/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package de.bokelberg.flex.parser;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import com.adobe.ac.pmd.files.impl.FileUtils;
import com.adobe.ac.pmd.parser.IAS3Parser;
import com.adobe.ac.pmd.parser.IParserNode;
import com.adobe.ac.pmd.parser.KeyWords;
import com.adobe.ac.pmd.parser.NodeKind;
import com.adobe.ac.pmd.parser.Operators;
import com.adobe.ac.pmd.parser.exceptions.NullTokenException;
import com.adobe.ac.pmd.parser.exceptions.TokenException;
import com.adobe.ac.pmd.parser.exceptions.UnExpectedTokenException;
import com.adobe.ac.pmd.parser.exceptions.UnExpectedTokenException.Position;

import de.bokelberg.flex.parser.AS3Scanner.Token;

/**
 * @author xagnetti
 */
public class AS3Parser implements IAS3Parser
{
   /**
    * 
    */
   public static final String  ASDOC_COMMENT          = "/**";
   /**
    * 
    */
   public static final String  MULTIPLE_LINES_COMMENT = "/*";
   /**
    * 
    */
   public static final String  NEW_LINE               = "\n";
   /**
    * 
    */
   public static final String  SINGLE_LINE_COMMENT    = "//";
   private static final String VECTOR                 = "Vector";
   private Node                currentAsDoc;
   private Node                currentFunctionNode;
   private Node                currentMultiLineComment;
   private String              fileName;
   private boolean             isInFor;
   private AS3Scanner          scn;
   private Token               tok;

   /**
    * 
    */
   public AS3Parser()
   {
      this.scn = new AS3Scanner();
      isInFor = false;
   }

   /*
    * (non-Javadoc)
    * @see de.bokelberg.flex.parser.IAS3Parser#buildAst(java.lang.String)
    */
   public final IParserNode buildAst( final String filePath ) throws IOException,
                                                             TokenException
   {
      return parseLines( filePath,
                         FileUtils.readLines( new File( filePath ) ) );
   }

   /*
    * (non-Javadoc)
    * @see com.adobe.ac.pmd.parser.IAS3Parser#buildAst(java.lang.String,
    * java.lang.String[])
    */
   public final IParserNode buildAst( final String filePath,
                                      final String[] scriptBlockLines ) throws TokenException
   {
      return parseLines( filePath,
                         scriptBlockLines );
   }

   /**
    * @return
    */
   final AS3Scanner getScn()
   {
      return scn;
   }

   final void nextToken() throws TokenException
   {
      nextToken( false );
   }

   /**
    * Get the next token Skip comments and newlines for now In the end we want
    * to keep them though.
    * 
    * @throws TokenException
    */
   final void nextToken( final boolean ignoreDocumentation ) throws TokenException
   {
      do
      {
         if ( ignoreDocumentation )
         {
            nextTokenIgnoringDocumentation();
         }
         else
         {
            nextTokenAllowNewLine();
         }
      }
      while ( tok.getText().equals( NEW_LINE ) );
   }

   /**
    * tok is first content token
    * 
    * @throws TokenException
    */
   final Node parseClassContent() throws TokenException
   {
      final Node result = Node.create( NodeKind.CONTENT,
                                       tok.getLine(),
                                       tok.getColumn() );
      final List< Token > modifiers = new ArrayList< Token >();
      final List< Node > meta = new ArrayList< Node >();

      while ( !tokIs( Operators.RIGHT_CURLY_BRACKET ) )
      {
         if ( tokIs( Operators.LEFT_CURLY_BRACKET ) )
         {
            result.addChild( parseBlock() );
         }
         if ( tokIs( Operators.LEFT_SQUARE_BRACKET ) )
         {
            meta.add( parseMetaData() );
         }
         else if ( tokIs( KeyWords.VAR ) )
         {
            parseClassField( result,
                             modifiers,
                             meta );
         }
         else if ( tokIs( KeyWords.CONST ) )
         {
            parseClassConstant( result,
                                modifiers,
                                meta );
         }
         else if ( tokIs( KeyWords.IMPORT ) )
         {
            result.addChild( parseImport() );
         }
         else if ( tokIs( KeyWords.FUNCTION ) )
         {
            parseClassFunctions( result,
                                 modifiers,
                                 meta );
         }
         else
         {
            tryToParseCommentNode( result,
                                   modifiers );
         }
      }
      return result;
   }

   /**
    * tok is empty, since nextToken has not been called before
    * 
    * @throws UnExpectedTokenException
    */
   final Node parseCompilationUnit() throws TokenException
   {
      final Node result = Node.create( NodeKind.COMPILATION_UNIT,
                                       -1,
                                       -1 );

      nextTokenIgnoringDocumentation();
      if ( tokIs( KeyWords.PACKAGE ) )
      {
         result.addChild( parsePackage() );
      }
      result.addChild( parsePackageContent() );
      return result;
   }

   /**
    * @return
    * @throws TokenException
    */
   final IParserNode parseExpression() throws TokenException
   {
      return parseAssignmentExpression();
   }

   /**
    * tok is first content token
    * 
    * @throws TokenException
    */
   final Node parseInterfaceContent() throws TokenException
   {
      final Node result = Node.create( NodeKind.CONTENT,
                                       tok.getLine(),
                                       tok.getColumn() );
      while ( !tokIs( Operators.RIGHT_CURLY_BRACKET ) )
      {
         if ( tokIs( KeyWords.IMPORT ) )
         {
            result.addChild( parseImport() );
         }
         else if ( tokIs( KeyWords.FUNCTION ) )
         {
            result.addChild( parseFunctionSignature() );
         }
         else if ( tokIs( KeyWords.INCLUDE )
               || tokIs( KeyWords.INCLUDE_AS2 ) )
         {
            result.addChild( parseIncludeExpression() );
         }
         else if ( tokIs( Operators.LEFT_SQUARE_BRACKET ) )
         {
            while ( !tokIs( Operators.RIGHT_SQUARE_BRACKET ) )
            {
               nextToken();
            }
            nextToken();
         }
         else
         {
            tryToParseCommentNode( result,
                                   null );
         }
      }
      return result;
   }

   /**
    * tok is first token of content
    * 
    * @throws UnExpectedTokenException
    */
   final Node parsePackageContent() throws TokenException
   {
      final Node result = Node.create( NodeKind.CONTENT,
                                       tok.getLine(),
                                       tok.getColumn() );
      final List< Token > modifiers = new ArrayList< Token >();
      final List< Node > meta = new ArrayList< Node >();

      while ( !tokIs( Operators.RIGHT_CURLY_BRACKET )
            && !tokIs( KeyWords.EOF ) )
      {
         if ( tokIs( KeyWords.IMPORT ) )
         {
            result.addChild( parseImport() );
         }
         else if ( tokIs( KeyWords.USE ) )
         {
            result.addChild( parseUse() );
         }
         else if ( tokIs( Operators.LEFT_SQUARE_BRACKET ) )
         {
            meta.add( parseMetaData() );
         }
         else if ( tokIs( KeyWords.CLASS ) )
         {
            result.addChild( parseClass( meta,
                                         modifiers ) );

            modifiers.clear();
            meta.clear();
         }
         else if ( tokIs( KeyWords.INTERFACE ) )
         {
            result.addChild( parseInterface( meta,
                                             modifiers ) );
            modifiers.clear();
            meta.clear();
         }
         else if ( tokIs( KeyWords.FUNCTION ) )
         {
            parseClassFunctions( result,
                                 modifiers,
                                 meta );
         }
         else if ( tok.getText().startsWith( ASDOC_COMMENT ) )
         {
            currentAsDoc = Node.create( NodeKind.AS_DOC,
                                        tok.getLine(),
                                        tok.getColumn(),
                                        tok.getText() );
            nextToken();
         }
         else if ( tok.getText().startsWith( MULTIPLE_LINES_COMMENT ) )
         {
            currentMultiLineComment = Node.create( NodeKind.MULTI_LINE_COMMENT,
                                                   tok.getLine(),
                                                   tok.getColumn(),
                                                   tok.getText() );
            nextToken();
         }
         else
         {
            modifiers.add( tok );
            nextTokenIgnoringDocumentation();
         }
      }
      return result;
   }

