Mercurial > hg > graal-jvmci-8
annotate src/share/vm/adlc/filebuff.cpp @ 558:3b5ac9e7e6ea
6796746: rename LoadC (char) opcode class to LoadUS (unsigned short)
Summary: Renaming LoadC to LoadUS would round up the planned introduction of LoadUB and LoadUI.
Reviewed-by: phh, kvn
author | twisti |
---|---|
date | Mon, 26 Jan 2009 16:22:12 +0100 |
parents | ad8c8ca4ab0f |
children | dbbe28fc66b5 |
rev | line source |
---|---|
0 | 1 /* |
470 | 2 * Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
21 * have any questions. | |
22 * | |
23 */ | |
24 | |
25 // FILEBUFF.CPP - Routines for handling a parser file buffer | |
26 #include "adlc.hpp" | |
27 | |
28 //------------------------------FileBuff--------------------------------------- | |
29 // Create a new parsing buffer | |
30 FileBuff::FileBuff( BufferedFile *fptr, ArchDesc& archDesc) : _fp(fptr), _AD(archDesc) { | |
31 _err = fseek(_fp->_fp, 0, SEEK_END); // Seek to end of file | |
32 if (_err) { | |
33 file_error(SEMERR, 0, "File seek error reading input file"); | |
34 exit(1); // Exit on seek error | |
35 } | |
36 _filepos = ftell(_fp->_fp); // Find offset of end of file | |
37 _bufferSize = _filepos + 5; // Filepos points to last char, so add padding | |
38 _err = fseek(_fp->_fp, 0, SEEK_SET); // Reset to beginning of file | |
39 if (_err) { | |
40 file_error(SEMERR, 0, "File seek error reading input file\n"); | |
41 exit(1); // Exit on seek error | |
42 } | |
43 _filepos = ftell(_fp->_fp); // Reset current file position | |
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
44 _linenum = 0; |
0 | 45 |
46 _bigbuf = new char[_bufferSize]; // Create buffer to hold text for parser | |
47 if( !_bigbuf ) { | |
48 file_error(SEMERR, 0, "Buffer allocation failed\n"); | |
49 exit(1); // Exit on allocation failure | |
50 } | |
51 *_bigbuf = '\n'; // Lead with a sentinal newline | |
52 _buf = _bigbuf+1; // Skip sentinal | |
53 _bufmax = _buf; // Buffer is empty | |
54 _bufeol = _bigbuf; // _bufeol points at sentinal | |
55 _filepos = -1; // filepos is in sync with _bufeol | |
56 _bufoff = _offset = 0L; // Offset at file start | |
57 | |
58 _bufmax += fread(_buf, 1, _bufferSize-2, _fp->_fp); // Fill buffer & set end value | |
59 if (_bufmax == _buf) { | |
60 file_error(SEMERR, 0, "File read error, no input read\n"); | |
61 exit(1); // Exit on read error | |
62 } | |
63 *_bufmax = '\n'; // End with a sentinal new-line | |
64 *(_bufmax+1) = '\0'; // Then end with a sentinal NULL | |
65 } | |
66 | |
67 //------------------------------~FileBuff-------------------------------------- | |
68 // Nuke the FileBuff | |
69 FileBuff::~FileBuff() { | |
70 delete _bigbuf; | |
71 } | |
72 | |
73 //------------------------------get_line---------------------------------------- | |
74 char *FileBuff::get_line(void) { | |
75 char *retval; | |
76 | |
77 // Check for end of file & return NULL | |
78 if (_bufeol >= _bufmax) return NULL; | |
79 | |
415
4d9884b01ba6
6754519: don't emit flag fixup for NaN when condition being tested doesn't need it
never
parents:
0
diff
changeset
|
80 _linenum++; |
0 | 81 retval = ++_bufeol; // return character following end of previous line |
82 if (*retval == '\0') return NULL; // Check for EOF sentinal | |
83 // Search for newline character which must end each line | |
84 for(_filepos++; *_bufeol != '\n'; _bufeol++) | |
85 _filepos++; // keep filepos in sync with _bufeol | |
86 // _bufeol & filepos point at end of current line, so return pointer to start | |
87 return retval; | |
88 } | |
89 | |
90 //------------------------------FileBuffRegion--------------------------------- | |
91 // Create a new region in a FileBuff. | |
92 FileBuffRegion::FileBuffRegion( FileBuff* bufr, int soln, int ln, | |
93 int off, int len) | |
94 : _bfr(bufr), _sol(soln), _line(ln), _offset(off), _length(len) { | |
95 _next = NULL; // No chained regions | |
96 } | |
97 | |
98 //------------------------------~FileBuffRegion-------------------------------- | |
99 // Delete the entire linked list of buffer regions. | |
100 FileBuffRegion::~FileBuffRegion() { | |
101 if( _next ) delete _next; | |
102 } | |
103 | |
104 //------------------------------copy------------------------------------------- | |
105 // Deep copy a FileBuffRegion | |
106 FileBuffRegion *FileBuffRegion::copy() { | |
107 if( !this ) return NULL; // The empty buffer region | |
108 FileBuffRegion *br = new FileBuffRegion(_bfr,_sol,_line,_offset,_length); | |
109 if( _next ) br->_next = _next->copy(); | |
110 return br; | |
111 } | |
112 | |
113 //------------------------------merge------------------------------------------ | |
114 // Merge another buffer region into this buffer region. Make overlapping areas | |
115 // become a single region. Remove (delete) the input FileBuffRegion. | |
116 // Since the buffer regions are sorted by file offset, this is a varient of a | |
117 // "sorted-merge" running in linear time. | |
118 FileBuffRegion *FileBuffRegion::merge( FileBuffRegion *br ) { | |
119 if( !br ) return this; // Merging nothing | |
120 if( !this ) return br; // Merging into nothing | |
121 | |
122 assert( _bfr == br->_bfr, "" ); // Check for pointer-equivalent buffers | |
123 | |
124 if( _offset < br->_offset ) { // "this" starts before "br" | |
125 if( _offset+_length < br->_offset ) { // "this" ends before "br" | |
126 if( _next ) _next->merge( br ); // Merge with remainder of list | |
127 else _next = br; // No more in this list; just append. | |
128 } else { // Regions overlap. | |
129 int l = br->_offset + br->_length - _offset; | |
130 if( l > _length ) _length = l; // Pick larger region | |
131 FileBuffRegion *nr = br->_next; // Get rest of region | |
132 br->_next = NULL; // Remove indication of rest of region | |
133 delete br; // Delete this region (it's been subsumed). | |
134 if( nr ) merge( nr ); // Merge with rest of region | |
135 } // End of if regions overlap or not. | |
136 } else { // "this" starts after "br" | |
137 if( br->_offset+br->_length < _offset ) { // "br" ends before "this" | |
138 FileBuffRegion *nr = new FileBuffRegion(_bfr,_sol,_line,_offset,_length); | |
139 nr->_next = _next; // Structure copy "this" guy to "nr" | |
140 *this = *br; // Structure copy "br" over "this". | |
141 br->_next = NULL; // Remove indication of rest of region | |
142 delete br; // Delete this region (it's been copied) | |
143 merge( nr ); // Finish merging | |
144 } else { // Regions overlap. | |
145 int l = _offset + _length - br->_offset; | |
146 if( l > _length ) _length = l; // Pick larger region | |
147 _offset = br->_offset; // Start with earlier region | |
148 _sol = br->_sol; // Also use earlier line start | |
149 _line = br->_line; // Also use earlier line | |
150 FileBuffRegion *nr = br->_next; // Get rest of region | |
151 br->_next = NULL; // Remove indication of rest of region | |
152 delete br; // Delete this region (it's been subsumed). | |
153 if( nr ) merge( nr ); // Merge with rest of region | |
154 } // End of if regions overlap or not. | |
155 } | |
156 return this; | |
157 } | |
158 | |
159 //------------------------------expandtab-------------------------------------- | |
160 static int expandtab( ostream &os, int off, char c, char fill1, char fill2 ) { | |
161 if( c == '\t' ) { // Tab? | |
162 do os << fill1; // Expand the tab; Output space | |
163 while( (++off) & 7 ); // Expand to tab stop | |
164 } else { // Normal character | |
165 os << fill2; // Display normal character | |
166 off++; // Increment "cursor" offset | |
167 } | |
168 return off; | |
169 } | |
170 | |
171 //------------------------------printline-------------------------------------- | |
172 // Print and highlite a region of a line. Return the amount of highliting left | |
173 // to do (i.e. highlite length minus length of line). | |
174 static int printline( ostream& os, const char *fname, int line, | |
175 const char *_sol, int skip, int len ) { | |
176 | |
177 // Display the entire tab-expanded line | |
178 os << fname << ":" << line << ": "; | |
179 const char *t = strchr(_sol,'\n')+1; // End of line | |
180 int off = 0; // Cursor offset for tab expansion | |
181 const char *s = _sol; // Nice string pointer | |
182 while( t-s ) { // Display whole line | |
183 char c = *s++; // Get next character to display | |
184 off = expandtab(os,off,c,' ',c); | |
185 } | |
186 | |
187 // Display the tab-expanded skippings before underlining. | |
188 os << fname << ":" << line << ": "; | |
189 off = 0; // Cursor offset for tab expansion | |
190 s = _sol; // Restart string pointer | |
191 | |
192 // Start underlining. | |
193 if( skip != -1 ) { // The no-start-indicating flag | |
194 const char *u = _sol+skip; // Amount to skip | |
195 while( u-s ) // Display skipped part | |
196 off = expandtab(os,off,*s++,' ',' '); | |
197 os << '^'; // Start region | |
198 off++; // Moved cursor | |
199 len--; // 1 less char to do | |
200 if( *s++ == '\t' ) // Starting character is a tab? | |
201 off = expandtab(os,off,'\t','-','^'); | |
202 } | |
203 | |
204 // Long region doesn't end on this line | |
205 int llen = (int)(t-s); // Length of line, minus what's already done | |
206 if( len > llen ) { // Doing entire rest of line? | |
207 while( t-s ) // Display rest of line | |
208 off = expandtab(os,off,*s++,'-','-'); | |
209 os << '\n'; // EOL | |
210 return len-llen; // Return what's not yet done. | |
211 } | |
212 | |
213 // Region does end on this line. This code fails subtly if the region ends | |
214 // in a tab character. | |
215 int i; | |
216 for( i=1; i<len; i++ ) // Underline just what's needed | |
217 off = expandtab(os,off,*s++,'-','-'); | |
218 if( i == len ) os << '^'; // Mark end of region | |
219 os << '\n'; // End of marked line | |
220 return 0L; // All done | |
221 } | |
222 | |
223 //------------------------------print------------------------------------------ | |
224 //std::ostream& operator<< ( std::ostream& os, FileBuffRegion &br ) { | |
225 ostream& operator<< ( ostream& os, FileBuffRegion &br ) { | |
226 if( &br == NULL ) return os; // The empty buffer region | |
227 FileBuffRegion *brp = &br; // Pointer to region | |
228 while( brp ) { // While have chained regions | |
229 brp->print(os); // Print region | |
230 brp = brp->_next; // Chain to next | |
231 } | |
232 return os; // Return final stream | |
233 } | |
234 | |
235 //------------------------------print------------------------------------------ | |
236 // Print the FileBuffRegion to a stream. FileBuffRegions are printed with the | |
237 // filename and line number to the left, and complete text lines to the right. | |
238 // Selected portions (portions of a line actually in the FileBuffRegion are | |
239 // underlined. Ellipses are used for long multi-line regions. | |
240 //void FileBuffRegion::print( std::ostream& os ) { | |
241 void FileBuffRegion::print( ostream& os ) { | |
242 if( !this ) return; // Nothing to print | |
243 char *s = _bfr->get_line(); | |
244 int skip = (int)(_offset - _sol); // Amount to skip to start of data | |
245 int len = printline( os, _bfr->_fp->_name, _line, s, skip, _length ); | |
246 | |
247 if( !len ) return; // All done; exit | |
248 | |
249 // Here we require at least 2 lines | |
250 int off1 = _length - len + skip; // Length of line 1 | |
251 int off2 = off1 + _sol; // Offset to start of line 2 | |
252 char *s2 = _bfr->get_line(); // Start of line 2 | |
253 char *s3 = strchr( s2, '\n' )+1; // Start of line 3 (unread) | |
254 if( len <= (s3-s2) ) { // It all fits on the next line | |
255 printline( os, _bfr->_fp->_name, _line+1, s2, -1, len ); // Print&underline | |
256 return; | |
257 } | |
258 | |
259 // Here we require at least 3 lines | |
260 int off3 = off2 + (int)(s3-s2); // Offset to start of line 3 | |
261 s3 = _bfr->get_line(); // Start of line 3 (read) | |
262 const char *s4 = strchr( s3, '\n' )+1;// Start of line 4 (unread) | |
263 if( len < (s4-s3) ) { // It all fits on the next 2 lines | |
264 s2 = _bfr->get_line(); | |
265 len = printline( os, _bfr->_fp->_name, _line+1, s2, -1, len ); // Line 2 | |
266 s3 = _bfr->get_line(); | |
267 printline( os, _bfr->_fp->_name, _line+2, s3, -1, len ); // Line 3 | |
268 return; | |
269 } | |
270 | |
271 // Here we require at least 4 lines. | |
272 // Print only the 1st and last line, with ellipses in middle. | |
273 os << "...\n"; // The ellipses | |
274 int cline = _line+1; // Skipped 2 lines | |
275 do { // Do until find last line | |
276 len -= (int)(s3-s2); // Remove length of line | |
277 cline++; // Next line | |
278 s2 = _bfr->get_line(); // Get next line from end of this line | |
279 s3 = strchr( s2, '\n' ) + 1;// Get end of next line | |
280 } while( len > (s3-s2) ); // Repeat until last line | |
281 printline( os, _bfr->_fp->_name, cline, s2, -1, len ); // Print & underline | |
282 } | |
283 | |
284 //------------------------------file_error------------------------------------- | |
285 void FileBuff::file_error(int flag, int linenum, const char *fmt, ...) | |
286 { | |
287 va_list args; | |
288 | |
289 va_start(args, fmt); | |
290 switch (flag) { | |
291 case 0: _AD._warnings += _AD.emit_msg(0, flag, linenum, fmt, args); | |
292 case 1: _AD._syntax_errs += _AD.emit_msg(0, flag, linenum, fmt, args); | |
293 case 2: _AD._semantic_errs += _AD.emit_msg(0, flag, linenum, fmt, args); | |
294 default: assert(0, ""); break; | |
295 } | |
296 va_end(args); | |
297 _AD._no_output = 1; | |
298 } |