home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 20 / AACD20.BIN / AACD / Programming / Jikes / Source / src / stream.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-03-03  |  41.7 KB  |  1,310 lines
  1. // $Id: stream.cpp,v 1.48 2001/02/20 07:47:03 mdejong Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10.  
  11. #include "stream.h"
  12. #include "code.h"
  13. #include "zip.h"
  14. #include "symbol.h"
  15. #include "control.h"
  16. #include "semantic.h"
  17.  
  18. #ifdef HAVE_CTYPE_H
  19. #include <ctype.h>
  20. #endif
  21.  
  22. #if defined(HAVE_LIB_ICU_UC)
  23. #ifdef ICU131
  24. # include <ucnv.h>
  25. #else
  26. # include <unicode/ucnv.h>
  27. #endif
  28. #elif defined(HAVE_ICONV_H)
  29. # include <iconv.h>
  30. # include <errno.h>
  31. #endif
  32.  
  33. #ifdef    HAVE_JIKES_NAMESPACE
  34. namespace Jikes {    // Open namespace Jikes block
  35. #endif
  36.  
  37. // Class StreamError
  38.  
  39. JikesError::JikesErrorSeverity StreamError::getSeverity        () 
  40. { 
  41.     //All Lexical errors are ERRORs.
  42.     return JikesError::JIKES_ERROR; 
  43. }
  44.  
  45. int StreamError::getLeftLineNo      () { return left_line_no    ; }
  46. int StreamError::getLeftColumnNo    () { return left_column_no  ; }
  47. int StreamError::getRightLineNo     () { return right_line_no   ; }
  48. int StreamError::getRightColumnNo   () { return right_column_no ; }
  49.  
  50. const char *StreamError::getFileName() 
  51. { 
  52.     assert(lex_stream);
  53.     return lex_stream -> FileName();   
  54. }
  55.  
  56. const wchar_t *StreamError::getErrorMessage() 
  57. {
  58.     switch(kind)
  59.     {
  60.     case StreamError::BAD_TOKEN:
  61.         return L"Illegal token\n";
  62.         break;
  63.     case StreamError::BAD_OCTAL_CONSTANT:
  64.         return L"Octal constant contains invalid digit\n";
  65.         break;
  66.     case StreamError::EMPTY_CHARACTER_CONSTANT:
  67.         return L"Empty character constant\n";
  68.         break;
  69.     case StreamError::UNTERMINATED_CHARACTER_CONSTANT:
  70.         return L"Character constant not properly terminated\n";
  71.         break;
  72.     case StreamError::UNTERMINATED_COMMENT:
  73.         return L"Comment not properly terminated\n";
  74.         break;
  75.     case StreamError::UNTERMINATED_STRING_CONSTANT:
  76.         return L"String constant not properly terminated\n";
  77.         break;
  78.     case StreamError::INVALID_HEX_CONSTANT:
  79.         return L"The prefix 0x must be followed by at least one hex digit\n";
  80.         break;
  81.     case StreamError::INVALID_FLOATING_CONSTANT_EXPONENT:
  82.         return L"floating-constant exponent has no digit\n";
  83.         break;
  84.     case StreamError::INVALID_UNICODE_ESCAPE:
  85.         return L"Invalid unicode escape character\n";
  86.         break;
  87.     default:
  88.         assert(false);
  89.     }
  90.  
  91.     return L"Unknown Error\n";
  92. }
  93.  
  94. bool StreamError::emacs_style_report=false;
  95.  
  96. const wchar_t *StreamError::getErrorReport() 
  97. {
  98.     /*
  99.      * We need to use this lazy initialization,
  100.      * because we can't to it in Initialize() method. Reason
  101.      * is that Find* methods are unusalble until
  102.      * LexStream::CompressSpace is called, which
  103.      * is not happend until later after scanning is done
  104.      * and all errors are reported.
  105.      * (lord)
  106.      */
  107.     if(!initialized)
  108.     {
  109.         left_line_no    = lex_stream->FindLine   ( start_location );
  110.         left_column_no  = lex_stream->FindColumn ( start_location );
  111.         right_line_no   = lex_stream->FindLine   ( end_location   );
  112.         right_column_no = lex_stream->FindColumn ( end_location   );
  113.         initialized     = true;
  114.     }
  115.  
  116.     return emacs_style_report?emacsErrorString():regularErrorString();
  117. }
  118.  
  119. wchar_t *StreamError::emacsErrorString()
  120. {
  121.     ErrorString s;
  122.  
  123.     s << getFileName()
  124.       << ':' << left_line_no  << ':' << left_column_no
  125.       << ':' << right_line_no << ':' << right_column_no
  126.       << ": Lexical: " << getErrorMessage();
  127.     
  128.     return s.Array();    
  129. }
  130.  
  131.  
  132. wchar_t *StreamError::regularErrorString() 
  133. {
  134.     ErrorString s;
  135.  
  136.     assert(lex_stream);
  137.     if(left_line_no == right_line_no)
  138.         PrintSmallSource(s);
  139.     else 
  140.         PrintLargeSource(s);
  141.     
  142.     s << "\n*** Lexical Error: "
  143.       << getErrorMessage();
  144.         
  145.     return s.Array();
  146. }
  147.  
  148. //
  149. // This procedure is invoked to print a small message that may
  150. // only span a single line. The parameter k points to the error
  151. // message in the error structure.
  152. //
  153. void StreamError::PrintSmallSource(ErrorString &s)
  154. {
  155.     s << "\n\n";
  156.     s.width(6);
  157.     s << left_line_no;
  158.     s << ". ";
  159.     for (int i = lex_stream->LineStart(left_line_no); i <= lex_stream->LineEnd(left_line_no); i++)
  160.         s << lex_stream->InputBuffer()[i];
  161.  
  162.     s.width(left_column_no + 7);
  163.     s << "";
  164.     if (left_column_no == right_column_no)
  165.         s << '^';
  166.     else
  167.     {
  168.         int offset = 0;
  169.         for (size_t i = start_location; i <= end_location; i++)
  170.         {
  171.             if (lex_stream->InputBuffer()[i] > 0xff)
  172.                 offset += 5;
  173.         }
  174.  
  175.         s << '<';
  176.         s.width(right_column_no - left_column_no + offset);
  177.         s.fill('-');
  178.         s << ">";
  179.         s.fill(' ');
  180.     }
  181. }
  182.  
  183.  
  184. //
  185. // This procedure is invoked to print a large message that may
  186. // span more than one line. The parameter message points to the
  187. // starting line. The parameter k points to the error message in
  188. // the error structure.
  189. //
  190. void StreamError::PrintLargeSource(ErrorString &s)
  191. {
  192.     if (left_line_no == right_line_no)
  193.     {
  194.         if (left_line_no == 0)
  195.             s << "\n";
  196.         else
  197.         {
  198.             s << "\n\n";
  199.             s.width(6);
  200.             s << left_line_no << ". ";
  201.             for (int i = lex_stream -> LineStart(left_line_no); i <= lex_stream -> LineEnd(left_line_no); i++)
  202.                 s << lex_stream -> InputBuffer()[i];
  203.  
  204.             int offset = 0;
  205.             for (size_t j = start_location; j <= end_location; j++)
  206.             {
  207.                 if (lex_stream -> InputBuffer()[j] > 0xff)
  208.                     offset += 5;
  209.             }
  210.  
  211.             s.width(left_column_no + 8);
  212.             s << "<";
  213.             s.width(right_column_no - left_column_no + offset);
  214.             s.fill('-');
  215.             s << ">";
  216.             s.fill(' ');
  217.         }
  218.     }
  219.     else
  220.     {
  221.         s << "\n\n";
  222.         s.width(left_column_no + 8);
  223.         s << "<";
  224.         
  225.         int segment_size = Tab::Wcslen(lex_stream->input_buffer, start_location,
  226.                                        lex_stream->LineEnd(lex_stream->FindLine(start_location)));
  227.         s.width(segment_size - 1);
  228.         s.fill('-');
  229.         s << "\n";
  230.         s.fill(' ');
  231.  
  232.         s.width(6);
  233.         s << left_line_no << ". ";
  234.         for (int i = lex_stream -> LineStart(left_line_no); i <= lex_stream -> LineEnd(left_line_no); i++)
  235.             s << lex_stream -> InputBuffer()[i];
  236.  
  237.         if (right_line_no > left_line_no + 1)
  238.         {
  239.             s.width(left_column_no + 7);
  240.             s << " ";
  241.             s << ". . .\n";
  242.         }
  243.  
  244.         s.width(6);
  245.         s << right_line_no << ". ";
  246.  
  247.         int offset = 0;
  248.         for (int j = lex_stream -> LineStart(right_line_no); j <= lex_stream -> LineEnd(right_line_no); j++)
  249.         {
  250.             wchar_t c = lex_stream -> InputBuffer()[j];
  251.             if (c > 0xff)
  252.                 offset += 5;
  253.             s << c;
  254.         }
  255.  
  256.         s.width(8);
  257.         s << "";
  258.         s.width(right_column_no - 1 + offset);
  259.         s.fill('-');
  260.         s << ">";
  261.         s.fill(' ');
  262.     }
  263. }
  264.  
  265. void StreamError::Initialize(StreamErrorKind kind_, unsigned start_location_, unsigned end_location_, LexStream *l)
  266. {
  267.     kind           = kind_           ;
  268.     start_location = start_location_ ;
  269.     end_location   = end_location_   ;
  270.     lex_stream     = l               ;
  271. }
  272.  
  273. StreamError::StreamError():initialized(false)
  274. {
  275. }
  276.  
  277.  
  278. // Class Stream
  279.  
  280. Stream::Stream()
  281. :   input_buffer(NULL),
  282.     input_buffer_length(0)
  283. #if defined(HAVE_LIB_ICU_UC)
  284.     ,_converter(NULL)
  285. #elif defined(HAVE_ICONV_H)
  286.     ,_converter((iconv_t)-1)
  287. #endif
  288. {
  289. }
  290.  
  291. Stream::~Stream()
  292. {
  293.     DestroyInput();
  294. #if defined(HAVE_LIB_ICU_UC) || defined(HAVE_ICONV_H)
  295.     DestroyEncoding();
  296. #endif
  297. }
  298.  
  299. #if defined(HAVE_LIB_ICU_UC) || defined(HAVE_ICONV_H)
  300.  
  301. // This method will return true is the given encoding
  302. // can be supported, it is static because we need to
  303. // be able to query encodings without an instance.
  304.  
  305. bool Stream::IsSupportedEncoding(char* encoding)
  306. {
  307.     bool supported;
  308.     // Create a tmp object instead of duplicating
  309.     // the code in SetEncoding and DestroyEncoding
  310.     Stream* tmp = new Stream();
  311.     supported = tmp->SetEncoding(encoding);
  312.     delete tmp;
  313.     return supported;
  314. }
  315.  
  316. bool Stream::SetEncoding(char* encoding)
  317. {
  318.     assert(encoding);
  319.     DestroyEncoding();
  320.  
  321. #if defined(HAVE_LIB_ICU_UC)
  322.     UErrorCode err = U_ZERO_ERROR;
  323.  
  324.     _converter = ucnv_open(encoding, &err);
  325.     if (!_converter)
  326.     {
  327.         return false;
  328.     }
  329.     else {
  330.         return true;
  331.     }
  332. #elif defined(HAVE_ICONV_H)
  333.     _converter = iconv_open("utf-16", encoding);
  334.     if (_converter == (iconv_t)-1)
  335.     {
  336.         return false;
  337.     }
  338.     else
  339.     {
  340.         return true;
  341.     }
  342. #endif
  343. }
  344.  
  345. void Stream::DestroyEncoding()
  346. {
  347. #if defined(HAVE_LIB_ICU_UC)
  348.     if (_converter)
  349.     {
  350.         ucnv_close(_converter);
  351.         _converter = NULL;
  352.     }
  353. #elif defined(HAVE_ICONV_H)
  354.     if (_converter != (iconv_t)-1)
  355.     {
  356.         iconv_close(_converter);
  357.         _converter = (iconv_t)-1;
  358.     }
  359. #endif
  360. }
  361.  
  362. #endif // defined(HAVE_LIB_ICU_UC) || defined(HAVE_ICONV_H)
  363.  
  364.  
  365. // Class LexStream
  366.  
  367. LexStream::LexStream(Control &control_, FileSymbol *file_symbol_) : file_symbol(file_symbol_),
  368. #ifdef JIKES_DEBUG
  369.     file_read(0),
  370. #endif
  371.     tokens(NULL),
  372.     columns(NULL),
  373.     token_stream(12, 16),
  374.     comments(NULL),
  375.     comment_stream(10, 8),
  376.     locations(NULL),
  377.     line_location(12, 8),
  378.     initial_reading_of_input(true),
  379.     comment_buffer(NULL),
  380.     control(control_)
  381. {
  382.     StreamError::emacs_style_report=!control_.option.errors;
  383. }
  384.  
  385. wchar_t *LexStream::KeywordName(int kind)
  386. {
  387.     switch(kind)
  388.     {
  389.         case TK_abstract:     return StringConstant::US_abstract; break;
  390.         case TK_boolean:      return StringConstant::US_boolean;  break;
  391.         case TK_break:        return StringConstant::US_break;    break;
  392.         case TK_byte:         return StringConstant::US_byte;     break;
  393.         case TK_case:         return StringConstant::US_case; break;
  394.         case TK_catch:        return StringConstant::US_catch; break;
  395.         case TK_char:         return StringConstant::US_char; break;
  396.         case TK_class:        return StringConstant::US_class; break;
  397.         case TK_const:        return StringConstant::US_const; break;
  398.         case TK_continue:     return StringConstant::US_continue; break;
  399.         case TK_default:      return StringConstant::US_default; break;
  400.         case TK_do:           return StringConstant::US_do; break;
  401.         case TK_double:       return StringConstant::US_double; break;
  402.         case TK_else:         return StringConstant::US_else; break;
  403.         case TK_extends:      return StringConstant::US_extends; break;
  404.         case TK_false:        return StringConstant::US_false; break;
  405.         case TK_final:        return StringConstant::US_final; break;
  406.         case TK_finally:      return StringConstant::US_finally; break;
  407.         case TK_float:        return StringConstant::US_float; break;
  408.         case TK_for:          return StringConstant::US_for; break;
  409.         case TK_goto:         return StringConstant::US_goto; break;
  410.         case TK_if:           return StringConstant::US_if; break;
  411.         case TK_implements:   return StringConstant::US_implements; break;
  412.         case TK_import:       return StringConstant::US_import; break;
  413.         case TK_instanceof:   return StringConstant::US_instanceof; break;
  414.         case TK_int:          return StringConstant::US_int; break;
  415.         case TK_interface:    return StringConstant::US_interface; break;
  416.         case TK_long:         return StringConstant::US_long; break;
  417.         case TK_native:       return StringConstant::US_native; break;
  418.         case TK_new:          return StringConstant::US_new; break;
  419.         case TK_null:         return StringConstant::US_null; break;
  420.         case TK_package:      return StringConstant::US_package; break;
  421.         case TK_private:      return StringConstant::US_private; break;
  422.         case TK_protected:    return StringConstant::US_protected; break;
  423.         case TK_public:       return StringConstant::US_public; break;
  424.         case TK_return:       return StringConstant::US_return; break;
  425.         case TK_short:        return StringConstant::US_short; break;
  426.         case TK_static:       return StringConstant::US_static; break;
  427.         case TK_strictfp:     return StringConstant::US_strictfp; break;
  428.         case TK_super:        return StringConstant::US_super; break;
  429.         case TK_switch:       return StringConstant::US_switch; break;
  430.         case TK_synchronized: return StringConstant::US_synchronized; break;
  431.         case TK_this:         return StringConstant::US_this; break;
  432.         case TK_throw:        return StringConstant::US_throw; break;
  433.         case TK_throws:       return StringConstant::US_throws; break;
  434.         case TK_transient:    return StringConstant::US_transient; break;
  435.         case TK_true:         return StringConstant::US_true; break;
  436.         case TK_try:          return StringConstant::US_try; break;
  437.         case TK_void:         return StringConstant::US_void; break;
  438.         case TK_volatile:     return StringConstant::US_volatile; break;
  439.         case TK_while:        return StringConstant::US_while; break;
  440.  
  441.         case TK_PLUS_PLUS:                  return StringConstant::US_PLUS_PLUS; break;
  442.         case TK_MINUS_MINUS:                return StringConstant::US_MINUS_MINUS; break;
  443.         case TK_EQUAL_EQUAL:                return StringConstant::US_EQUAL_EQUAL; break;
  444.         case TK_LESS_EQUAL:                 return StringConstant::US_LESS_EQUAL; break;
  445.         case TK_GREATER_EQUAL:              return StringConstant::US_GREATER_EQUAL; break;
  446.         case TK_NOT_EQUAL:                  return StringConstant::US_NOT_EQUAL; break;
  447.         case TK_LEFT_SHIFT:                 return StringConstant::US_LEFT_SHIFT; break;
  448.         case TK_RIGHT_SHIFT:                return StringConstant::US_RIGHT_SHIFT; break;
  449.         case TK_UNSIGNED_RIGHT_SHIFT:       return StringConstant::US_UNSIGNED_RIGHT_SHIFT; break;
  450.         case TK_PLUS_EQUAL:                 return StringConstant::US_PLUS_EQUAL; break;
  451.         case TK_MINUS_EQUAL:                return StringConstant::US_MINUS_EQUAL; break;
  452.         case TK_MULTIPLY_EQUAL:             return StringConstant::US_MULTIPLY_EQUAL; break;
  453.         case TK_DIVIDE_EQUAL:               return StringConstant::US_DIVIDE_EQUAL; break;
  454.         case TK_AND_EQUAL:                  return StringConstant::US_AND_EQUAL; break;
  455.         case TK_OR_EQUAL:                   return StringConstant::US_OR_EQUAL; break;
  456.         case TK_XOR_EQUAL:                  return StringConstant::US_XOR_EQUAL; break;
  457.         case TK_REMAINDER_EQUAL:            return StringConstant::US_REMAINDER_EQUAL; break;
  458.         case TK_LEFT_SHIFT_EQUAL:           return StringConstant::US_LEFT_SHIFT_EQUAL; break;
  459.         case TK_RIGHT_SHIFT_EQUAL:          return StringConstant::US_RIGHT_SHIFT_EQUAL; break;
  460.         case TK_UNSIGNED_RIGHT_SHIFT_EQUAL: return StringConstant::US_UNSIGNED_RIGHT_SHIFT_EQUAL; break;
  461.         case TK_OR_OR:                      return StringConstant::US_OR_OR; break;
  462.         case TK_AND_AND:                    return StringConstant::US_AND_AND; break;
  463.  
  464.         case TK_PLUS:                       return StringConstant::US_PLUS; break;
  465.         case TK_MINUS:                      return StringConstant::US_MINUS; break;
  466.         case TK_NOT:                        return StringConstant::US_NOT; break;
  467.         case TK_REMAINDER:                  return StringConstant::US_REMAINDER; break;
  468.         case TK_XOR:                        return StringConstant::US_XOR; break;
  469.         case TK_AND:                        return StringConstant::US_AND; break;
  470.         case TK_MULTIPLY:                   return StringConstant::US_MULTIPLY; break;
  471.         case TK_OR:                         return StringConstant::US_OR; break;
  472.         case TK_TWIDDLE:                    return StringConstant::US_TWIDDLE; break;
  473.         case TK_DIVIDE:                     return StringConstant::US_DIVIDE; break;
  474.         case TK_GREATER:                    return StringConstant::US_GREATER; break;
  475.         case TK_LESS:                       return StringConstant::US_LESS; break;
  476.         case TK_LPAREN:                     return StringConstant::US_LPAREN; break;
  477.         case TK_RPAREN:                     return StringConstant::US_RPAREN; break;
  478.         case TK_LBRACE:                     return StringConstant::US_LBRACE; break;
  479.         case TK_RBRACE:                     return StringConstant::US_RBRACE; break;
  480.         case TK_LBRACKET:                   return StringConstant::US_LBRACKET; break;
  481.         case TK_RBRACKET:                   return StringConstant::US_RBRACKET; break;
  482.         case TK_SEMICOLON:                  return StringConstant::US_SEMICOLON; break;
  483.         case TK_QUESTION:                   return StringConstant::US_QUESTION; break;
  484.         case TK_COLON:                      return StringConstant::US_COLON; break;
  485.         case TK_COMMA:                      return StringConstant::US_COMMA; break;
  486.         case TK_DOT:                        return StringConstant::US_DOT; break;
  487.         case TK_EQUAL:                      return StringConstant::US_EQUAL; break;
  488.         case TK_EOF:                        return StringConstant::US_EOF; break;
  489.         default:                            break;
  490.     }
  491.  
  492.     return StringConstant::US_EMPTY;
  493. }
  494.  
  495.  
  496. LexStream::~LexStream()
  497. {
  498. #ifdef JIKES_DEBUG
  499.     control.line_count += (file_read * (line_location.Length() - 3));
  500. #endif
  501.  
  502.     DestroyInput();
  503.  
  504.     delete [] columns;
  505.     columns = NULL;
  506. }
  507.  
  508.  
  509. //
  510. //
  511. //
  512. class LiteralSymbol *LexStream::LiteralSymbol(TokenIndex i)
  513. {
  514.     Symbol *symbol = tokens[i].additional_info.symbol;
  515.     return (symbol && (Kind(i) != TK_LBRACE) ?
  516.         symbol -> LiteralCast() :
  517.             (class LiteralSymbol *) NULL);
  518. }
  519.  
  520.  
  521. //
  522. //
  523. //
  524. class NameSymbol *LexStream::NameSymbol(TokenIndex i)
  525. {
  526.     Symbol *symbol = tokens[i].additional_info.symbol;
  527.     return (symbol && (Kind(i) != TK_LBRACE) ?
  528.         symbol -> NameCast() :
  529.             (class NameSymbol *) NULL);
  530. }
  531.  
  532.  
  533. //
  534. // Name of input file where the token appeared.
  535. //
  536. char *LexStream::FileName() { return file_symbol -> FileName(); }
  537. size_t LexStream::FileNameLength() { return file_symbol -> FileNameLength(); }
  538.  
  539.  
  540. void LexStream::InitializeColumns()
  541. {
  542.     if (! columns)
  543.     {
  544.         columns = new unsigned short[token_stream.Length()];
  545.  
  546.         int start = 0,
  547.             k = 1;
  548.  
  549.         for (size_t i = 0; i < input_buffer_length; i++)
  550.         {
  551.             if (Code::IsNewline(input_buffer[i]))
  552.                 start = i;
  553.             else
  554.             {
  555.                 if (input_buffer[i] == U_HORIZONTAL_TAB)
  556.                 {
  557.                     int offset = (i - start) - 1;
  558.                     start -= ((Tab::TabSize() - 1) - offset % Tab::TabSize());
  559.                 }
  560.                 else if (tokens[k].Location() == i)
  561.                 {
  562.                     int col = i - start;
  563.                     columns[k++] = (col < USHRT_MAX ? col : 0);
  564.                 }
  565.             }
  566.         }
  567.     }
  568.  
  569.     return;
  570. }
  571.  
  572.  
  573. //
  574. //
  575. //
  576. void LexStream::CompressSpace()
  577. {
  578.     tokens    = token_stream   .Array();
  579.     comments  = comment_stream .Array();
  580.     locations = line_location  .Array();
  581.     types     = type_index     .Array();
  582.     
  583.     if(control.option.dump_errors)
  584.         InitializeColumns();
  585.     
  586.     return;
  587. }
  588.  
  589.  
  590. //
  591. // Find and return the index of the first comment that immediately
  592. // follows tok. Return 0 if there is not a comment that immediately
  593. // follows tok.
  594. //
  595. LexStream::CommentIndex LexStream::FirstComment(TokenIndex tok)
  596. {
  597.     unsigned location = Location(tok);
  598.     int lo = 0,
  599.         hi = comment_stream.Length() - 1,
  600.         i = 0;
  601.  
  602.     if (lo < hi)
  603.     {
  604.         do
  605.         {
  606.             int mid = (lo + hi) / 2;
  607.  
  608.             if (comment_stream[mid].location < location)
  609.                  lo = mid + 1;
  610.             else hi = mid - 1;
  611.         } while (lo < hi);
  612.  
  613.         //
  614.         // at this stage lo == hi
  615.         //
  616.         i = (comment_stream[lo].location > location ? lo : lo + 1);
  617.     }
  618.  
  619.     return (i < comment_stream.Length() && comment_stream[i].previous_token == tok ? i : 0);
  620. }
  621.  
  622.  
  623. unsigned LexStream::FindLine(unsigned location)
  624. {
  625.     int lo = 0,
  626.         hi = line_location.Length() - 1;
  627.  
  628.     assert(locations);
  629.  
  630.     //
  631.     // we can place the exit test at the bottom of the loop
  632.     // since the line_location array will always contain at least
  633.     // one element.
  634.     //
  635.     do
  636.     {
  637.         int mid = (lo + hi) / 2;
  638.  
  639.         if (locations[mid] == location)
  640.             return mid;
  641.         if (locations[mid] < location)
  642.              lo = mid + 1;
  643.         else hi = mid - 1;
  644.     } while (lo < hi);
  645.  
  646.     return (locations[lo] > location ? lo - 1 : lo);
  647. }
  648.  
  649.  
  650. void LexStream::ReadInput()
  651. {
  652.     if (file_symbol -> buffer)
  653.     {
  654.         ProcessInput(file_symbol -> buffer, strlen(file_symbol -> buffer));
  655.     }
  656.     else if (file_symbol -> IsZip()) {
  657.         ZipFile *zipfile = new ZipFile(file_symbol);
  658.  
  659.         if (zipfile -> Buffer() == NULL)
  660.         {
  661.             fprintf(stderr, "chaos: Don\'t know how to process compressed (\".java\") source in a zip file\n");
  662.             assert(false);
  663.         }
  664.         else if (! file_symbol -> lex_stream) // Once the zip file is loaded, it never changes. So, we only read it the first time
  665.         {
  666.             file_symbol -> lex_stream = this;
  667.             ProcessInput(zipfile -> Buffer(), file_symbol -> uncompressed_size);
  668.         }
  669.         delete zipfile;
  670.     }
  671.     else
  672.     {
  673.         struct stat status;
  674.         JikesAPI::getInstance()->stat(FileName(), &status);
  675.  
  676.         file_symbol -> mtime = status.st_mtime; // actual time stamp of file read
  677.         file_symbol -> lex_stream = this;
  678.  
  679.  
  680.         JikesAPI::FileReader  *file = JikesAPI::getInstance()->read(FileName());
  681.         if (file)
  682.         {
  683.             ProcessInput(file->getBuffer(),file->getBufferSize());
  684.             delete file;
  685.         }
  686.     }
  687.  
  688.     initial_reading_of_input = false;
  689.  
  690.     return;
  691. }
  692.  
  693. void LexStream::RereadInput()
  694. {
  695.     if (input_buffer) // if input already available, do nothing
  696.         ;
  697. #ifdef JIKES_DEBUG
  698.     else if (file_symbol -> buffer)
  699.     {
  700.       fprintf(stderr, "chaos: Don\'t know how to RereadInput a buffer\n");
  701.       assert(false);
  702.     }
  703. #endif
  704.     else if (file_symbol -> IsZip())
  705.     {
  706.         ZipFile *zipfile = new ZipFile(file_symbol);
  707.  
  708.         if (zipfile -> Buffer() == NULL)
  709.         {
  710.             fprintf(stderr, "chaos: Don\'t know how to process compressed (\".java\") source in a zip file\n");
  711.             assert(false);
  712.         }
  713.         else ProcessInput(zipfile -> Buffer(), file_symbol -> uncompressed_size);
  714.         delete zipfile;
  715.     }
  716.     else
  717.     {
  718.         struct stat status;
  719.         JikesAPI::getInstance()->stat(FileName(), &status);
  720.  
  721.         if (status.st_mtime == file_symbol -> mtime)
  722.         {
  723.            JikesAPI::FileReader  *file = JikesAPI::getInstance()->read(FileName());
  724.            if (file)
  725.            {
  726.                ProcessInput(file->getBuffer(),file->getBufferSize());
  727.                delete file;
  728.            }
  729.         }
  730.         else
  731.         {
  732.             // TODO: File has changed !!!
  733.         }
  734.     }
  735.  
  736.     return;
  737. }
  738.  
  739.  
  740. int LexStream::hexvalue(wchar_t ch)
  741. {
  742.     switch(ch)
  743.     {
  744.     case U_a: case U_A:
  745.         return 10;
  746.     case U_b: case U_B:
  747.         return 11;
  748.     case U_c: case U_C:
  749.         return 12;
  750.     case U_d: case U_D:
  751.         return 13;
  752.     case U_e: case U_E:
  753.         return 14;
  754.     case U_f: case U_F:
  755.         return 15;
  756.     default:
  757.         return ch - U_0;
  758.     }
  759. }
  760.  
  761. //
  762. // Read filesize  characters from srcfile, convert them to unicode, and
  763. // store them in input_buffer.
  764. //
  765. void LexStream::ProcessInput(const char *buffer, long filesize)
  766. {
  767. #if defined(HAVE_LIB_ICU_UC) || defined(HAVE_ICONV_H)
  768.     LexStream::ProcessInputUnicode(buffer,filesize);
  769. #else
  770.     LexStream::ProcessInputAscii(buffer, filesize);
  771. #endif
  772. }
  773.  
  774. //
  775. // Read file_size Ascii characters from srcfile, convert them to unicode and
  776. // store them in input_buffer.
  777. //
  778. void LexStream::ProcessInputAscii(const char *buffer, long filesize)
  779. {
  780. #ifdef JIKES_DEBUG
  781.     file_read++;
  782. #endif
  783.  
  784.     wchar_t *input_ptr = AllocateInputBuffer( filesize );
  785.     *input_ptr = U_LINE_FEED; // add an initial '\n';
  786.  
  787.     if (buffer)
  788.     {
  789.         const char *source_ptr = buffer,
  790.              *source_tail = &(buffer[filesize - 1]); // point to last character read from the file.
  791.  
  792.         while(source_ptr <= source_tail)
  793.         {
  794.             *(++input_ptr) = (*source_ptr++) & 0x00ff; // The (& 0x00ff) guarantees that quantity is copied as unsigned value
  795.  
  796.             if (*input_ptr == U_CARRIAGE_RETURN)
  797.             {
  798.                 *input_ptr = U_LINE_FEED;
  799.                 if (*source_ptr == U_LINE_FEED)
  800.                     source_ptr++;
  801.             }
  802.             else if (*input_ptr == U_BACKSLASH)
  803.             {
  804.                 if (*source_ptr == U_BACKSLASH)
  805.                     *(++input_ptr) = *source_ptr++;
  806.                 else if (*source_ptr == U_u)
  807.                 {
  808.                     const char *u_ptr = source_ptr;
  809.  
  810.                     for (source_ptr++; source_ptr <= source_tail && *source_ptr == U_u; source_ptr++)
  811.                         ;
  812.                     *input_ptr = 0;
  813.                     int i;
  814.                     for (i = 0; source_ptr <= source_tail && isxdigit(*source_ptr) && i < 4; i++)
  815.                     {
  816.                         int multiplier[4] = {4096, 256, 16, 1};
  817.  
  818.                         const char ch = *source_ptr++;
  819.                         switch(ch)
  820.                         {
  821.                             case U_a: case U_A:
  822.                                 *input_ptr += (10 * multiplier[i]);
  823.                                 break;
  824.                             case U_b: case U_B:
  825.                                 *input_ptr += (11 * multiplier[i]);
  826.                                 break;
  827.                             case U_c: case U_C:
  828.                                 *input_ptr += (12 * multiplier[i]);
  829.                                 break;
  830.                             case U_d: case U_D:
  831.                                 *input_ptr += (13 * multiplier[i]);
  832.                                 break;
  833.                             case U_e: case U_E:
  834.                                 *input_ptr += (14 * multiplier[i]);
  835.                                 break;
  836.                             case U_f: case U_F:
  837.                                 *input_ptr += (15 * multiplier[i]);
  838.                                 break;
  839.                             default:
  840.                                 *input_ptr += ((ch - U_0) * multiplier[i]);
  841.                         }
  842.                     }
  843.  
  844.                     if (i != 4)
  845.                     {
  846.                         if (initial_reading_of_input)
  847.                             bad_tokens.Next().Initialize(StreamError::INVALID_UNICODE_ESCAPE,
  848.                                                          (unsigned) (input_ptr - input_buffer),
  849.                                                          (unsigned) (input_ptr - input_buffer) + (source_ptr - u_ptr), this);
  850.  
  851.                         source_ptr = u_ptr;
  852.                         *input_ptr = U_BACKSLASH;
  853.                     }
  854.                     else if (*input_ptr == U_CARRIAGE_RETURN)
  855.                     {
  856.                         *input_ptr = U_LINE_FEED;
  857.                         if (*source_ptr == U_LINE_FEED)
  858.                             source_ptr++;
  859.                         else if (*source_ptr == U_BACKSLASH)
  860.                         {
  861.                             int i;
  862.                             for (i = 1; (source_ptr + i) <= source_tail && source_ptr[i] == U_u; i++)
  863.                                 ;
  864.                             if (i > 1 && (source_ptr + i + 3) <= source_tail
  865.                                       && source_ptr[i]     == U_0
  866.                                       && source_ptr[i + 1] == U_0
  867.                                       && source_ptr[i + 2] == U_0
  868.                                       && source_ptr[i + 3] == U_a) // the escape sequence of \n is \u000a
  869.                                 source_ptr += (i + 4);
  870.                         }
  871.                     }
  872.                 }
  873.             }
  874.         }
  875.  
  876.         //
  877.         // Remove all trailing spaces
  878.         //
  879.         while((input_ptr > input_buffer) && Code::IsSpace(*input_ptr))
  880.             input_ptr--;
  881.     }
  882.  
  883.     //
  884.     // If the very last character is not CTL_Z then add CTL_Z
  885.     //
  886.     if (*input_ptr != U_CTL_Z)
  887.     {
  888.         if (*input_ptr != U_LINE_FEED)
  889.             *(++input_ptr) = U_LINE_FEED; // if the last character is not end-of-line, add end-of-line
  890.         *(++input_ptr) = U_CTL_Z;         // Mark end-of-file
  891.     }
  892.     *(++input_ptr) = U_NULL;              // add gate
  893.  
  894.     input_buffer_length = input_ptr - input_buffer;
  895.  
  896.     return;
  897. }
  898.  
  899. #if defined(HAVE_LIB_ICU_UC) || defined(HAVE_ICONV_H)
  900. //
  901. // Read file_size Ascii characters from srcfile, convert them to unicode, and
  902. // store them in input_buffer.
  903. //
  904. void LexStream::ProcessInputUnicode(const char *buffer, long filesize)
  905. {
  906.     //fprintf(stderr,"LexStream::ProcessInputUnicode called.\n");
  907. #ifdef JIKES_DEBUG
  908.     file_read++;
  909. #endif
  910.  
  911.     wchar_t *input_ptr = AllocateInputBuffer( filesize );
  912.     wchar_t *input_tail = input_ptr + filesize;
  913.     *input_ptr = U_LINE_FEED; // add an initial '\n';
  914.  
  915.     if(buffer)
  916.     {
  917.         int      escape_value;
  918.         wchar_t *escape_ptr;
  919.  
  920.         const char *source_ptr  = buffer;
  921.         const char *source_tail = buffer + filesize - 1; // point to last character read from the file.
  922.  
  923.         UnicodeLexerState saved_state = START;
  924.         UnicodeLexerState state = START;
  925. #ifdef HAVE_LIB_ICU_UC
  926.         UErrorCode err = U_ZERO_ERROR;
  927. #endif
  928.         bool oncemore = false;
  929.  
  930.         if(control.option.encoding)
  931.         {
  932.             // The encoding should have been validated by now
  933.             assert( SetEncoding(control.option.encoding) );
  934.         }
  935.  
  936.         while((source_ptr <= source_tail) || oncemore)
  937.         {
  938.             // On each iteration we advance input_ptr maximun 2 postions.
  939.             // Here we check if we are close to the end of input_buffer
  940.             if(input_ptr>=input_tail)
  941.             {
  942.                 // If this happen, reallocate it with some more space.
  943.                 // This is very rare case, which could happen if
  944.                 // one code page character is represened by several 
  945.                 // unicode characters. One of exaples of such
  946.                 // situation is unicode "surrogates".
  947.                 //
  948.                 // If such reallocation will be required, it will indeed
  949.                 // slow down compilation a bit.
  950.                 size_t cursize = input_ptr-input_buffer;
  951.                 size_t newsize = cursize+cursize/10+4; // add 10%
  952.                 wchar_t *tmp   = new wchar_t[newsize]; 
  953.                 memcpy (tmp, input_buffer, cursize*sizeof(wchar_t));
  954.                 delete [] input_buffer;
  955.                 input_buffer = tmp;
  956.                 input_tail = input_buffer + newsize - 1;
  957.                 input_ptr  = input_buffer + cursize;
  958.             }
  959.             
  960.             wchar_t ch;
  961.             
  962.             if(!oncemore)
  963.             {
  964.                 if(control.option.encoding)
  965.                 {
  966.                     const char *before = source_ptr;
  967.  
  968. #ifdef HAVE_LIB_ICU_UC
  969.                     ch=ucnv_getNextUChar (_converter,
  970.                                           &source_ptr,
  971.                                           source_tail+1,
  972.                                           &err);
  973.  
  974.                    
  975.                     if(U_FAILURE(err))
  976.                     {
  977.                         fprintf(stderr,"Conversion error: %s at byte %d\n", 
  978. #ifdef ICU131
  979.                 errorName(err),
  980. #else
  981.                                 u_errorName(err),
  982. #endif
  983.                                 int(before-buffer)
  984.                         );
  985.                         break;
  986.                     }
  987. #else
  988. #   ifdef HAVE_ICONV_H
  989.                     u1 chd[2], uni_high, uni_low;
  990.                     u1 *chp  = chd;
  991.                     // Point to 2 bytes with 16 bit type
  992.                     wchar_t* wchp = (wchar_t *) chp;
  993.                     size_t   chl  = 2;
  994.                     size_t   srcl = 1;
  995.                     size_t n = iconv(_converter,
  996. #ifdef HAVE_ERROR_CALL_ICONV_CONST
  997.                                      (char **)
  998. #endif
  999.                                      &source_ptr, &srcl,
  1000.                                      (char **)&chp, &chl
  1001.                     );
  1002.  
  1003.                     if(n == (size_t) -1)
  1004.                     {
  1005.                         fprintf(stderr,"Charset conversion error at offset %d: ", int(before-buffer));
  1006.                         perror("");
  1007.                         break;
  1008.                     }
  1009.  
  1010.                     // FIXME: This seems like a hack, someone should reread the docs
  1011.                     // and clean this nasty code up -> http://www.netppl.fi/~pp/glibc21/libc_6.html#SEC91
  1012.  
  1013.                     // Operate on chd buffer in endian independent fashion
  1014.                     uni_high = (u1) (*wchp);
  1015.                     uni_low = (u1) ((*wchp) >> 8);
  1016.                     ch = uni_low + (uni_high * 256);
  1017. #   endif
  1018. #endif
  1019.                     if(before==source_ptr)
  1020.                     {
  1021.                         //End of conversion
  1022.                         break;
  1023.                     }
  1024.                 }
  1025.                 else
  1026.                 {
  1027.                     ch=*source_ptr++;
  1028.                 }
  1029.             } else oncemore = false;
  1030.       
  1031.             switch(state)
  1032.             {
  1033.  
  1034.             case QUOTE:
  1035.                 if(ch==U_BACKSLASH)
  1036.                 {
  1037.                     *(++input_ptr) = U_BACKSLASH;
  1038.                     *(++input_ptr) = U_BACKSLASH;
  1039.                     state          = RAW;
  1040.                 } else if(ch==U_u)
  1041.                 {
  1042.                     escape_ptr = input_ptr;
  1043.                     state      = UNICODE_ESCAPE;
  1044.                 } else
  1045.                 {
  1046.                     *(++input_ptr )= U_BACKSLASH;
  1047.                     state          = RAW;
  1048.                     oncemore       = true;
  1049.                 }
  1050.                 break;
  1051.  
  1052.             case UNICODE_ESCAPE:
  1053.                 if(isxdigit(ch))
  1054.                 {
  1055.                     state=UNICODE_ESCAPE_DIGIT_0;
  1056.                     escape_value=hexvalue(ch)*16*16*16;
  1057.                 } else if(ch!=U_u)
  1058.                 {
  1059.                     if(initial_reading_of_input)
  1060.                         bad_tokens.Next().Initialize(StreamError::INVALID_UNICODE_ESCAPE,
  1061.                                                      (unsigned) (escape_ptr - input_buffer),
  1062.                                                      (unsigned) (input_ptr - input_buffer), this);
  1063.                 }
  1064.                 break;
  1065.  
  1066.             case UNICODE_ESCAPE_DIGIT_0:
  1067.                 if(isxdigit(ch))
  1068.                 {
  1069.                     state=UNICODE_ESCAPE_DIGIT_1;
  1070.                     escape_value+=hexvalue(ch)*16*16;
  1071.                 } else  
  1072.                 {
  1073.                     if(initial_reading_of_input)
  1074.                         bad_tokens.Next().Initialize(StreamError::INVALID_UNICODE_ESCAPE,
  1075.                                                      (unsigned) (escape_ptr - input_buffer),
  1076.                                                      (unsigned) (input_ptr - input_buffer), this);
  1077.                 }
  1078.                 break;
  1079.  
  1080.             case UNICODE_ESCAPE_DIGIT_1:
  1081.                 if(isxdigit(ch))
  1082.                 {
  1083.                     state=UNICODE_ESCAPE_DIGIT_2;
  1084.                     escape_value+=hexvalue(ch)*16;
  1085.                 } else  
  1086.                 {
  1087.                     if(initial_reading_of_input)
  1088.                         bad_tokens.Next().Initialize(StreamError::INVALID_UNICODE_ESCAPE,
  1089.                                                      (unsigned) (escape_ptr - input_buffer),
  1090.                                                      (unsigned) (input_ptr - input_buffer), this);
  1091.                 }
  1092.                 break;
  1093.  
  1094.             case UNICODE_ESCAPE_DIGIT_2:
  1095.                 if(isxdigit(ch))
  1096.                 {
  1097.                     ch       = escape_value+hexvalue(ch);
  1098.                     state    = saved_state;
  1099.                     saved_state = UNICODE_ESCAPE_DIGIT_2;
  1100.                     oncemore = true;
  1101.                 } else  
  1102.                 {
  1103.                     if(initial_reading_of_input)
  1104.                         bad_tokens.Next().Initialize(StreamError::INVALID_UNICODE_ESCAPE,
  1105.                                                      (unsigned) (escape_ptr - input_buffer),
  1106.                                                      (unsigned) (input_ptr - input_buffer), this);
  1107.                 }
  1108.                 break;
  1109.  
  1110.             case CR:
  1111.                 if (ch == U_LINE_FEED)
  1112.                 {
  1113.                     // skip line feed if it comes right after a CR.
  1114.                     state = RAW;
  1115.                 } else if (ch == U_CARRIAGE_RETURN)
  1116.                 {
  1117.                     // but if CR follows CR then the second CR is a
  1118.                     // line feed too (and note that state=CR still, afterwards,
  1119.                     // so that CR-CR-LF will be handled correctly). [CSA]
  1120.                     *(++input_ptr) = U_LINE_FEED;
  1121.                 } else if (ch == U_BACKSLASH && saved_state != UNICODE_ESCAPE_DIGIT_2)
  1122.                 {
  1123.                     saved_state = CR;
  1124.                     state       = QUOTE;
  1125.                 } else
  1126.                 {
  1127.                     state = RAW;
  1128.                     *(++input_ptr)=ch;                    
  1129.                 }
  1130.                // clear saved_state == UNICODE_ESCAPE_DIGIT_2 status
  1131.                saved_state = CR;
  1132.                 break;
  1133.  
  1134.             case START:
  1135.                 // if for some reason converter produced or passed
  1136.                 // byte order mark, it have to be ignored.
  1137.                 state = RAW;
  1138.                 if(ch==U_BOM || ch==U_REVERSE_BOM)
  1139.                     break; //ignore
  1140.                     
  1141.             case RAW:
  1142.                 if(ch==U_BACKSLASH && saved_state != UNICODE_ESCAPE_DIGIT_2)
  1143.                 {
  1144.                     state       = QUOTE;
  1145.                 } else if(ch == U_CARRIAGE_RETURN)
  1146.                 {
  1147.                     state = CR;
  1148.                     *(++input_ptr) = U_LINE_FEED;
  1149.                 } else
  1150.                 {
  1151.                     *(++input_ptr)=ch;                    
  1152.                 }
  1153.                 saved_state = RAW;
  1154.                 break;
  1155.             }
  1156.         }
  1157.     }
  1158.  
  1159.     //
  1160.     // If the very last character is not CTL_Z then add CTL_Z
  1161.     //
  1162.     if (*input_ptr != U_CTL_Z)
  1163.     {
  1164.         if (*input_ptr != U_LINE_FEED)
  1165.             *(++input_ptr) = U_LINE_FEED; // if the last character is not end-of-line, add end-of-line
  1166.         *(++input_ptr) = U_CTL_Z;         // Mark end-of-file
  1167.     }
  1168.     *(++input_ptr) = U_NULL;              // add gate
  1169.     
  1170.     input_buffer_length = input_ptr - input_buffer;
  1171.  
  1172.     return;
  1173. }
  1174. #endif // defined(HAVE_LIB_ICU_UC) || defined(HAVE_ICONV_H)
  1175.  
  1176. //
  1177. // This procedure uses a  quick sort algorithm to sort the stream ERRORS
  1178. // by their locations.
  1179. //
  1180. void LexStream::SortMessages()
  1181. {
  1182.      int lower,
  1183.          upper,
  1184.          lostack[32],
  1185.          histack[32];
  1186.  
  1187.      int top,
  1188.          i,
  1189.          j;
  1190.      StreamError pivot,
  1191.                  temp;
  1192.  
  1193.      top = 0;
  1194.      lostack[top] = 0;
  1195.      histack[top] = bad_tokens.Length() - 1;
  1196.  
  1197.      while(top >= 0)
  1198.      {
  1199.          lower = lostack[top];
  1200.          upper = histack[top];
  1201.          top--;
  1202.  
  1203.          while(upper > lower)
  1204.          {
  1205.              //
  1206.              // The array is most-likely almost sorted. Therefore,
  1207.              // we use the middle element as the pivot element.
  1208.              //
  1209.              i = (lower + upper) / 2;
  1210.              pivot = bad_tokens[i];
  1211.              bad_tokens[i] = bad_tokens[lower];
  1212.  
  1213.              //
  1214.              // Split the array section indicated by LOWER and UPPER
  1215.              // using ARRAY(LOWER) as the pivot.
  1216.              //
  1217.              i = lower;
  1218.              for (j = lower + 1; j <= upper; j++)
  1219.              {
  1220.                  if (bad_tokens[j].start_location < pivot.start_location)
  1221.                  {
  1222.                      temp = bad_tokens[++i];
  1223.                      bad_tokens[i] = bad_tokens[j];
  1224.                      bad_tokens[j] = temp;
  1225.                  }
  1226.              }
  1227.              bad_tokens[lower] = bad_tokens[i];
  1228.              bad_tokens[i] = pivot;
  1229.  
  1230.              top++;
  1231.              if ((i - lower) < (upper - i))
  1232.              {
  1233.                  lostack[top] = i + 1;
  1234.                  histack[top] = upper;
  1235.                  upper = i - 1;
  1236.              }
  1237.              else
  1238.              {
  1239.                  histack[top] = i - 1;
  1240.                  lostack[top] = lower;
  1241.                  lower = i + 1;
  1242.              }
  1243.          }
  1244.      }
  1245.  
  1246.      return;
  1247. }
  1248.  
  1249.  
  1250. //
  1251. //
  1252. //
  1253. void LexStream::PrintMessages()
  1254. {
  1255.     //
  1256.     // If control.option.dump_errors then the error messages have already been printed
  1257.     //
  1258.     if (! control.option.dump_errors)
  1259.     {
  1260.         RereadInput();
  1261.  
  1262.         if (control.option.errors)
  1263.         {
  1264.             char *file_name = FileName();
  1265.  
  1266.             Coutput << "\nFound " << NumBadTokens() << " lexical error" << (NumBadTokens() == 1 ? "" : "s")
  1267.                     << " in \""
  1268.                     << file_name
  1269.                     << "\":";
  1270.  
  1271.             if (! input_buffer)
  1272.             {
  1273.                 int length = FileNameLength();
  1274.                 wchar_t *name = new wchar_t[length + 1];
  1275.                 for (int i = 0; i < length; i++)
  1276.                     name[i] = file_name[i];
  1277.                 name[length] = U_NULL;
  1278.                 control.system_semantic -> ReportSemError(SemanticError::CANNOT_REOPEN_FILE,
  1279.                                                           0,
  1280.                                                           0,
  1281.                                                           name);
  1282.                 delete [] name;
  1283.             }
  1284.             else
  1285.             {
  1286.                 for (int i = 0; i < bad_tokens.Length(); i++)
  1287.                 {
  1288.                     JikesAPI::getInstance()->reportError(&bad_tokens[i]);
  1289.                 }
  1290.             }
  1291.         }
  1292.         else
  1293.         {
  1294.             for (int i = 0; i < bad_tokens.Length(); i++)
  1295.                 JikesAPI::getInstance()->reportError(&bad_tokens[i]);
  1296.         }
  1297.  
  1298.         DestroyInput();
  1299.  
  1300.         Coutput.flush();
  1301.     }
  1302.  
  1303.     return;
  1304. }
  1305.  
  1306. #ifdef    HAVE_JIKES_NAMESPACE
  1307. }            // Close namespace Jikes block
  1308. #endif
  1309.  
  1310.