   /**
    * @return
    * @throws TokenException
    */
   final Node parsePrimaryExpression() throws TokenException
   {
      Node result = Node.create( NodeKind.PRIMARY,
                                 tok.getLine(),
                                 tok.getColumn(),
                                 tok.getText() );

      if ( tokIs( Operators.LEFT_SQUARE_BRACKET ) )
      {
         result.addChild( parseArrayLiteral() );
      }
      else if ( tokIs( Operators.LEFT_CURLY_BRACKET ) )
      {
         result.addChild( parseObjectLiteral() );
      }
      else if ( tokIs( KeyWords.FUNCTION ) )
      {
         result.addChild( parseLambdaExpression() );
      }
      else if ( tokIs( KeyWords.NEW ) )
      {
         result = parseNewExpression();
      }
      else if ( tokIs( Operators.LEFT_PARENTHESIS ) )
      {
         result.addChild( parseEncapsulatedExpression() );
      }
      else
      {
         nextToken( true );
      }
      return result;
   }

   /**
    * tok is the first token of a statement
    * 
    * @throws TokenException
    */
   final IParserNode parseStatement() throws TokenException
   {
      IParserNode result;

      if ( tokIs( KeyWords.FOR ) )
      {
         result = parseFor();
      }
      else if ( tokIs( KeyWords.IF ) )
      {
         result = parseIf();
      }
      else if ( tokIs( KeyWords.SWITCH ) )
      {
         result = parseSwitch();
      }
      else if ( tokIs( KeyWords.DO ) )
      {
         result = parseDo();
      }
      else if ( tokIs( KeyWords.WHILE ) )
      {
         result = parseWhile();
      }
      else if ( tokIs( KeyWords.TRY ) )
      {
         result = parseTry();
      }
      else if ( tokIs( KeyWords.CATCH ) )
      {
         result = parseCatch();
      }
      else if ( tokIs( KeyWords.FINALLY ) )
      {
         result = parseFinally();
      }
      else if ( tokIs( Operators.LEFT_CURLY_BRACKET ) )
      {
         result = parseBlock();
      }
      else if ( tokIs( KeyWords.VAR ) )
      {
         result = parseVar();
      }
      else if ( tokIs( KeyWords.CONST ) )
      {
         result = parseConst();
      }
      else if ( tokIs( KeyWords.RETURN ) )
      {
         result = parseReturnStatement();
      }
      else if ( tokIs( Operators.SEMI_COLUMN ) )
      {
         result = parseEmptyStatement();
      }
      else
      {
         result = parseExpressionList();
         skip( Operators.SEMI_COLUMN );
      }
      return result;
   }

   /**
    * @return
    * @throws TokenException
    */
   final Node parseUnaryExpression() throws TokenException
   {
      Node result;
      if ( tokIs( Operators.INCREMENT ) )
      {
         nextToken();
         result = Node.create( NodeKind.PRE_INC,
                               tok.getLine(),
                               tok.getColumn(),
                               parseUnaryExpression() );
      }
      else if ( tokIs( Operators.DECREMENT ) )
      {
         nextToken();
         result = Node.create( NodeKind.PRE_DEC,
                               tok.getLine(),
                               tok.getColumn(),
                               parseUnaryExpression() );
      }
      else if ( tokIs( Operators.MINUS ) )
      {
         nextToken();
         result = Node.create( NodeKind.MINUS,
                               tok.getLine(),
                               tok.getColumn(),
                               parseUnaryExpression() );
      }
      else if ( tokIs( Operators.PLUS )
            || tokIs( Operators.PLUS_AS2 ) )
      {
         nextToken();
         result = Node.create( NodeKind.PLUS,
                               tok.getLine(),
                               tok.getColumn(),
                               parseUnaryExpression() );
      }
      else
      {
         result = parseUnaryExpressionNotPlusMinus();
      }
      return result;
   }

   private IParserNode collectVarListContent( final Node result ) throws TokenException
   {
      result.addChild( parseNameTypeInit() );
      while ( tokIs( Operators.COMMA ) )
      {
         nextToken( true );
         result.addChild( parseNameTypeInit() );
      }
      return result;
   }

   private void consume( final KeyWords keyword ) throws TokenException
   {
      consume( keyword.toString() );
   }

   private void consume( final Operators operator ) throws TokenException
   {
      consume( operator.toString() );
   }

   /**
    * Compare the current token to the parameter. If it equals, get the next
    * token. If not, throw a runtime exception.
    * 
    * @param text
    * @throws UnExpectedTokenException
    */
   private void consume( final String text ) throws TokenException
   {
      while ( tok.getText().startsWith( "//" ) )
      {
         nextToken();
      }

      if ( !tokIs( text ) )
      {
         throw new UnExpectedTokenException( tok.getText(),
                                             new Position( tok.getLine(), tok.getColumn() ),
                                             fileName,
                                             text );
      }
      nextToken();
   }

   private Node convertMeta( final List< Node > metadataList )
   {
      if ( metadataList == null
            || metadataList.isEmpty() )
      {
         return null;
      }

      final Node result = Node.create( NodeKind.META_LIST,
                                       tok.getLine(),
                                       tok.getColumn() );

      for ( final Node metadataNode : metadataList )
      {
         result.addChild( metadataNode );
      }
      return result;
   }

   private Node convertModifiers( final List< Token > modifierList )
   {
      if ( modifierList == null )
      {
         return null;
      }

      final Node result = Node.create( NodeKind.MOD_LIST,
                                       tok.getLine(),
                                       tok.getColumn() );

      for ( final Token modifierToken : modifierList )
      {
         result.addChild( NodeKind.MODIFIER,
                          tok.getLine(),
                          tok.getColumn(),
                          modifierToken.getText() );
      }
      return result;
   }

   private Node[] doParseSignature() throws TokenException
   {
      consume( KeyWords.FUNCTION );

      Node type = Node.create( NodeKind.TYPE,
                               tok.getLine(),
                               tok.getColumn(),
                               KeyWords.FUNCTION.toString() );
      if ( tokIs( KeyWords.SET )
            || tokIs( KeyWords.GET ) )
      {
         type = Node.create( NodeKind.TYPE,
                             tok.getLine(),
                             tok.getColumn(),
                             tok.getText() );
         nextToken(); // set or get
      }
      final Node name = Node.create( NodeKind.NAME,
                                     tok.getLine(),
                                     tok.getColumn(),
                                     tok.getText() );
      nextToken(); // name
      final Node params = parseParameterList();
      final Node returnType = parseOptionalType();
      return new Node[]
      { type,
                  name,
                  params,
                  returnType };
   }

   private NodeKind findFunctionTypeFromSignature( final Node[] signature )
   {
      for ( final Node node : signature )
      {
         if ( node.is( NodeKind.TYPE ) )
         {
            if ( node.getStringValue().equals( "set" ) )
            {
               return NodeKind.SET;
            }
            if ( node.getStringValue().equals( "get" ) )
            {
               return NodeKind.GET;
            }
            return NodeKind.FUNCTION;
         }
      }
      return NodeKind.FUNCTION;
   }

