Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    ***** BEGIN LICENSE BLOCK *****
    * Version: CPL 1.0/GPL 2.0/LGPL 2.1
    *
    * The contents of this file are subject to the Common Public
    * License Version 1.0 (the "License"); you may not use this file
    * except in compliance with the License. You may obtain a copy of
    * the License at http://www.eclipse.org/legal/cpl-v10.html
    *
   * Software distributed under the License is distributed on an "AS
   * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
   * implied. See the License for the specific language governing
   * rights and limitations under the License.
   *
   * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr>
   * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
   * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
   * Copyright (C) 2004-2006 Thomas E Enebo <enebo@acm.org>
   * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
   * Copyright (C) 2004-2005 David Corbin <dcorbin@users.sourceforge.net>
   * Copyright (C) 2005 Zach Dennis <zdennis@mktec.com>
   * Copyright (C) 2006 Thomas Corbat <tcorbat@hsr.ch>
   * 
   * Alternatively, the contents of this file may be used under the terms of
   * either of the GNU General Public License Version 2 or later (the "GPL"),
   * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
   * in which case the provisions of the GPL or the LGPL are applicable instead
   * of those above. If you wish to allow use of your version of this file only
   * under the terms of either the GPL or the LGPL, and not to allow others to
   * use your version of this file under the terms of the CPL, indicate your
   * decision by deleting the provisions above and replace them with the notice
   * and other provisions required by the GPL or the LGPL. If you do not delete
   * the provisions above, a recipient may use your version of this file under
   * the terms of any one of the CPL, the GPL or the LGPL.
   ***** END LICENSE BLOCK *****/
  package org.jruby.lexer.yacc;
  
  
  import java.util.HashMap;
  
  import org.joni.Matcher;
  import org.joni.Option;
  import org.joni.Regex;
