package code.loader.parser.txtParser;

import java_cup.runtime.*;
import java.util.*;
import code.type.*;
import code.symbols.*;
import code.instr.*;

parser code {:

/** We can't use the usual setScanner/getScanner mechanism, because our
 lexer doesn't quite match the Lexer interface. */

Yylex jlexer;
public TxtCupParser(Yylex jlexer) {
  super();
  this.jlexer = jlexer;
}

public void syntax_error(java_cup.runtime.Symbol current) {} // override default message

public void unrecovered_syntax_error(java_cup.runtime.Symbol current) throws ParseError {
  report_fatal_error("Error at line " + current.left + ": Parse Syntax error",current);
}

public void report_fatal_error(String message, java_cup.runtime.Symbol info) throws ParseError {
 done_parsing();
 throw new ParseError(message);
}

:}


action code {:
  // All these are data members describing the module being parsed.
  Vector importedv=new Vector();
  Vector symbolv=new Vector();
  Boolean compiled = null;
  String source = null;
  String name = null;
  Integer timestamp = null ; // a dummy variable to make things more meaningful
  // Order of the elements of 'a' is important.
  Object [] a = {importedv, symbolv, compiled, source,name,timestamp};
:}


scan with {: Token tmp = jlexer.yylex();
             // System.out.println(tmp.sym+" "+tmp.parse_state+" "+tmp.value);
             return tmp; :}

terminal String	    UNQUAL_ID;
terminal Integer	INTEGER;
terminal Float	    FLOAT;

terminal	NAME, COMPILED, TRUE, FALSE, TIME,
            IMPORT, TYPE, CONSTRUCTOR, OPERATION,
            PUBLIC, PRIVATE, LEFT, RIGHT, NONASSOC;

terminal	BRANCH, CHOICE, FAIL, LOAD, MAKEREF, MAKEANON, MAKECHAR, MAKEINT, MAKEFLOAT,
            MAKEPARTIAL, MAKETERM, MAKEVAR, NARROW,
            POP, PUSH, REPLACE, RESIDUATE, STOREVAR;

terminal	COLONCOLON, LPAREN, RPAREN, LCUBRA, RCUBRA, COMMA, DOT, ARROW;

non terminal		                        module;
non terminal                                name;
non terminal		                        compiled;
non terminal		                        bool;
non terminal                                timestamp;
non terminal Vector []	                    imported_symbol;
non terminal                                imported_or_symbol;
non terminal String	                        imported;
non terminal code.symbols.Symbol            symbol;
non terminal TypeSymbol                     type;
non terminal                                qualtype_name;
non terminal String                         constructor_symbol_name;
non terminal String                         operation_symbol_name;
non terminal Integer	                    visibility;
non terminal ConstructorSymbol	            constructor;
non terminal OperationSymbol		        operation;
non terminal Integer	                    staticNestingDepth;
non terminal Integer	                    arity;
non terminal Integer	                    kind;
non terminal Object []	                    associativityPrecedence;
non terminal TypeConstructorApplication	    type_constructorApplication;
non terminal Vector                         type_args;
non terminal Vector                         typeExpList;
non terminal TypeExpression		            typeExp;
non terminal FunctionType		            type_fun;
non terminal Vector 	                    codeBlock;
non terminal Vector 	                    instrs;
non terminal Instruction		            instr;
non terminal String                         sig_symbol_name;
non terminal Vector 	                    intArgs;
non terminal Vector 	                    codeBlocks;


/* Precedence */
precedence  right ARROW;


module                  ::= name compiled timestamp imported_symbol
                            {: RESULT = a; :}
                            ;

name                    ::= NAME UNQUAL_ID:module_name
                            {: name = module_name ; a[4] = module_name; :}
                            ;

compiled                ::= COMPILED bool
                            ;

bool                    ::= TRUE
                            {: compiled = new Boolean(true); a[2] = compiled ; :}
                            |
                            FALSE
                            {: compiled = new Boolean(false); a[2] = compiled ;  :}
                            ;

timestamp               ::= TIME INTEGER:ts
                            {: timestamp = ts; a[5] = timestamp; :}
                            ;

imported_symbol		    ::= imported_symbol imported_or_symbol
                            |
                            imported_or_symbol
                            ;

imported_or_symbol	    ::= imported:i
                            {: importedv.add(i); :}
                            |
                            symbol:s
                            {: symbolv.add(s); :}
                            ;

imported		        ::= IMPORT UNQUAL_ID:module_name
                            {: RESULT = module_name; :}
                            ;