   /**
    * Get the next token Skip comments but keep newlines We need this method for
    * beeing able to decide if a returnStatement has an expression
    * 
    * @throws UnExpectedTokenException
    */
   private void nextTokenAllowNewLine() throws TokenException
   {
      do
      {
         tok = scn.nextToken();

         if ( tok == null )
         {
            throw new NullTokenException( fileName );

         }
         if ( tok.getText() == null )
         {
            throw new NullTokenException( fileName );
         }
      }
      while ( tok.getText().startsWith( SINGLE_LINE_COMMENT ) );
   }

   private void nextTokenIgnoringDocumentation() throws TokenException
   {
      do
      {
         nextToken();
      }
      while ( tok.getText().startsWith( MULTIPLE_LINES_COMMENT ) );
   }

   private IParserNode parseAdditiveExpression() throws TokenException
   {
      final Node result = Node.create( NodeKind.ADD,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseMultiplicativeExpression() );
      while ( tokIs( Operators.PLUS )
            || tokIs( Operators.PLUS_AS2 ) || tokIs( Operators.MINUS ) )
      {
         result.addChild( Node.create( NodeKind.OP,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       tok.getText() ) );
         nextToken( true );
         result.addChild( parseMultiplicativeExpression() );
      }
      return result.numChildren() > 1 ? result
                                     : result.getChild( 0 );
   }

   // ------------------------------------------------------------------------
   // language specific recursive descent parsing
   // ------------------------------------------------------------------------

   private IParserNode parseAndExpression() throws TokenException
   {
      final Node result = Node.create( NodeKind.AND,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseBitwiseOrExpression() );
      while ( tokIs( Operators.AND )
            || tokIs( Operators.AND_AS2 ) )
      {
         result.addChild( Node.create( NodeKind.OP,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       tok.getText() ) );
         nextToken( true );
         result.addChild( parseBitwiseOrExpression() );
      }
      return result.numChildren() > 1 ? result
                                     : result.getChild( 0 );
   }

   /**
    * tok is ( exit tok is first token after )
    */
   private Node parseArgumentList() throws TokenException
   {
      consume( Operators.LEFT_PARENTHESIS );
      final Node result = Node.create( NodeKind.ARGUMENTS,
                                       tok.getLine(),
                                       tok.getColumn() );
      while ( !tokIs( Operators.RIGHT_PARENTHESIS ) )
      {
         result.addChild( parseExpression() );
         skip( Operators.COMMA );
      }
      consume( Operators.RIGHT_PARENTHESIS );
      return result;
   }

   private Node parseArrayAccessor( final Node node ) throws TokenException
   {
      final Node result = Node.create( NodeKind.ARRAY_ACCESSOR,
                                       tok.getLine(),
                                       tok.getColumn() );
      result.addChild( node );
      while ( tokIs( Operators.LEFT_SQUARE_BRACKET ) )
      {
         nextToken( true );
         result.addChild( parseExpression() );
         consume( Operators.RIGHT_SQUARE_BRACKET );
      }
      return result;
   }

   /**
    * tok is [
    */
   private IParserNode parseArrayLiteral() throws TokenException
   {
      final Node result = Node.create( NodeKind.ARRAY,
                                       tok.getLine(),
                                       tok.getColumn() );
      consume( Operators.LEFT_SQUARE_BRACKET );
      while ( !tokIs( Operators.RIGHT_SQUARE_BRACKET ) )
      {
         result.addChild( parseExpression() );
         skip( Operators.COMMA );
      }
      consume( Operators.RIGHT_SQUARE_BRACKET );
      return result;
   }

   private IParserNode parseAssignmentExpression() throws TokenException
   {
      final Node result = Node.create( NodeKind.ASSIGN,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseConditionalExpression() );
      while ( tokIs( Operators.EQUAL )
            || tokIs( Operators.PLUS_EQUAL ) || tokIs( Operators.MINUS_EQUAL )
            || tokIs( Operators.TIMES_EQUAL ) || tokIs( Operators.DIVIDED_EQUAL )
            || tokIs( Operators.MODULO_EQUAL ) || tokIs( Operators.AND_EQUAL ) || tokIs( Operators.OR_EQUAL )
            || tokIs( Operators.XOR_EQUAL ) )
      {
         result.addChild( Node.create( NodeKind.OP,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       tok.getText() ) );
         nextToken( true );
         result.addChild( parseExpression() );
      }
      return result.numChildren() > 1 ? result
                                     : result.getChild( 0 );
   }

   private IParserNode parseBitwiseAndExpression() throws TokenException
   {
      final Node result = Node.create( NodeKind.B_AND,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseEqualityExpression() );
      while ( tokIs( Operators.B_AND ) )
      {
         result.addChild( Node.create( NodeKind.OP,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       tok.getText() ) );
         nextToken( true );
         result.addChild( parseEqualityExpression() );
      }
      return result.numChildren() > 1 ? result
                                     : result.getChild( 0 );
   }

   private IParserNode parseBitwiseOrExpression() throws TokenException
   {
      final Node result = Node.create( NodeKind.B_OR,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseBitwiseXorExpression() );
      while ( tokIs( Operators.B_OR ) )
      {
         result.addChild( Node.create( NodeKind.OP,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       tok.getText() ) );
         nextToken( true );
         result.addChild( parseBitwiseXorExpression() );
      }
      return result.numChildren() > 1 ? result
                                     : result.getChild( 0 );
   }

   private IParserNode parseBitwiseXorExpression() throws TokenException
   {
      final Node result = Node.create( NodeKind.B_XOR,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseBitwiseAndExpression() );
      while ( tokIs( Operators.B_XOR ) )
      {
         result.addChild( Node.create( NodeKind.OP,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       tok.getText() ) );
         nextToken( true );
         result.addChild( parseBitwiseAndExpression() );
      }
      return result.numChildren() > 1 ? result
                                     : result.getChild( 0 );
   }

   private Node parseBlock() throws TokenException
   {
      return parseBlock( Node.create( NodeKind.BLOCK,
                                      tok.getLine(),
                                      tok.getColumn() ) );
   }

   private Node parseBlock( final Node result ) throws TokenException
   {
      consume( Operators.LEFT_CURLY_BRACKET );

      while ( !tokIs( Operators.RIGHT_CURLY_BRACKET ) )
      {
         if ( tok.getText().startsWith( MULTIPLE_LINES_COMMENT ) )
         {
            currentFunctionNode.addChild( Node.create( NodeKind.MULTI_LINE_COMMENT,
                                                       tok.getLine(),
                                                       tok.getColumn(),
                                                       tok.getText() ) );
            nextToken();
         }
         else
         {
            result.addChild( parseStatement() );
         }
      }
      consume( Operators.RIGHT_CURLY_BRACKET );
      return result;
   }

   /**
    * tok is catch
    * 
    * @throws TokenException
    */
   private Node parseCatch() throws TokenException
   {
      consume( KeyWords.CATCH );
      consume( Operators.LEFT_PARENTHESIS );
      final Node result = Node.create( NodeKind.CATCH,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       Node.create( NodeKind.NAME,
                                                    tok.getLine(),
                                                    tok.getColumn(),
                                                    tok.getText() ) );
      nextToken( true ); // name
      if ( tokIs( Operators.COLUMN ) )
      {
         nextToken( true ); // :
         result.addChild( Node.create( NodeKind.TYPE,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       tok.getText() ) );
         nextToken( true ); // type
      }
      consume( Operators.RIGHT_PARENTHESIS );
      result.addChild( parseBlock() );
      return result;
   }