This is a port of the MRI lexer to Java it is compatible to Ruby 1.8.1.
  
  public class RubyYaccLexer {
      public static final Encoding UTF8_ENCODING = .;
      public static final Encoding USASCII_ENCODING = .;
      public static final Encoding ASCII8BIT_ENCODING = .;
      
      private static ByteList END_MARKER = new ByteList(new byte[] {'_''E''N''D''_''_'});
      private static ByteList BEGIN_DOC_MARKER = new ByteList(new byte[] {'b''e''g''i''n'});
      private static ByteList END_DOC_MARKER = new ByteList(new byte[] {'e''n''d'});
      private static final HashMap<StringKeywordmap;
  
      static {
           = new HashMap<StringKeyword>();
  
          .put("end".);
          .put("else".);
          .put("case".);
          .put("ensure".);
          .put("module".);
          .put("elsif".);
          .put("def".);
          .put("rescue".);
          .put("not".);
          .put("then".);
          .put("yield".);
          .put("for".);
          .put("self".);
          .put("false".);
          .put("retry".);
          .put("return".);
          .put("true".);
          .put("if".);
          .put("defined?".);
         .put("super".);
         .put("undef".);
         .put("break".);
         .put("in".);
         .put("do".);
         .put("nil".);
         .put("until".);
         .put("unless".);
         .put("or".);
         .put("next".);
         .put("when".);
         .put("redo".);
         .put("and".);
         .put("begin".);
         .put("__LINE__".);
         .put("class".);
         .put("__FILE__".);
         .put("END".);
         .put("BEGIN".);
         .put("while".);
         .put("alias".);
         .put("__ENCODING__".);
     }
 
     private Encoding encoding;
 
     public Encoding getEncoding() {
         return ;
     }
 
     private int getFloatToken(String number) {
         double d;
         try {
             d = SafeDoubleParser.parseDouble(number);
         } catch (NumberFormatException e) {
             .warn(.getPosition(), "Float " + number + " out of range.");
 
             d = number.startsWith("-") ? . : .;
         }
          = new FloatNode(getPosition(), d);
         return .;
     }
 
     private Object newBignumNode(String valueint radix) {
         return new BignumNode(getPosition(), new BigInteger(valueradix));
     }
 
     private Object newFixnumNode(String valueint radixthrows NumberFormatException {
         return new FixnumNode(getPosition(), Long.parseLong(valueradix));
     }
     
     public enum Keyword {
         END ("end"...),
         ELSE ("else"...),
         CASE ("case"...),
         ENSURE ("ensure"...),
         MODULE ("module"...),
         ELSIF ("elsif"...),
         DEF ("def"...),
         RESCUE ("rescue"...),
         NOT ("not"...),
         THEN ("then"...),
         YIELD ("yield"...),
         FOR ("for"...),
         SELF ("self"...),
         FALSE ("false"...),
         RETRY ("retry"...),
         RETURN ("return"...),
         TRUE ("true"...),
         IF ("if"...),
         DEFINED_P ("defined?"...),
         SUPER ("super"...),
         UNDEF ("undef"...),
         BREAK ("break"...),
         IN ("in"...),
         DO ("do"...),
         NIL ("nil"...),
         UNTIL ("until"...),
         UNLESS ("unless"...),
         OR ("or"...),
         NEXT ("next"...),
         WHEN ("when"...),
         REDO ("redo"...),
         AND ("and"...),
         BEGIN ("begin"...),
         __LINE__ ("__LINE__"...),
         CLASS ("class"...),
         __FILE__("__FILE__"...),
         LEND ("END"...),
         LBEGIN ("BEGIN"...),
         WHILE ("while"...),
         ALIAS ("alias"...),
         __ENCODING__("__ENCODING__"...);
         
         public final String name;
         public final int id0;
         public final int id1;
         public final LexState state;
         
         Keyword(String nameint id0int id1LexState state) {
             this. = name;
             this. = id0;
             this. = id1;
             this. = state;
         }
     }
     
     public enum LexState {
         EXPR_BEG, EXPR_END, EXPR_ARG, EXPR_CMDARG, EXPR_ENDARG, EXPR_MID,
         EXPR_FNAME, EXPR_DOT, EXPR_CLASS, EXPR_VALUE, EXPR_ENDFN
     }
     
     public static Keyword getKeyword(String str) {
         return (Keyword.get(str);
     }
 
     // Last token read via yylex().
     private int token;
     
     // Value of last token which had a value associated with it.
     Object yaccValue;
 
     // Stream of data that yylex() examines.
     private LexerSource src;
     
     // Used for tiny smidgen of grammar in lexer (see setParserSupport())
     private ParserSupport parserSupport = null;
 
     // What handles warnings
     private IRubyWarnings warnings;
 
     // Additional context surrounding tokens that both the lexer and
     // grammar use.
     private LexState lex_state;
     
     // Tempory buffer to build up a potential token.  Consumer takes responsibility to reset 
     // this before use.
     private StringBuilder tokenBuffer = new StringBuilder(60);
 
     private StackState conditionState = new StackState();
     private StackState cmdArgumentState = new StackState();
     private StrTerm lex_strterm;
     public boolean commandStart;
 
     // Give a name to a value.  Enebo: This should be used more.
     static final int EOF = -1;
 
     // ruby constants for strings (should this be moved somewhere else?)
     static final int STR_FUNC_ESCAPE=0x01;
     static final int STR_FUNC_EXPAND=0x02;
     static final int STR_FUNC_REGEXP=0x04;
     static final int STR_FUNC_QWORDS=0x08;
     static final int STR_FUNC_SYMBOL=0x10;
     // When the heredoc identifier specifies <<-EOF that indents before ident. are ok (the '-').
     static final int STR_FUNC_INDENT=0x20;
 
     private static final int str_squote = 0;
     private static final int str_dquote = ;
     private static final int str_xquote = ;
     private static final int str_regexp =  |  | ;
     private static final int str_ssym   = ;
     private static final int str_dsym   =  | ;
 
     // Are we lexing Ruby 1.8 or 1.9+ syntax
     private boolean isOneEight;
     // Count of nested parentheses (1.9 only)
     private int parenNest = 0;
     // 1.9 only
     private int leftParenBegin = 0;
 
     public int incrementParenNest() {
         ++;
 
         return ;
     }
 
     public int getLeftParenBegin() {
         return ;
     }
 
     public void setLeftParenBegin(int value) {
          = value;
     }
 
     public RubyYaccLexer() {
     	this(true);
     }
     
     public RubyYaccLexer(boolean isOneEight) {
     	reset();
         this. = isOneEight;
     }
     
     public final void reset() {
     	 = 0;
     	 = null;
     	 = null;
         setState(null);
         resetStacks();
          = null;
          = true;
     }
    
    
How the parser advances to the next token.

Returns:
true if not at end of file (EOF).
 
     public boolean advance() throws IOException {
         return ( = yylex()) != ;
     }
 
     public int nextToken() throws IOException {
          = yylex();
 
         return  ==  ? 0 : ;
     }
    
    
Last token read from the lexer at the end of a call to yylex()

Returns:
last token read
 
     public int token() {
         return ;
     }
 
     public StringBuilder getTokenBuffer() {
         return ;
     }
    
    
Value of last token (if it is a token which has a value).

Returns:
value of last value-laden token
 
     public Object value() {
         return ;
     }
    
    
Get position information for Token/Node that follows node represented by startPosition and current lexer location.

Parameters:
startPosition previous node/token
inclusive include previous node into position information of current node
Returns:
a new position
 
     public ISourcePosition getPosition(ISourcePosition startPosition) {
     	return .getPosition(startPosition); 
     }
     
     public ISourcePosition getPosition() {
         return .getPosition();
     }
 
     public String getCurrentLine() {
         return .getCurrentLine();
     }

    
Parse must pass its support object for some check at bottom of yylex(). Ruby does it this way as well (i.e. a little parsing logic in the lexer).

Parameters:
parserSupport
 
     public void setParserSupport(ParserSupport parserSupport) {
         this. = parserSupport;
     }
 
     private void setEncoding(ByteList name) {
         Encoding newEncoding = .getConfiguration().getEncodingService().loadEncoding(name);
 
         if (newEncoding == null) {
             throw new SyntaxException(.getPosition(),
                     null"unknown encoding name: " + name.toString());
         }
 
         if (!newEncoding.isAsciiCompatible()) {
             throw new SyntaxException(.getPosition(),
                     nullname.toString() + " is not ASCII compatible");
         }
 
         setEncoding(newEncoding);
     }
 
     public void setEncoding(Encoding encoding) {
         this. = encoding;
     }

    
Allow the parser to set the source for its lexer.

Parameters:
source where the lexer gets raw data
 
     public void setSource(LexerSource source) {
         this. = source;
     }
 
     public StrTerm getStrTerm() {
         return ;
     }
     
     public void setStrTerm(StrTerm strterm) {
         this. = strterm;
     }
 
     public void resetStacks() {
         .reset();
         .reset();
     }
     
     public void setWarnings(IRubyWarnings warnings) {
         this. = warnings;
     }
 
     private void printState() {
         if ( == null) {
             ..println("NULL");
         } else {
             ..println();
         }
     }
 
     public void setState(LexState state) {
         this. = state;
 //        printState();
     }
 
     public StackState getCmdArgumentState() {
         return ;
     }
 
     public boolean isOneEight() {
         return ;
     }
 
     public StackState getConditionState() {
         return ;
     }
     
     public void setValue(Object yaccValue) {
         this. = yaccValue;
     }
 
     private boolean isNext_identchar() throws IOException {
         int c = .read();
         .unread(c);
 
         return c !=  && (Character.isLetterOrDigit(c) || c == '_');
     }
 
     private boolean isBEG() {
         return  == . ||  == . ||
                  == . || (! &&  == .);
     }
     
     private boolean isEND() {
         return  == . ||  == . ||
                 (! &&  == .);
     }
 
     private boolean isARG() {
         return  == . ||  == .;
     }
 
     private void determineExpressionState() {
         switch () {
         case case :
             setState(.);
             break;
         default:
             setState(.);
             break;
         }
     }
 
     private Object getInteger(String valueint radix) {
         try {
             return newFixnumNode(valueradix);
         } catch (NumberFormatException e) {
             return newBignumNode(valueradix);
         }
     }

Parameters:
c the character to test
Returns:
true if character is a hex value (0-9a-f)
 
     static boolean isHexChar(int c) {
         return Character.isDigit(c) || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F');
     }

    

Parameters:
c the character to test
Returns:
true if character is an octal value (0-7)
 
     static boolean isOctChar(int c) {
         return '0' <= c && c <= '7';
     }
    
    
This is a valid character for an identifier?

Parameters:
c is character to be compared
Returns:
whether c is an identifier or not mri: is_identchar
 
     public boolean isIdentifierChar(int c) {
         return Character.isLetterOrDigit(c) || c == '_' || isMultiByteChar(c);
     }

    
Is this a multibyte character from a multibyte encoding?

Parameters:
c
Returns:
whether c is an multibyte char or not
 
     protected boolean isMultiByteChar(int c) {
         return .codeToMbcLength(c) != 1;
     }
 
     // STR_NEW3/parser_str_new
     public StrNode createStrNode(ISourcePosition positionByteList bufferint flags) {
         Encoding bufferEncoding = buffer.getEncoding();
         int codeRange = StringSupport.codeRangeScan(bufferEncodingbuffer);
 
         if ((flags & .) == 0 && bufferEncoding.isAsciiCompatible()) {
             // If we have characters outside 7-bit range and we are still ascii then change to ascii-8bit
             if (codeRange == .) {
                 // Do nothing like MRI
             } else if (getEncoding() == . &&
                     bufferEncoding != .) {
                 codeRange = ParserSupport.associateEncoding(buffer.codeRange);
             }
         }
 
         return new StrNode(positionbuffercodeRange);
     }
    
    
What type/kind of quote are we dealing with?

Parameters:
c first character the the quote construct
Returns:
a token that specifies the quote type
 
     private int parseQuote(int cthrows IOException {
         int beginend;
         boolean shortHand;
         
         // Short-hand (e.g. %{,%.,%!,... versus %Q{).
         if (!Character.isLetterOrDigit(c)) {
             begin = c;
             c = 'Q';
             shortHand = true;
         // Long-hand (e.g. %Q{}).
         } else {
             shortHand = false;
             begin = .read();
             if (Character.isLetterOrDigit(begin/* no mb || ismbchar(term)*/) {
                 throw new SyntaxException(.getPosition(), getCurrentLine(), "unknown type of %string");
             }
         }
         if (c ==  || begin == ) {
             throw new SyntaxException(.getPosition(), getCurrentLine(), "unterminated quoted string meets end of file");
         }
         
         // Figure end-char.  '\0' is special to indicate begin=end and that no nesting?
         switch(begin) {
         case '('end = ')'break;
         case '['end = ']'break;
         case '{'end = '}'break;
         case '<'end = '>'break;
         default
             end = begin
             begin = '\0';
         }
 
         switch (c) {
         case 'Q':
              = new StringTerm(begin ,end);
              = new Token("%"+ (shortHand ? (""+end) : ("" + c + begin)), getPosition());
             return .;
 
         case 'q':
              = new StringTerm(beginend);
              = new Token("%"+c+begingetPosition());
             return .;
 
         case 'W':
              = new StringTerm( | beginend);
             do {c = .read();} while (Character.isWhitespace(c));
             .unread(c);
              = new Token("%"+c+begingetPosition());
             return .;
 
         case 'w':
              = new StringTerm(/* str_squote | */ beginend);
             do {c = .read();} while (Character.isWhitespace(c));
             .unread(c);
              = new Token("%"+c+begingetPosition());
             return .;
 
         case 'x':
              = new StringTerm(beginend);
              = new Token("%"+c+begingetPosition());
             return .;
 
         case 'r':
              = new StringTerm(beginend);
              = new Token("%"+c+begingetPosition());
             return .;
 
         case 's':
              = new StringTerm(beginend);
             setState(.);
              = new Token("%"+c+begingetPosition());
             return .;
 
         default:
             throw new SyntaxException(.getPosition(), getCurrentLine(),
                     "Unknown type of %string. Expected 'Q', 'q', 'w', 'x', 'r' or any non letter character, but found '" + c + "'.");
         }
     }
     
     private int hereDocumentIdentifier() throws IOException {
         int c = .read(); 
         int term;
 
         int func = 0;
         if (c == '-') {
             c = .read();
             func = ;
         }
         
         ByteList markerValue;
         if (c == '\'' || c == '"' || c == '`') {
             if (c == '\'') {
                 func |= ;
             } else if (c == '"') {
                 func |= ;
             } else {
                 func |= 
             }
 
             markerValue = new ByteList();
             term = c;
             while ((c = .read()) !=  && c != term) {
                 markerValue.append(c);
             }
             if (c == ) {
                 throw new SyntaxException(.getPosition(), 
                         getCurrentLine(), "unterminated here document identifier");
             }	
         } else {
             if (!isIdentifierChar(c)) {
                 .unread(c);
                 if ((func & ) != 0) {
                     .unread('-');
                 }
                 return 0;
             }
             markerValue = new ByteList();
             term = '"';
             func |= ;
             do {
                 markerValue.append(c);
             } while ((c = .read()) !=  && isIdentifierChar(c));
 
             .unread(c);
         }
 
         ByteList lastLine = .readLineBytes();
         lastLine.append('\n');
          = new HeredocTerm(markerValuefunclastLine);
 
         if (term == '`') {
              = new Token("`"getPosition());
             return .;
         }
         
          = new Token("\""getPosition());
         // Hacky: Advance position to eat newline here....
         getPosition();
         return .;
     }
     
     private void arg_ambiguous() {
         if (.isVerbose()) .warning(.getPosition(), "Ambiguous first argument; make sure.");
     }
 
 
     /* MRI: magic_comment_marker */
     /* This impl is a little sucky.  We basically double scan the same bytelist twice.  Once here
      * and once in parseMagicComment.
      */
     private int magicCommentMarker(ByteList strint begin) {
         int i = begin;
         int len = str.length();
 
         while (i < len) {
             switch (str.charAt(i)) {
                 case '-':
                     if (i >= 2 && str.charAt(i - 1) == '*' && str.charAt(i - 2) == '-'return i + 1;
                     i += 2;
                     break;
                 case '*':
                     if (i + 1 >= lenreturn -1;
 
                     if (str.charAt(i + 1) != '-') {
                         i += 4;
                     } else if (str.charAt(i - 1) != '-') {
                         i += 2;
                     } else {
                         return i + 2;
                     }
                     break;
                 default:
                     i += 3;
                     break;
             }
         }
         return -1;
     }
 
 
     private boolean magicCommentSpecialChar(char c) {
         switch (c) {
             case '\''case '"'case ':'case ';'return true;
         }
         return false;
     }
 
     private static final String magicString = "([^\\s\'\":;]+)\\s*:\\s*(\"(?:\\\\.|[^\"])*\"|[^\"\\s;]+)[\\s;]*";
     private static final Regex magicRegexp = new Regex(.getBytes(), 0, .length(), 0, Encoding.load("ASCII"));
 
     // MRI: parser_magic_comment
     protected boolean parseMagicComment(ByteList magicLinethrows IOException {
         int length = magicLine.length();
 
         if (length <= 7) return false;
         int beg = magicCommentMarker(magicLine, 0);
         if (beg < 0) return false;
         int end = magicCommentMarker(magicLinebeg);
         if (end < 0) return false;
 
         // We only use a regex if -*- ... -*- is found.  Not too hot a path?
         int realSize = magicLine.getRealSize();
         int begin = magicLine.getBegin();
         Matcher matcher = .matcher(magicLine.getUnsafeBytes(), beginbegin + realSize);
         int result = matcher.search(beginbegin + realSize.);
 
         if (result < 0) return false;
 
         // Regexp is guarateed to have three matches
         int begs[] = matcher.getRegion().;
         int ends[] = matcher.getRegion().;
         String name = magicLine.subSequence(begs[1], ends[1]).toString();
         if (!name.equalsIgnoreCase("encoding")) return false;
 
         setEncoding(new ByteList(magicLine.getUnsafeBytes(), begs[2], ends[2] - begs[2]));
 
         return true;
     }
 
     // TODO: Make hand-rolled version of this
     private static final String encodingString = "[cC][oO][dD][iI][nN][gG]\\s*[=:]\\s*([a-zA-Z0-9\\-_]+)";
     private static final Regex encodingRegexp = new Regex(.getBytes(), 0,
             .length(), 0, Encoding.load("ASCII"));
 
     protected void handleFileEncodingComment(ByteList encodingLinethrows IOException {
         int realSize = encodingLine.getRealSize();
         int begin = encodingLine.getBegin();
         Matcher matcher = .matcher(encodingLine.getUnsafeBytes(), beginbegin + realSize);
         int result = matcher.search(beginbegin + realSize.);
 
         if (result < 0) return;
 
         int begs[] = matcher.getRegion().;
         int ends[] = matcher.getRegion().;
 
         setEncoding(new ByteList(encodingLine.getUnsafeBytes(), begs[1], ends[1] - begs[1]));
     }

    
Read a comment up to end of line.

Returns:
something or eof value
 
     protected int readComment() throws IOException {
         // 1.9 - first line comment handling
         ByteList commentLine;
         boolean handledMagicComment = false;
         if (!isOneEight() && .getLine() == 0 &&  == 0) {
             // Skip first line if it is a shebang line?
             // (not the same as MRI:parser_prepare/comment_at_top)
             if (.peek('!')) {
                 int c = .skipUntil('\n');
 
                 // TODO: Eat whitespace
                 
                 if (!.peek('#')) return c// Next line better also be a comment
             }
 
             commentLine = .readUntil('\n');
             if (commentLine != null) {
                 handledMagicComment = parseMagicComment(commentLine);
                 if (!handledMagicComment) {
                     handleFileEncodingComment(commentLine);
                 }
             }
             return 0;
         }
         
         return .skipUntil('\n');
     }
     
     /*
      * Not normally used, but is left in here since it can be useful in debugging
      * grammar and lexing problems.
      *
      */
     private void printToken(int token) {
         //System.out.print("LOC: " + support.getPosition() + " ~ ");
         
         switch (token) {
             case ...print("yyErrorCode,"); break;
             case ...print("kClass,"); break;
             case ...print("kModule,"); break;
             case ...print("kDEF,"); break;
             case ...print("kUNDEF,"); break;
             case ...print("kBEGIN,"); break;
             case ...print("kRESCUE,"); break;
             case ...print("kENSURE,"); break;
             case ...print("kEND,"); break;
             case ...print("kIF,"); break;
             case ...print("kUNLESS,"); break;
             case ...print("kTHEN,"); break;
             case ...print("kELSIF,"); break;
             case ...print("kELSE,"); break;
             case ...print("kCASE,"); break;
             case ...print("kWHEN,"); break;
             case ...print("kWHILE,"); break;
             case ...print("kUNTIL,"); break;
             case ...print("kFOR,"); break;
             case ...print("kBREAK,"); break;
             case ...print("kNEXT,"); break;
             case ...print("kREDO,"); break;
             case ...print("kRETRY,"); break;
             case ...print("kIN,"); break;
             case ...print("kDO,"); break;
             case ...print("kDO_COND,"); break;
             case ...print("kDO_BLOCK,"); break;
             case ...print("kRETURN,"); break;
             case ...print("kYIELD,"); break;
             case ...print("kSUPER,"); break;
             case ...print("kSELF,"); break;
             case ...print("kNIL,"); break;
             case ...print("kTRUE,"); break;
             case ...print("kFALSE,"); break;
             case ...print("kAND,"); break;
             case ...print("kOR,"); break;
             case ...print("kNOT,"); break;
             case ...print("kIF_MOD,"); break;
             case ...print("kUNLESS_MOD,"); break;
             case ...print("kWHILE_MOD,"); break;
             case ...print("kUNTIL_MOD,"); break;
             case ...print("kRESCUE_MOD,"); break;
             case ...print("kALIAS,"); break;
             case ...print("kDEFINED,"); break;
             case ...print("klBEGIN,"); break;
             case ...print("klEND,"); break;
             case ...print("k__LINE__,"); break;
             case ...print("k__FILE__,"); break;
             case ...print("k__ENCODING__,"); break;
             case ...print("kDO_LAMBDA,"); break;
             case ...print("tIDENTIFIER["value() + "],"); break;
             case ...print("tFID[" + value() + "],"); break;
             case ...print("tGVAR[" + value() + "],"); break;
             case ...print("tIVAR[" + value() +"],"); break;
             case ...print("tCONSTANT["value() +"],"); break;
             case ...print("tCVAR,"); break;
             case ...print("tINTEGER,"); break;
             case ...print("tFLOAT,"); break;
             case ...print("tSTRING_CONTENT[" + ((StrNodevalue()).getValue().toString() + "],"); break;
             case ...print("tSTRING_BEG,"); break;
             case ...print("tSTRING_END,"); break;
             case ...print("tSTRING_DBEG,"); break;
             case ...print("tSTRING_DVAR,"); break;
             case ...print("tXSTRING_BEG,"); break;
             case ...print("tREGEXP_BEG,"); break;
             case ...print("tREGEXP_END,"); break;
             case ...print("tWORDS_BEG,"); break;
             case ...print("tQWORDS_BEG,"); break;
             case ...print("tBACK_REF,"); break;
             case ...print("tBACK_REF2,"); break;
             case ...print("tNTH_REF,"); break;
             case ...print("tUPLUS"); break;
             case ...print("tUMINUS,"); break;
             case ...print("tPOW,"); break;
             case ...print("tCMP,"); break;
             case ...print("tEQ,"); break;
             case ...print("tEQQ,"); break;
             case ...print("tNEQ,"); break;
             case ...print("tGEQ,"); break;
             case ...print("tLEQ,"); break;
             case ...print("tANDOP,"); break;
             case ...print("tOROP,"); break;
             case ...print("tMATCH,"); break;
             case ...print("tNMATCH,"); break;
             case ...print("tDOT,"); break;
             case ...print("tDOT2,"); break;
             case ...print("tDOT3,"); break;
             case ...print("tAREF,"); break;
             case ...print("tASET,"); break;
             case ...print("tLSHFT,"); break;
             case ...print("tRSHFT,"); break;
             case ...print("tCOLON2,"); break;
             case ...print("tCOLON3,"); break;
             case ...print("tOP_ASGN,"); break;
             case ...print("tASSOC,"); break;
             case ...print("tLPAREN,"); break;
             case ...print("tLPAREN2,"); break;
             case ...print("tLPAREN_ARG,"); break;
             case ...print("tLBRACK,"); break;
             case ...print("tRBRACK,"); break;
             case ...print("tLBRACE,"); break;
             case ...print("tLBRACE_ARG,"); break;
             case ...