symbol                  ::= type:t
                            {: RESULT = t; :}
                            |
                            constructor:c
                            {: RESULT = c; :}
                            |
                            operation:o
                            {: RESULT = o; :}
                            ;

type                    ::= TYPE UNQUAL_ID:tsn INTEGER:type_arity visibility:v
                            {:
                              RESULT = new TypeSymbol(name,tsn,type_arity.intValue(),v.intValue());
                            :}
                            ;

visibility              ::=
                            {: RESULT = new Integer(code.symbols.Symbol.DefaultVisibility); :}
                            |
                            PUBLIC
                            {: RESULT = new Integer(code.symbols.Symbol.Public); :}
                            |
                            PRIVATE
                            {: RESULT = new Integer(code.symbols.Symbol.Private); :}
                            ;

constructor             ::= CONSTRUCTOR
                            constructor_symbol_name:csn
                            staticNestingDepth:depth
                            arity:ari
                            kind:k
                            associativityPrecedence:ap
                            visibility:v
                            COLONCOLON typeExp:te
                            {:
                              RESULT = new ConstructorSymbol(name,csn, depth.intValue(), ari.intValue(), k.intValue(), ((Integer)ap[0]).intValue(), ((Integer)ap[1]).intValue(), v.intValue(), te);
                            :}
                            ;

operation               ::= OPERATION
                            operation_symbol_name:osn
                            staticNestingDepth:depth
                            arity:ari
                            associativityPrecedence:ap
                            visibility:v
                            COLONCOLON typeExp:te
                            codeBlock:c
                            {:
        	                    Object [] oa = c.toArray();
	                            Instruction [] ia = new Instruction[oa.length];
                                for(int i=0;i<oa.length;++i)
                                    ia[i] = (Instruction)oa[i];
                                RESULT = new OperationSymbol(name,osn, depth.intValue(), ari.intValue(), ((Integer)ap[0]).intValue(), ((Integer)ap[1]).intValue(), v.intValue(), te, ia);
                            :}
                            ;

constructor_symbol_name ::= UNQUAL_ID:id
                            {: RESULT = id; :}
                            ;

operation_symbol_name  ::= UNQUAL_ID:id
                            {: RESULT = id; :}
                            ;

staticNestingDepth      ::= INTEGER:depth
                            {: RESULT = depth; :}
                            ;

arity                   ::= INTEGER:ari
                            {: RESULT = ari; :}
                            ;

kind                    ::= INTEGER:k
                            {: RESULT = k; :}
                            ;

associativityPrecedence	 ::=
                            {: Object [] ap = { new Integer(code.symbols.DataSymbol.NonInfix), new Integer(code.symbols.DataSymbol.NonInfix) }; RESULT = ap; :}
                            |
                            LEFT INTEGER:i
                            {: Object [] ap = {new Integer(code.symbols.DataSymbol.Left), i}; RESULT = ap; :}
                            |
                            RIGHT INTEGER:i
                            {: Object [] ap = {new Integer(code.symbols.DataSymbol.Right), i}; RESULT = ap; :}
                            |
                            NONASSOC INTEGER:i
                            {: Object [] ap = {new Integer(code.symbols.DataSymbol.NonAssoc), i}; RESULT = ap; :}
			                ;


typeExp                  ::= INTEGER:varnum
                            {: RESULT = TypeFactory.makeTypeVariable(varnum.intValue()); :}
                            |
                            qualtype_name:id
                            {: RESULT = TypeFactory.makeSimpleType(id.toString()) ; :}
                            |
                            type_constructorApplication:tca
                            {: RESULT = tca; :}
                            |
                            type_fun:tf
                            {: RESULT = tf; :}
                            ;

type_constructorApplication	::= qualtype_name:id type_args:targs
                                  {:
                                    Object [] oa = targs.toArray();
                                    TypeExpression [] tea = new TypeExpression[oa.length];
                                    for(int i=0;i<oa.length;++i)
                                        tea[i] = (TypeExpression)oa[i];
                                    RESULT = TypeFactory.makeApplicationType(id.toString(), tea);
                                  :}
                                ;

qualtype_name            ::= UNQUAL_ID:mod DOT UNQUAL_ID:symb
                            {: RESULT = mod+"."+symb;
                            :}
                            ;

type_args               ::= LPAREN typeExp:te typeExpList:tel RPAREN
                            {:
                                Vector tas = new Vector() ;
                                tas.add(te) ;
                                Object [] tes = tel.toArray() ;
                                for ( int i=0;i<tes.length;++i)
                                    tas.add ( tes[i] ) ;
                                RESULT = tas ;
                            :}
                            ;