   /**
    * tok is class
    * 
    * @param meta
    * @param modifier
    * @throws TokenException
    */
   private Node parseClass( final List< Node > meta,
                            final List< Token > modifier ) throws TokenException
   {
      consume( KeyWords.CLASS );

      final Node result = Node.create( NodeKind.CLASS,
                                       tok.getLine(),
                                       tok.getColumn() );

      if ( currentAsDoc != null )
      {
         result.addChild( currentAsDoc );
         currentAsDoc = null;
      }
      if ( currentMultiLineComment != null )
      {
         result.addChild( currentMultiLineComment );
         currentMultiLineComment = null;
      }

      result.addChild( NodeKind.NAME,
                       tok.getLine(),
                       tok.getColumn(),
                       parseQualifiedName( true ) );

      result.addChild( convertMeta( meta ) );
      result.addChild( convertModifiers( modifier ) );

      // nextToken( true ); // name

      do
      {
         if ( tokIs( KeyWords.EXTENDS ) )
         {
            nextToken( true ); // extends
            result.addChild( NodeKind.EXTENDS,
                             tok.getLine(),
                             tok.getColumn(),
                             parseQualifiedName( false ) );
         }
         else if ( tokIs( KeyWords.IMPLEMENTS ) )
         {
            result.addChild( parseImplementsList() );
         }
      }
      while ( !tokIs( Operators.LEFT_CURLY_BRACKET ) );
      consume( Operators.LEFT_CURLY_BRACKET );
      result.addChild( parseClassContent() );
      consume( Operators.RIGHT_CURLY_BRACKET );
      return result;
   }

   private void parseClassConstant( final Node result,
                                    final List< Token > modifiers,
                                    final List< Node > meta ) throws TokenException
   {
      result.addChild( parseConstList( meta,
                                       modifiers ) );
      if ( tokIs( Operators.SEMI_COLUMN ) )
      {
         nextToken();
      }
      meta.clear();
      modifiers.clear();
   }

   private void parseClassField( final Node result,
                                 final List< Token > modifiers,
                                 final List< Node > meta ) throws TokenException
   {
      final Node varList = parseVarList( meta,
                                         modifiers );
      result.addChild( varList );
      if ( currentAsDoc != null )
      {
         varList.addChild( currentAsDoc );
         currentAsDoc = null;
      }
      if ( currentMultiLineComment != null )
      {
         result.addChild( currentMultiLineComment );
         currentMultiLineComment = null;
      }
      if ( tokIs( Operators.SEMI_COLUMN ) )
      {
         nextToken();
      }
      meta.clear();
      modifiers.clear();
   }

   private void parseClassFunctions( final Node result,
                                     final List< Token > modifiers,
                                     final List< Node > meta ) throws TokenException
   {
      result.addChild( parseFunction( meta,
                                      modifiers ) );
      meta.clear();
      modifiers.clear();
   }

   /**
    * tok is (
    * 
    * @throws TokenException
    */
   private Node parseCondition() throws TokenException
   {
      consume( Operators.LEFT_PARENTHESIS );
      final Node result = Node.create( NodeKind.CONDITION,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseExpression() );
      consume( Operators.RIGHT_PARENTHESIS );
      return result;
   }

   private IParserNode parseConditionalExpression() throws TokenException
   {
      final IParserNode result = parseOrExpression();
      if ( tokIs( Operators.QUESTION_MARK ) )
      {
         final Node conditional = Node.create( NodeKind.CONDITIONAL,
                                               tok.getLine(),
                                               tok.getColumn(),
                                               result );
         nextToken( true ); // ?
         conditional.addChild( parseExpression() );
         nextToken( true ); // :
         conditional.addChild( parseExpression() );

         return conditional;
      }
      return result;
   }

   private Node parseConst() throws TokenException
   {
      Node result;
      result = parseConstList( null,
                               null );
      skip( Operators.SEMI_COLUMN );
      return result;
   }

   /**
    * tok is const
    * 
    * @param modifiers
    * @param meta
    * @throws TokenException
    */
   private Node parseConstList( final List< Node > meta,
                                final List< Token > modifiers ) throws TokenException
   {
      consume( KeyWords.CONST );
      final Node result = Node.create( NodeKind.CONST_LIST,
                                       tok.getLine(),
                                       tok.getColumn() );
      result.addChild( convertMeta( meta ) );
      result.addChild( convertModifiers( modifiers ) );
      collectVarListContent( result );
      return result;
   }

   private Node parseDecrement( final Node node ) throws TokenException
   {
      nextToken( true );
      final Node result = Node.create( NodeKind.POST_DEC,
                                       tok.getLine(),
                                       tok.getColumn() );
      result.addChild( node );
      return result;
   }

   /**
    * tok is do
    * 
    * @throws TokenException
    */
   private Node parseDo() throws TokenException
   {
      consume( KeyWords.DO );
      final Node result = Node.create( NodeKind.DO,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseStatement() );
      consume( KeyWords.WHILE );
      result.addChild( parseCondition() );
      if ( tokIs( Operators.SEMI_COLUMN ) )
      {
         nextToken( true );
      }
      return result;
   }

   private Node parseDot( final Node node ) throws TokenException
   {
      nextToken();
      if ( tokIs( Operators.LEFT_PARENTHESIS ) )
      {
         nextToken();
         final Node result = Node.create( NodeKind.E4X_FILTER,
                                          tok.getLine(),
                                          tok.getColumn() );
         result.addChild( node );
         result.addChild( parseExpression() );
         consume( Operators.RIGHT_PARENTHESIS );
         return result;
      }
      else if ( tokIs( Operators.TIMES ) )
      {
         final Node result = Node.create( NodeKind.E4X_STAR,
                                          tok.getLine(),
                                          tok.getColumn() );
         result.addChild( node );
         return result;
      }
      final Node result = Node.create( NodeKind.DOT,
                                       tok.getLine(),
                                       tok.getColumn() );
      result.addChild( node );
      result.addChild( parseExpression() );
      return result;
   }

   private Node parseEmptyStatement() throws TokenException
   {
      Node result;
      result = Node.create( NodeKind.STMT_EMPTY,
                            tok.getLine(),
                            tok.getColumn(),
                            Operators.SEMI_COLUMN.toString() );
      nextToken( true );
      return result;
   }

   private Node parseEncapsulatedExpression() throws TokenException
   {
      consume( Operators.LEFT_PARENTHESIS );
      final Node result = Node.create( NodeKind.ENCAPSULATED,
                                       tok.getLine(),
                                       tok.getColumn() );
      result.addChild( parseExpressionList() );

      consume( Operators.RIGHT_PARENTHESIS );

      return result;
   }

   private IParserNode parseEqualityExpression() throws TokenException
   {
      final Node result = Node.create( NodeKind.EQUALITY,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseRelationalExpression() );
      while ( tokIs( Operators.DOUBLE_EQUAL )
            || tokIs( Operators.DOUBLE_EQUAL_AS2 ) || tokIs( Operators.STRICTLY_EQUAL )
            || tokIs( Operators.NON_EQUAL ) || tokIs( Operators.NON_EQUAL_AS2_1 )
            || tokIs( Operators.NON_EQUAL_AS2_2 ) || tokIs( Operators.NON_STRICTLY_EQUAL ) )
      {
         result.addChild( Node.create( NodeKind.OP,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       tok.getText() ) );
         nextToken( true );
         result.addChild( parseRelationalExpression() );
      }
      return result.numChildren() > 1 ? result
                                     : result.getChild( 0 );
   }

   private IParserNode parseExpressionList() throws TokenException
   {
      final Node result = Node.create( NodeKind.EXPR_LIST,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseAssignmentExpression() );
      while ( tokIs( Operators.COMMA ) )
      {
         nextToken( true );
         result.addChild( parseAssignmentExpression() );
      }
      return result.numChildren() > 1 ? result
                                     : result.getChild( 0 );
   }

