*** old/src/share/vm/adlc/filebuff.cpp	Mon May  5 12:28:27 2014
--- new/src/share/vm/adlc/filebuff.cpp	Mon May  5 12:28:26 2014

*** 1,7 ****
--- 1,7 ----
  /*
!  * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
!  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. 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.

*** 23,34 ****
--- 23,32 ----
   */
  
  // FILEBUFF.CPP - Routines for handling a parser file buffer
  #include "adlc.hpp"
  
  using namespace std;
  
  //------------------------------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) {

*** 87,290 ****
--- 85,94 ----
      _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 0;                     // 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;