typeExpList             ::= {: RESULT = new Vector() ; :}
                            | COMMA typeExp:te typeExpList:tel
                            {:
                                Vector list = new Vector() ;
                                list.add(te);
                                Object [] a = tel.toArray() ;
                                for ( int i=0; i<a.length;++i)
                                    list.add(a[i]);
                                RESULT = list ;
                            :}
                            ;

type_fun                ::= ARROW LPAREN typeExp:te1 COMMA typeExp:te2 RPAREN
                            {: RESULT = TypeFactory.makeFunctionType(te1, te2); :}
                            ;

codeBlock               ::= LCUBRA instrs:is RCUBRA
                            {: RESULT = is; :}
                            ;

instrs                  ::=
                            {: Vector v = new Vector(); RESULT = v; :}
                            |
                            instrs:is instr:i
                            {:
                               //Debug instructions in non-debug mode will
                               //be null and should be removed from the instruction
                               //stream.  This allows us to put debug instructions
                               //into libraries and then remove them at load time
                               //when not debugging.
                               if (i != null){
                                 is.add(i);
                               }
                               RESULT = is;
                            :}
                            ;

instr                   ::= BRANCH LCUBRA codeBlocks:cbs RCUBRA
                            {:
                              Object [] oa = cbs.toArray();
                              Instruction [][] aia = new Instruction[oa.length][];
                              for(int i=0;i<oa.length;++i)
                                  aia[i] = (Instruction [])oa[i];
                              RESULT = new Branch(aia);
                            :}
                            |
                            CHOICE
                            {: RESULT = Choice.singleton; :}
                            |
                            FAIL
                            {: RESULT = Fail.singleton; :}
                            |
                            LOAD intArgs:iav
                            {:
                              Object [] oa = iav.toArray();
                              byte [] ba = new byte[oa.length];
                              for(int i=0;i<oa.length;++i) {
                                  Integer it = (Integer)oa[i];
                                  ba[i] = (byte)it.intValue();
                              }
                              RESULT = new Load(ba);
                            :}
                            |
                            MAKEREF
                            {: RESULT = MakeRef.singleton; :}
                            |
                            MAKEANON
                            {: RESULT = MakeAnon.singleton; :}
                            |
                            MAKECHAR INTEGER:i
                            {: RESULT = new MakeChar((char)(i.intValue())); :}
                            |
                            MAKEINT INTEGER:i
                            {: RESULT = new MakeInt(i.intValue()); :}
                            |
                            MAKEFLOAT FLOAT:i
                            {: RESULT = new MakeFloat(i.floatValue()); :}
                            |
                            MAKEPARTIAL INTEGER:i sig_symbol_name:id UNQUAL_ID:module_name
                            {: RESULT = new MakePartial(module_name,id, i.intValue()); :}
                            |
                            MAKETERM sig_symbol_name:id UNQUAL_ID:module_name
                            {: RESULT = new MakeTerm(module_name, id); :}
                            |
                            MAKEVAR INTEGER:i
                            {: RESULT = new MakeVar(i.intValue()); :}
                            |
                            NARROW
                            {: RESULT = Narrow.singleton; :}
			    |
                            POP
                            {: RESULT = Pop.singleton; :}
                            |
                            PUSH
                            {: RESULT = Push.singleton; :}
                            |
                            REPLACE
                            {: RESULT = Replace.singleton; :}
                            |
                            RESIDUATE
                            {: RESULT = Residuate.singleton; :}
                            |
                            STOREVAR INTEGER:i
                            {: RESULT = new StoreVar(i.intValue()); :}
                            ;

sig_symbol_name         ::= UNQUAL_ID:id
                            {: RESULT = id; :}
                            ;

intArgs                 ::= INTEGER:i
                            {: Vector iav = new Vector();
                               iav.add(i); 
                               RESULT = iav; :}
                            |
                            intArgs:iav INTEGER:i
                            {: iav.add(i); RESULT = iav; :}
                            ;

codeBlocks              ::= codeBlock:c
                            {:
                              Vector v = new Vector();
                              Object [] oa = c.toArray();
                              Instruction [] ia = new Instruction[oa.length];
                              for(int i=0;i<oa.length;++i)
                                  ia[i] = (Instruction)oa[i];
                              v.add(ia); RESULT = v;
                            :}
                            |
                            codeBlocks:cbs codeBlock:c
                            {:  
                              Object [] oa = c.toArray();
                              Instruction [] ia = new Instruction[oa.length];
                              for(int i=0;i<oa.length;++i)
                                  ia[i] = (Instruction)oa[i];
                              cbs.add(ia); RESULT = cbs; 
                            :}
                            ;