   private Node parseFinally() throws TokenException
   {
      Node result;
      nextToken( true );
      result = Node.create( NodeKind.FINALLY,
                            tok.getLine(),
                            tok.getColumn(),
                            parseBlock() );
      return result;
   }

   /**
    * tok is for
    * 
    * @throws TokenException
    */
   private Node parseFor() throws TokenException
   {
      consume( KeyWords.FOR );

      if ( tokIs( KeyWords.EACH ) )
      {
         nextToken();
         return parseForEach();
      }
      else
      {
         return parseTraditionalFor();
      }
   }

   /**
    * tok is ( for each( var obj : Type in List )
    * 
    * @throws TokenException
    */
   private Node parseForEach() throws TokenException
   {
      consume( Operators.LEFT_PARENTHESIS );

      final Node result = Node.create( NodeKind.FOREACH,
                                       tok.getLine(),
                                       tok.getColumn() );
      if ( tokIs( KeyWords.VAR ) )
      {
         final Node var = Node.create( NodeKind.VAR,
                                       tok.getLine(),
                                       tok.getColumn() );
         nextToken();
         var.addChild( parseNameTypeInit() );
         result.addChild( var );
      }
      else
      {
         result.addChild( NodeKind.NAME,
                          tok.getLine(),
                          tok.getColumn(),
                          tok.getText() );
         // names allowed?
         nextToken();
      }
      nextToken(); // in
      result.addChild( NodeKind.IN,
                       tok.getLine(),
                       tok.getColumn(),
                       parseExpression() );
      consume( Operators.RIGHT_PARENTHESIS );
      result.addChild( parseStatement() );
      return result;
   }

   private Node parseForIn( final Node result ) throws TokenException
   {
      nextToken();
      result.addChild( NodeKind.IN,
                       tok.getLine(),
                       tok.getColumn(),
                       parseExpression() );
      result.setId( NodeKind.FORIN );
      return result;
   }

   /**
    * tok is function
    * 
    * @param modifiers
    * @param meta
    * @throws TokenException
    */
   private Node parseFunction( final List< Node > meta,
                               final List< Token > modifiers ) throws TokenException
   {
      final Node[] signature = doParseSignature();
      final Node result = Node.create( findFunctionTypeFromSignature( signature ),
                                       tok.getLine(),
                                       tok.getColumn(),
                                       signature[ 0 ].getStringValue() );

      if ( currentAsDoc != null )
      {
         result.addChild( currentAsDoc );
         currentAsDoc = null;
      }
      if ( currentMultiLineComment != null )
      {
         result.addChild( currentMultiLineComment );
         currentMultiLineComment = null;
      }
      result.addChild( convertMeta( meta ) );
      result.addChild( convertModifiers( modifiers ) );
      result.addChild( signature[ 1 ] );
      result.addChild( signature[ 2 ] );
      result.addChild( signature[ 3 ] );
      if ( tokIs( Operators.SEMI_COLUMN ) )
      {
         consume( Operators.SEMI_COLUMN );
      }
      else
      {
         result.addChild( parseFunctionBlock() );
      }
      currentFunctionNode = null;
      return result;
   }

   /**
    * tok is { exit tok is the first tok after }
    * 
    * @throws TokenException
    * @throws TokenException
    */

   private Node parseFunctionBlock() throws TokenException
   {
      final Node block = Node.create( NodeKind.BLOCK,
                                      tok.getLine(),
                                      tok.getColumn() );

      currentFunctionNode = block;

      parseBlock( block );

      return block;
   }

   private Node parseFunctionCall( final Node node ) throws TokenException
   {
      final Node result = Node.create( NodeKind.CALL,
                                       tok.getLine(),
                                       tok.getColumn() );
      result.addChild( node );
      while ( tokIs( Operators.LEFT_PARENTHESIS ) )
      {
         result.addChild( parseArgumentList() );
      }
      while ( tokIs( Operators.LEFT_SQUARE_BRACKET ) )
      {
         result.addChild( parseArrayLiteral() );
      }

      return result;
   }

   /**
    * tok is function exit tok is the first token after the optional ;
    * 
    * @throws TokenException
    */
   private Node parseFunctionSignature() throws TokenException
   {
      final Node[] signature = doParseSignature();
      skip( Operators.SEMI_COLUMN );
      final Node result = Node.create( findFunctionTypeFromSignature( signature ),
                                       tok.getLine(),
                                       tok.getColumn(),
                                       signature[ 0 ].getStringValue() );
      result.addChild( signature[ 1 ] );
      result.addChild( signature[ 2 ] );
      result.addChild( signature[ 3 ] );
      return result;
   }

   /**
    * tok is if
    * 
    * @throws TokenException
    */
   private Node parseIf() throws TokenException
   {
      consume( KeyWords.IF );
      final Node result = Node.create( NodeKind.IF,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseCondition() );
      result.addChild( parseStatement() );
      if ( tokIs( KeyWords.ELSE ) )
      {
         nextToken( true );
         result.addChild( parseStatement() );
      }
      return result;
   }

   /**
    * tok is implements implements a,b,c exit tok is the first token after the
    * list of qualfied names
    * 
    * @throws TokenException
    */
   private Node parseImplementsList() throws TokenException
   {
      consume( KeyWords.IMPLEMENTS );

      final Node result = Node.create( NodeKind.IMPLEMENTS_LIST,
                                       tok.getLine(),
                                       tok.getColumn() );
      result.addChild( NodeKind.IMPLEMENTS,
                       tok.getLine(),
                       tok.getColumn(),
                       parseQualifiedName( true ) );
      while ( tokIs( Operators.COMMA ) )
      {
         nextToken( true );
         result.addChild( NodeKind.IMPLEMENTS,
                          tok.getLine(),
                          tok.getColumn(),
                          parseQualifiedName( false ) );
      }
      return result;
   }

   /**
    * tok is import
    * 
    * @throws TokenException
    */
   private Node parseImport() throws TokenException
   {
      consume( KeyWords.IMPORT );
      final Node result = Node.create( NodeKind.IMPORT,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseImportName() );
      skip( Operators.SEMI_COLUMN );
      return result;
   }

   /**
    * tok is the first part of a name the last part can be a star exit tok is
    * the first token, which doesn't belong to the name
    * 
    * @throws TokenException
    */
   private String parseImportName() throws TokenException
   {
      final StringBuffer result = new StringBuffer();

      result.append( tok.getText() );
      nextToken();
      while ( tokIs( Operators.DOT ) )
      {
         result.append( Operators.DOT );
         nextToken(); // .
         result.append( tok.getText() );
         nextToken(); // part of name
      }
      return result.toString();
   }

   private IParserNode parseIncludeExpression() throws TokenException
   {
      final Node result = Node.create( NodeKind.INCLUDE,
                                       tok.getLine(),
                                       tok.getColumn() );
      if ( tokIs( KeyWords.INCLUDE ) )
      {
         consume( KeyWords.INCLUDE );
      }
      else if ( tokIs( KeyWords.INCLUDE_AS2 ) )
      {
         consume( KeyWords.INCLUDE_AS2 );
      }
      result.addChild( parseExpression() );
      return result;
   }

   private Node parseIncrement( final Node node ) throws TokenException
   {
      nextToken( true );
      final Node result = Node.create( NodeKind.POST_INC,
                                       tok.getLine(),
                                       tok.getColumn() );
      result.addChild( node );
      return result;
   }

