--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/share/vm/adlc/filebuff.cpp	Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,296 @@
+/*
+ * Copyright 1997-2002 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// FILEBUFF.CPP - Routines for handling a parser file buffer
+#include "adlc.hpp"
+
+//------------------------------FileBuff---------------------------------------
+// Create a new parsing buffer
+FileBuff::FileBuff( BufferedFile *fptr, ArchDesc& archDesc) : _fp(fptr), _AD(archDesc) {
+  _err = fseek(_fp->_fp, 0, SEEK_END);  // Seek to end of file
+  if (_err) {
+    file_error(SEMERR, 0, "File seek error reading input file");
+    exit(1);                    // Exit on seek error
+  }
+  _filepos = ftell(_fp->_fp);   // Find offset of end of file
+  _bufferSize = _filepos + 5;   // Filepos points to last char, so add padding
+  _err = fseek(_fp->_fp, 0, SEEK_SET);  // Reset to beginning of file
+  if (_err) {
+    file_error(SEMERR, 0, "File seek error reading input file\n");
+    exit(1);                    // Exit on seek error
+  }
+  _filepos = ftell(_fp->_fp);      // Reset current file position
+
+  _bigbuf = new char[_bufferSize]; // Create buffer to hold text for parser
+  if( !_bigbuf ) {
+    file_error(SEMERR, 0, "Buffer allocation failed\n");
+    exit(1);                    // Exit on allocation failure
+  }
+  *_bigbuf = '\n';               // Lead with a sentinal newline
+  _buf = _bigbuf+1;                     // Skip sentinal
+  _bufmax = _buf;               // Buffer is empty
+  _bufeol = _bigbuf;              // _bufeol points at sentinal
+  _filepos = -1;                 // filepos is in sync with _bufeol
+  _bufoff = _offset = 0L;       // Offset at file start
+
+  _bufmax += fread(_buf, 1, _bufferSize-2, _fp->_fp); // Fill buffer & set end value
+  if (_bufmax == _buf) {
+    file_error(SEMERR, 0, "File read error, no input read\n");
+    exit(1);                     // Exit on read error
+  }
+  *_bufmax = '\n';               // End with a sentinal new-line
+  *(_bufmax+1) = '\0';           // Then end with a sentinal NULL
+}
+
+//------------------------------~FileBuff--------------------------------------
+// Nuke the FileBuff
+FileBuff::~FileBuff() {
+  delete _bigbuf;
+}
+
+//------------------------------get_line----------------------------------------
+char *FileBuff::get_line(void) {
+  char *retval;
+
+  // Check for end of file & return NULL
+  if (_bufeol >= _bufmax) return NULL;
+
+  retval = ++_bufeol;      // return character following end of previous line
+  if (*retval == '\0') return NULL; // Check for EOF sentinal
+  // Search for newline character which must end each line
+  for(_filepos++; *_bufeol != '\n'; _bufeol++)
+    _filepos++;                    // keep filepos in sync with _bufeol
+  // _bufeol & filepos point at end of current line, so return pointer to start
+  return retval;
+}
+
+//------------------------------FileBuffRegion---------------------------------
+// Create a new region in a FileBuff.
+FileBuffRegion::FileBuffRegion( FileBuff* bufr, int soln, int ln,
+                                int off, int len)
+: _bfr(bufr), _sol(soln), _line(ln), _offset(off), _length(len) {
+  _next = NULL;                 // No chained regions
+}
+
+//------------------------------~FileBuffRegion--------------------------------
+// Delete the entire linked list of buffer regions.
+FileBuffRegion::~FileBuffRegion() {
+  if( _next ) delete _next;
+}
+
+//------------------------------copy-------------------------------------------
+// Deep copy a FileBuffRegion
+FileBuffRegion *FileBuffRegion::copy() {
+  if( !this ) return NULL;      // The empty buffer region
+  FileBuffRegion *br = new FileBuffRegion(_bfr,_sol,_line,_offset,_length);
+  if( _next ) br->_next = _next->copy();
+  return br;
+}
+
+//------------------------------merge------------------------------------------
+// Merge another buffer region into this buffer region.  Make overlapping areas
+// become a single region.  Remove (delete) the input FileBuffRegion.
+// Since the buffer regions are sorted by file offset, this is a varient of a
+// "sorted-merge" running in linear time.
+FileBuffRegion *FileBuffRegion::merge( FileBuffRegion *br ) {
+  if( !br ) return this;        // Merging nothing
+  if( !this ) return br;        // Merging into nothing
+
+  assert( _bfr == br->_bfr, "" );     // Check for pointer-equivalent buffers
+
+  if( _offset < br->_offset ) { // "this" starts before "br"
+    if( _offset+_length < br->_offset ) { // "this" ends before "br"
+      if( _next ) _next->merge( br );    // Merge with remainder of list
+      else _next = br;                 // No more in this list; just append.
+    } else {                           // Regions overlap.
+      int l = br->_offset + br->_length - _offset;
+      if( l > _length ) _length = l;     // Pick larger region
+      FileBuffRegion *nr = br->_next;     // Get rest of region
+      br->_next = NULL;         // Remove indication of rest of region
+      delete br;                // Delete this region (it's been subsumed).
+      if( nr ) merge( nr );     // Merge with rest of region
+    }                           // End of if regions overlap or not.
+  } else {                      // "this" starts after "br"
+    if( br->_offset+br->_length < _offset ) {    // "br" ends before "this"
+      FileBuffRegion *nr = new FileBuffRegion(_bfr,_sol,_line,_offset,_length);
+      nr->_next = _next;                // Structure copy "this" guy to "nr"
+      *this = *br;              // Structure copy "br" over "this".
+      br->_next = NULL;         // Remove indication of rest of region
+      delete br;                // Delete this region (it's been copied)
+      merge( nr );              // Finish merging
+    } else {                    // Regions overlap.
+      int l = _offset + _length - br->_offset;
+      if( l > _length ) _length = l;    // Pick larger region
+      _offset = br->_offset;            // Start with earlier region
+      _sol = br->_sol;                  // Also use earlier line start
+      _line = br->_line;                        // Also use earlier line
+      FileBuffRegion *nr = br->_next;   // Get rest of region
+      br->_next = NULL;         // Remove indication of rest of region
+      delete br;                // Delete this region (it's been subsumed).
+      if( nr ) merge( nr );     // Merge with rest of region
+    }                           // End of if regions overlap or not.
+  }
+  return this;
+}
+
+//------------------------------expandtab--------------------------------------
+static int expandtab( ostream &os, int off, char c, char fill1, char fill2 ) {
+  if( c == '\t' ) {             // Tab?
+    do os << fill1;             // Expand the tab; Output space
+    while( (++off) & 7 );       // Expand to tab stop
+  } else {                      // Normal character
+    os << fill2;                // Display normal character
+    off++;                      // Increment "cursor" offset
+  }
+  return off;
+}
+
+//------------------------------printline--------------------------------------
+// Print and highlite a region of a line.  Return the amount of highliting left
+// to do (i.e. highlite length minus length of line).
+static int printline( ostream& os, const char *fname, int line,
+                        const char *_sol, int skip, int len ) {
+
+  // Display the entire tab-expanded line
+  os << fname << ":" << line << ": ";
+  const char *t = strchr(_sol,'\n')+1; // End of line
+  int off = 0;                  // Cursor offset for tab expansion
+  const char *s = _sol;         // Nice string pointer
+  while( t-s ) {                // Display whole line
+    char c = *s++;              // Get next character to display
+    off = expandtab(os,off,c,' ',c);
+  }
+
+  // Display the tab-expanded skippings before underlining.
+  os << fname << ":" << line << ": ";
+  off = 0;                      // Cursor offset for tab expansion
+  s = _sol;                     // Restart string pointer
+
+  // Start underlining.
+  if( skip != -1 ) {            // The no-start-indicating flag
+    const char *u = _sol+skip;  // Amount to skip
+    while( u-s )                // Display skipped part
+      off = expandtab(os,off,*s++,' ',' ');
+    os << '^';                  // Start region
+    off++;                      // Moved cursor
+    len--;                      // 1 less char to do
+    if( *s++ == '\t' )          // Starting character is a tab?
+      off = expandtab(os,off,'\t','-','^');
+  }
+
+  // Long region doesn't end on this line
+  int llen = (int)(t-s);        // Length of line, minus what's already done
+  if( len > llen ) {            // Doing entire rest of line?
+    while( t-s )                // Display rest of line
+      off = expandtab(os,off,*s++,'-','-');
+    os << '\n';                 // EOL
+    return len-llen;            // Return what's not yet done.
+  }
+
+  // Region does end on this line.  This code fails subtly if the region ends
+  // in a tab character.
+  int i;
+  for( i=1; i<len; i++ )        // Underline just what's needed
+    off = expandtab(os,off,*s++,'-','-');
+  if( i == len ) os << '^';     // Mark end of region
+  os << '\n';                   // End of marked line
+  return 0L;                    // All done
+}
+
+//------------------------------print------------------------------------------
+//std::ostream& operator<< ( std::ostream& os, FileBuffRegion &br ) {
+ostream& operator<< ( ostream& os, FileBuffRegion &br ) {
+  if( &br == NULL ) return os;  // The empty buffer region
+  FileBuffRegion *brp = &br;    // Pointer to region
+  while( brp ) {                // While have chained regions
+    brp->print(os);             // Print region
+    brp = brp->_next;           // Chain to next
+  }
+  return os;                    // Return final stream
+}
+
+//------------------------------print------------------------------------------
+// Print the FileBuffRegion to a stream. FileBuffRegions are printed with the
+// filename and line number to the left, and complete text lines to the right.
+// Selected portions (portions of a line actually in the FileBuffRegion are
+// underlined.  Ellipses are used for long multi-line regions.
+//void FileBuffRegion::print( std::ostream& os ) {
+void FileBuffRegion::print( ostream& os ) {
+  if( !this ) return;           // Nothing to print
+  char *s = _bfr->get_line();
+  int skip = (int)(_offset - _sol);     // Amount to skip to start of data
+  int len = printline( os, _bfr->_fp->_name, _line, s, skip, _length );
+
+  if( !len ) return;                    // All done; exit
+
+  // Here we require at least 2 lines
+  int off1 = _length - len + skip;      // Length of line 1
+  int off2 = off1 + _sol;               // Offset to start of line 2
+  char *s2 = _bfr->get_line();           // Start of line 2
+  char *s3 = strchr( s2, '\n' )+1;      // Start of line 3 (unread)
+  if( len <= (s3-s2) ) {                // It all fits on the next line
+    printline( os, _bfr->_fp->_name, _line+1, s2, -1, len ); // Print&underline
+    return;
+  }
+
+  // Here we require at least 3 lines
+  int off3 = off2 + (int)(s3-s2);       // Offset to start of line 3
+  s3 = _bfr->get_line();                // Start of line 3 (read)
+  const char *s4 = strchr( s3, '\n' )+1;// Start of line 4 (unread)
+  if( len < (s4-s3) ) {                 // It all fits on the next 2 lines
+    s2 = _bfr->get_line();
+    len = printline( os, _bfr->_fp->_name, _line+1, s2, -1, len ); // Line 2
+    s3 = _bfr->get_line();
+    printline( os, _bfr->_fp->_name, _line+2, s3, -1, len );     // Line 3
+    return;
+  }
+
+  // Here we require at least 4 lines.
+  // Print only the 1st and last line, with ellipses in middle.
+  os << "...\n";                // The ellipses
+  int cline = _line+1;          // Skipped 2 lines
+  do {                          // Do until find last line
+    len -= (int)(s3-s2);        // Remove length of line
+    cline++;                    // Next line
+    s2 = _bfr->get_line();      // Get next line from end of this line
+    s3 = strchr( s2, '\n' ) + 1;// Get end of next line
+  } while( len > (s3-s2) );     // Repeat until last line
+  printline( os, _bfr->_fp->_name, cline, s2, -1, len ); // Print & underline
+}
+
+//------------------------------file_error-------------------------------------
+void FileBuff::file_error(int flag, int linenum, const char *fmt, ...)
+{
+  va_list args;
+
+  va_start(args, fmt);
+  switch (flag) {
+  case 0: _AD._warnings += _AD.emit_msg(0, flag, linenum, fmt, args);
+  case 1: _AD._syntax_errs += _AD.emit_msg(0, flag, linenum, fmt, args);
+  case 2: _AD._semantic_errs += _AD.emit_msg(0, flag, linenum, fmt, args);
+  default: assert(0, ""); break;
+  }
+  va_end(args);
+  _AD._no_output = 1;
+}