   /**
    * tok is interface
    * 
    * @param meta
    * @param modifier
    * @throws TokenException
    */
   private Node parseInterface( final List< Node > meta,
                                final List< Token > modifier ) throws TokenException
   {
      consume( KeyWords.INTERFACE );
      final Node result = Node.create( NodeKind.INTERFACE,
                                       tok.getLine(),
                                       tok.getColumn() );

      if ( currentAsDoc != null )
      {
         result.addChild( currentAsDoc );
         currentAsDoc = null;
      }
      if ( currentMultiLineComment != null )
      {
         result.addChild( currentMultiLineComment );
         currentMultiLineComment = null;
      }
      result.addChild( NodeKind.NAME,
                       tok.getLine(),
                       tok.getColumn(),
                       parseQualifiedName( true ) );

      result.addChild( convertMeta( meta ) );
      result.addChild( convertModifiers( modifier ) );

      if ( tokIs( KeyWords.EXTENDS ) )
      {
         nextToken(); // extends
         result.addChild( NodeKind.EXTENDS,
                          tok.getLine(),
                          tok.getColumn(),
                          parseQualifiedName( false ) );
      }
      while ( tokIs( Operators.COMMA ) )
      {
         nextToken(); // comma
         result.addChild( NodeKind.EXTENDS,
                          tok.getLine(),
                          tok.getColumn(),
                          parseQualifiedName( false ) );
      }
      consume( Operators.LEFT_CURLY_BRACKET );
      result.addChild( parseInterfaceContent() );
      consume( Operators.RIGHT_CURLY_BRACKET );
      return result;
   }

   /**
    * tok is function
    * 
    * @throws TokenException
    */
   private Node parseLambdaExpression() throws TokenException
   {
      consume( KeyWords.FUNCTION );
      Node result;

      if ( tok.getText().compareTo( "(" ) == 0 )
      {
         result = Node.create( NodeKind.LAMBDA,
                               tok.getLine(),
                               tok.getColumn() );
      }
      else
      {
         result = Node.create( NodeKind.FUNCTION,
                               tok.getLine(),
                               tok.getColumn(),
                               tok.getText() );
         nextToken( true );
      }
      result.addChild( parseParameterList() );
      result.addChild( parseOptionalType() );
      result.addChild( parseBlock() );
      return result;
   }

   private IParserNode parseLines( final String filePath,
                                   final String[] lines ) throws TokenException
   {
      setFileName( filePath );
      scn = new AS3Scanner();
      scn.setLines( lines );
      return parseCompilationUnit();
   }

   /**
    * tok is [ [id] [id ("test")] [id (name="test",type="a.b.c.Event")] exit
    * token is the first token after ]
    * 
    * @throws TokenException
    */
   private Node parseMetaData() throws TokenException
   {
      final StringBuffer buffer = new StringBuffer();

      final int line = tok.getLine();
      final int column = tok.getColumn();

      consume( Operators.LEFT_SQUARE_BRACKET );
      while ( !tokIs( Operators.RIGHT_SQUARE_BRACKET ) )
      {
         if ( buffer.length() > 0 )
         {
            buffer.append( ' ' );
         }
         buffer.append( tok.getText() );
         nextToken();
      }
      skip( Operators.RIGHT_SQUARE_BRACKET );
      final Node metaDataNode = Node.create( NodeKind.META,
                                             line,
                                             column,
                                             buffer.toString() );

      return metaDataNode;
   }

   private IParserNode parseMultiplicativeExpression() throws TokenException
   {
      final Node result = Node.create( NodeKind.MULTIPLICATION,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseUnaryExpression() );
      while ( tokIs( Operators.TIMES )
            || tokIs( Operators.SLASH ) || tokIs( Operators.MODULO ) )
      {
         result.addChild( Node.create( NodeKind.OP,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       tok.getText() ) );
         nextToken( true );
         result.addChild( parseUnaryExpression() );
      }
      return result.numChildren() > 1 ? result
                                     : result.getChild( 0 );
   }

   private String parseNamespaceName() throws TokenException
   {
      final String name = tok.getText();
      nextToken(); // simple name for now
      return name;
   }

   private Node parseNameTypeInit() throws TokenException
   {
      final Node result = Node.create( NodeKind.NAME_TYPE_INIT,
                                       tok.getLine(),
                                       tok.getColumn() );
      result.addChild( NodeKind.NAME,
                       tok.getLine(),
                       tok.getColumn(),
                       tok.getText() );
      nextToken( true ); // name
      result.addChild( parseOptionalType() );
      result.addChild( parseOptionalInit() );
      return result;
   }

   private Node parseNewExpression() throws TokenException
   {
      consume( KeyWords.NEW );

      final Node result = Node.create( NodeKind.NEW,
                                       tok.getLine(),
                                       tok.getColumn() );
      result.addChild( parseExpression() ); // name
      if ( tokIs( Operators.VECTOR_START ) )
      {
         result.addChild( Node.create( NodeKind.VECTOR,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseVector() ) );
      }
      if ( tokIs( Operators.LEFT_PARENTHESIS ) )
      {
         result.addChild( parseArgumentList() );
      }
      return result;
   }

   /**
    * tok is {
    */
   private Node parseObjectLiteral() throws TokenException
   {
      final Node result = Node.create( NodeKind.OBJECT,
                                       tok.getLine(),
                                       tok.getColumn() );
      consume( Operators.LEFT_CURLY_BRACKET );
      while ( !tokIs( Operators.RIGHT_CURLY_BRACKET ) )
      {
         result.addChild( parseObjectLiteralPropertyDeclaration() );
         skip( Operators.COMMA );
      }
      consume( Operators.RIGHT_CURLY_BRACKET );
      return result;
   }

   /*
    * tok is name
    */
   private Node parseObjectLiteralPropertyDeclaration() throws TokenException
   {
      final Node result = Node.create( NodeKind.PROP,
                                       tok.getLine(),
                                       tok.getColumn() );
      final Node name = Node.create( NodeKind.NAME,
                                     tok.getLine(),
                                     tok.getColumn(),
                                     tok.getText() );
      result.addChild( name );
      nextToken(); // name
      consume( Operators.COLUMN );
      result.addChild( NodeKind.VALUE,
                       tok.getLine(),
                       tok.getColumn(),
                       parseExpression() );
      return result;
   }

   /**
    * if tok is "=" parse the expression otherwise do nothing
    * 
    * @return
    */
   private Node parseOptionalInit() throws TokenException
   {
      Node result = null;
      if ( tokIs( Operators.EQUAL ) )
      {
         nextToken( true );
         result = Node.create( NodeKind.INIT,
                               tok.getLine(),
                               tok.getColumn(),
                               parseExpression() );
      }
      return result;
   }

   /**
    * if tok is ":" parse the type otherwise do nothing
    * 
    * @return
    * @throws TokenException
    */
   private Node parseOptionalType() throws TokenException
   {
      Node result = Node.create( NodeKind.TYPE,
                                 tok.getLine(),
                                 tok.getColumn(),
                                 "" );
      if ( tokIs( Operators.COLUMN ) )
      {
         nextToken( true );
         result = parseType();
      }
      return result;
   }

   private IParserNode parseOrExpression() throws TokenException
   {
      final Node result = Node.create( NodeKind.OR,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseAndExpression() );
      while ( tokIs( Operators.LOGICAL_OR )
            || tokIs( Operators.LOGICAL_OR_AS2 ) )
      {
         result.addChild( Node.create( NodeKind.OP,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       tok.getText() ) );
         nextToken( true );
         result.addChild( parseAndExpression() );
      }
      return result.numChildren() > 1 ? result
                                     : result.getChild( 0 );
   }

   /**
    * tok is package
    * 
    * @throws UnExpectedTokenException
    */
   private Node parsePackage() throws TokenException
   {
      consume( KeyWords.PACKAGE );

      final Node result = Node.create( NodeKind.PACKAGE,
                                       tok.getLine(),
                                       tok.getColumn() );
      final StringBuffer nameBuffer = new StringBuffer();

      while ( !tokIs( Operators.LEFT_CURLY_BRACKET ) )
      {
         nameBuffer.append( tok.getText() );
         nextToken();
      }
      result.addChild( NodeKind.NAME,
                       tok.getLine(),
                       tok.getColumn(),
                       nameBuffer.toString() );
      consume( Operators.LEFT_CURLY_BRACKET );
      result.addChild( parsePackageContent() );
      consume( Operators.RIGHT_CURLY_BRACKET );
      return result;
   }

   /**
    * tok is the name of a parameter or ...
    */
   private Node parseParameter() throws TokenException
   {
      final Node result = Node.create( NodeKind.PARAMETER,
                                       tok.getLine(),
                                       tok.getColumn() );
      if ( tokIs( Operators.REST_PARAMETERS ) )
      {
         nextToken( true ); // ...
         final Node rest = Node.create( NodeKind.REST,
                                        tok.getLine(),
                                        tok.getColumn(),
                                        tok.getText() );
         nextToken( true ); // rest
         result.addChild( rest );
      }
      else
      {
         result.addChild( parseNameTypeInit() );
      }
      return result;
   }

   /**
    * tok is (
    * 
    * @throws TokenException
    */
   private Node parseParameterList() throws TokenException
   {
      consume( Operators.LEFT_PARENTHESIS );

      final Node result = Node.create( NodeKind.PARAMETER_LIST,
                                       tok.getLine(),
                                       tok.getColumn() );
      while ( !tokIs( Operators.RIGHT_PARENTHESIS ) )
      {
         result.addChild( parseParameter() );
         if ( tokIs( Operators.COMMA ) )
         {
            nextToken( true );
         }
         else
         {
            break;
         }
      }
      consume( Operators.RIGHT_PARENTHESIS );
      return result;
   }

   /**
    * tok is first part of the name exit tok is the first token after the name
    * 
    * @throws TokenException
    */
   private String parseQualifiedName( final boolean skipPackage ) throws TokenException
   {
      final StringBuffer buffer = new StringBuffer();

      buffer.append( tok.getText() );
      nextToken();
      while ( tokIs( Operators.DOT )
            || tokIs( Operators.DOUBLE_COLUMN ) )
      {
         buffer.append( tok.getText() );
         nextToken();
         buffer.append( tok.getText() );
         nextToken(); // name
      }

      if ( skipPackage )
      {
         return buffer.substring( buffer.lastIndexOf( Operators.DOT.toString() ) + 1 );
      }
      return buffer.toString();
   }

   private IParserNode parseRelationalExpression() throws TokenException
   {
      final Node result = Node.create( NodeKind.RELATION,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseShiftExpression() );
      while ( tokIs( Operators.INFERIOR )
            || tokIs( Operators.INFERIOR_AS2 ) || tokIs( Operators.INFERIOR_OR_EQUAL )
            || tokIs( Operators.INFERIOR_OR_EQUAL_AS2 ) || tokIs( Operators.SUPERIOR )
            || tokIs( Operators.SUPERIOR_AS2 ) || tokIs( Operators.SUPERIOR_OR_EQUAL )
            || tokIs( Operators.SUPERIOR_OR_EQUAL_AS2 ) || tokIs( KeyWords.IS ) || tokIs( KeyWords.IN )
            && !isInFor || tokIs( KeyWords.AS ) || tokIs( KeyWords.INSTANCE_OF ) )
      {
         if ( !tokIs( KeyWords.AS ) )
         {
            result.addChild( Node.create( NodeKind.OP,
                                          tok.getLine(),
                                          tok.getColumn(),
                                          tok.getText() ) );
         }
         else
         {
            result.addChild( Node.create( NodeKind.AS,
                                          tok.getLine(),
                                          tok.getColumn(),
                                          tok.getText() ) );
         }
         nextToken( true );
         result.addChild( parseShiftExpression() );
      }
      return result.numChildren() > 1 ? result
                                     : result.getChild( 0 );
   }

   private IParserNode parseReturnStatement() throws TokenException
   {
      Node result;

      nextTokenAllowNewLine();
      if ( tokIs( NEW_LINE )
            || tokIs( Operators.SEMI_COLUMN ) )
      {
         nextToken( true );
         result = Node.create( NodeKind.RETURN,
                               tok.getLine(),
                               tok.getColumn(),
                               "" );
      }
      else
      {
         result = Node.create( NodeKind.RETURN,
                               tok.getLine(),
                               tok.getColumn(),
                               parseExpression() );
         skip( Operators.SEMI_COLUMN );
      }
      return result;
   }

   private IParserNode parseShiftExpression() throws TokenException
   {
      final Node result = Node.create( NodeKind.SHIFT,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseAdditiveExpression() );
      while ( tokIs( Operators.DOUBLE_SHIFT_LEFT )
            || tokIs( Operators.TRIPLE_SHIFT_LEFT ) || tokIs( Operators.DOUBLE_SHIFT_RIGHT )
            || tokIs( Operators.TRIPLE_SHIFT_RIGHT ) )
      {
         result.addChild( Node.create( NodeKind.OP,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       tok.getText() ) );
         nextToken( true );
         result.addChild( parseAdditiveExpression() );
      }
      return result.numChildren() > 1 ? result
                                     : result.getChild( 0 );
   }

   /**
    * tok is switch
    * 
    * @throws TokenException
    */
   private Node parseSwitch() throws TokenException
   {
      consume( KeyWords.SWITCH );
      final Node result = Node.create( NodeKind.SWITCH,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseCondition() );
      if ( tokIs( Operators.LEFT_CURLY_BRACKET ) )
      {
         nextToken();
         result.addChild( parseSwitchCases() );
         consume( Operators.RIGHT_CURLY_BRACKET );
      }
      return result;
   }

   /**
    * tok is case, default or the first token of the first statement
    * 
    * @throws TokenException
    */
   private Node parseSwitchBlock() throws TokenException
   {
      final Node result = Node.create( NodeKind.SWITCH_BLOCK,
                                       tok.getLine(),
                                       tok.getColumn() );
      while ( !tokIs( KeyWords.CASE )
            && !tokIs( KeyWords.DEFAULT ) && !tokIs( Operators.RIGHT_CURLY_BRACKET ) )
      {
         result.addChild( parseStatement() );
      }
      return result;
   }

   /**
    * tok is { exit tok is }
    * 
    * @throws TokenException
    */
   private Node parseSwitchCases() throws TokenException
   {
      final Node result = Node.create( NodeKind.CASES,
                                       tok.getLine(),
                                       tok.getColumn() );
      for ( ;; )
      {
         if ( tokIs( Operators.RIGHT_CURLY_BRACKET ) )
         {
            break;
         }
         else if ( tokIs( KeyWords.CASE ) )
         {
            nextToken( true ); // case
            final Node caseNode = Node.create( NodeKind.CASE,
                                               tok.getLine(),
                                               tok.getColumn(),
                                               parseExpression() );
            consume( Operators.COLUMN );
            caseNode.addChild( parseSwitchBlock() );
            result.addChild( caseNode );
         }
         else if ( tokIs( KeyWords.DEFAULT ) )
         {
            nextToken( true ); // default
            consume( Operators.COLUMN );
            final Node caseNode = Node.create( NodeKind.CASE,
                                               tok.getLine(),
                                               tok.getColumn(),
                                               Node.create( NodeKind.DEFAULT,
                                                            tok.getLine(),
                                                            tok.getColumn(),
                                                            KeyWords.DEFAULT.toString() ) );
            caseNode.addChild( parseSwitchBlock() );
            result.addChild( caseNode );
         }
      }
      return result;
   }

   /**
    * tok is ( for( var x : int = 0; i < length; i++ ) for( var s : String in
    * Object )
    * 
    * @throws TokenException
    */
   private Node parseTraditionalFor() throws TokenException
   {
      consume( Operators.LEFT_PARENTHESIS );

      final Node result = Node.create( NodeKind.FOR,
                                       tok.getLine(),
                                       tok.getColumn() );
      if ( !tokIs( Operators.SEMI_COLUMN ) )
      {
         if ( tokIs( KeyWords.VAR ) )
         {
            result.addChild( NodeKind.INIT,
                             tok.getLine(),
                             tok.getColumn(),
                             parseVarList( null,
                                           null ) );
         }
         else
         {
            isInFor = true;
            result.addChild( NodeKind.INIT,
                             tok.getLine(),
                             tok.getColumn(),
                             parseExpression() );
            isInFor = false;
         }
         if ( tokIs( NodeKind.IN.toString() ) )
         {
            return parseForIn( result );
         }
      }
      consume( Operators.SEMI_COLUMN );
      if ( !tokIs( Operators.SEMI_COLUMN ) )
      {
         result.addChild( NodeKind.COND,
                          tok.getLine(),
                          tok.getColumn(),
                          parseExpression() );
      }
      consume( Operators.SEMI_COLUMN );
      if ( !tokIs( Operators.RIGHT_PARENTHESIS ) )
      {
         result.addChild( NodeKind.ITER,
                          tok.getLine(),
                          tok.getColumn(),
                          parseExpressionList() );
      }
      consume( Operators.RIGHT_PARENTHESIS );
      result.addChild( parseStatement() );
      return result;
   }

   private Node parseTry() throws TokenException
   {
      Node result;
      nextToken( true );
      result = Node.create( NodeKind.TRY,
                            tok.getLine(),
                            tok.getColumn(),
                            parseBlock() );
      return result;
   }

   private Node parseType() throws TokenException
   {
      Node result;
      if ( tok.getText().equals( VECTOR ) )
      {
         result = parseVector();
      }
      else
      {
         result = Node.create( NodeKind.TYPE,
                               tok.getLine(),
                               tok.getColumn(),
                               parseQualifiedName( true ) );
         // nextToken( true );
      }
      return result;
   }

   private Node parseUnaryExpressionNotPlusMinus() throws TokenException
   {
      Node result;
      if ( tokIs( KeyWords.DELETE ) )
      {
         nextToken( true );
         result = Node.create( NodeKind.DELETE,
                               tok.getLine(),
                               tok.getColumn(),
                               parseExpression() );
      }
      else if ( tokIs( KeyWords.VOID ) )
      {
         nextToken( true );
         result = Node.create( NodeKind.VOID,
                               tok.getLine(),
                               tok.getColumn(),
                               parseExpression() );
      }
      else if ( tokIs( KeyWords.TYPEOF ) )
      {
         nextToken( true );
         result = Node.create( NodeKind.TYPEOF,
                               tok.getLine(),
                               tok.getColumn(),
                               parseExpression() );
      }
      else if ( tokIs( "!" )
            || tokIs( "not" ) )
      {
         nextToken( true );
         result = Node.create( NodeKind.NOT,
                               tok.getLine(),
                               tok.getColumn(),
                               parseExpression() );
      }
      else if ( tokIs( "~" ) )
      {
         nextToken( true );
         result = Node.create( NodeKind.B_NOT,
                               tok.getLine(),
                               tok.getColumn(),
                               parseExpression() );
      }
      else
      {
         result = parseUnaryPostfixExpression();
      }
      return result;
   }

   private Node parseUnaryPostfixExpression() throws TokenException
   {
      Node node = parsePrimaryExpression();

      if ( tokIs( Operators.LEFT_SQUARE_BRACKET ) )
      {
         node = parseArrayAccessor( node );
      }
      else if ( tokIs( Operators.LEFT_PARENTHESIS ) )
      {
         node = parseFunctionCall( node );
      }
      if ( tokIs( Operators.INCREMENT ) )
      {
         node = parseIncrement( node );
      }
      else if ( tokIs( Operators.DECREMENT ) )
      {
         node = parseDecrement( node );
      }
      else if ( tokIs( Operators.DOT )
            || tokIs( Operators.DOUBLE_COLUMN ) )
      {
         node = parseDot( node );
      }
      return node;
   }

   private Node parseUse() throws TokenException
   {
      consume( KeyWords.USE );
      consume( KeyWords.NAMESPACE );
      final Node result = Node.create( NodeKind.USE,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       parseNamespaceName() );
      skip( Operators.SEMI_COLUMN );
      return result;
   }

   private Node parseVar() throws TokenException
   {
      Node result;
      result = parseVarList( null,
                             null );
      skip( Operators.SEMI_COLUMN );
      return result;
   }

   /**
    * tok is var var x, y : String, z : int = 0;
    * 
    * @param modifiers
    * @param meta
    * @throws TokenException
    */
   private Node parseVarList( final List< Node > meta,
                              final List< Token > modifiers ) throws TokenException
   {
      consume( KeyWords.VAR );
      final Node result = Node.create( NodeKind.VAR_LIST,
                                       tok.getLine(),
                                       tok.getColumn() );
      result.addChild( convertMeta( meta ) );
      result.addChild( convertModifiers( modifiers ) );
      collectVarListContent( result );
      return result;
   }

   private Node parseVector() throws TokenException
   {
      final Node result = Node.create( NodeKind.VECTOR,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       "" );
      if ( tok.getText().compareTo( "Vector" ) == 0 )
      {
         nextToken();
      }
      consume( Operators.VECTOR_START );

      result.addChild( parseType() );

      consume( Operators.SUPERIOR );

      return result;
   }

   /**
    * tok is while
    * 
    * @throws TokenException
    */
   private Node parseWhile() throws TokenException
   {
      consume( KeyWords.WHILE );
      final Node result = Node.create( NodeKind.WHILE,
                                       tok.getLine(),
                                       tok.getColumn() );
      result.addChild( parseCondition() );
      result.addChild( parseStatement() );
      return result;
   }

   private void setFileName( final String fileNameToParse )
   {
      fileName = fileNameToParse;
   }

   private void skip( final Operators operator ) throws TokenException
   {
      skip( operator.toString() );
   }

   /**
    * Skip the current token, if it equals to the parameter
    * 
    * @param text
    * @throws UnExpectedTokenException
    */
   private void skip( final String text ) throws TokenException
   {
      if ( tokIs( text ) )
      {
         nextToken();
      }
   }

   private boolean tokIs( final KeyWords keyword )
   {
      return tok.getText().compareTo( keyword.toString() ) == 0;
   }

   private boolean tokIs( final Operators operator )
   {
      return tok.getText().compareTo( operator.toString() ) == 0;
   }

   /**
    * Compare the current token to the parameter
    * 
    * @param text
    * @return true, if tok's text property equals the parameter
    */
   private boolean tokIs( final String text )
   {
      return tok.getText().equals( text );
   }

   private void tryToParseCommentNode( final Node result,
                                       final List< Token > modifiers ) throws TokenException
   {
      if ( tok.getText().startsWith( ASDOC_COMMENT ) )
      {
         currentAsDoc = Node.create( NodeKind.AS_DOC,
                                     tok.getLine(),
                                     tok.getColumn(),
                                     tok.getText() );
         nextToken();
      }
      else if ( tok.getText().startsWith( MULTIPLE_LINES_COMMENT ) )
      {
         result.addChild( Node.create( NodeKind.MULTI_LINE_COMMENT,
                                       tok.getLine(),
                                       tok.getColumn(),
                                       tok.getText() ) );
         nextToken();
      }
      else
      {
         if ( modifiers != null )
         {
            modifiers.add( tok );
         }
         nextTokenIgnoringDocumentation();
      }
   }
}