language nLPD
{
   lexicon
	 {
	 	  ReservedWord tipos | variaveis
	 	  Number      [0-9]+
		  Id          [a-z]+
		  separa      \: | \, | \;
		  ignore      [\0x09\0x0A\0x0D\  ]+
	 }

attributes Hashtable   *.inTabelaTipos, *.outTableTypes;
		       
	   String      *.outProlog, IDS.inTipo;

	   int        *.inEnd, *.outEnd;

  rule nLPD {
	NLPD ::= TIPOS VARS compute {
		TIPOS.inTabelaTipos = new Hashtable();
		VARS.inTabelaTipos  = TIPOS.outTableTypes;
		
		NLPD.outTableTypes  = TIPOS.outTableTypes;
		NLPD.outProlog      = VARS.outProlog;
	   };
	}
	

rule Tipos {
        TIPOS ::= tipos TS compute {
        		TS.inTabelaTipos     = TIPOS.inTabelaTipos;
        		
        		TIPOS.outTableTypes = TS.outTableTypes;
        	};
            }

rule Ts {
        TS ::= TIPO compute {
        		TIPO.inTabelaTipos = TS.inTabelaTipos; 

        		TS.outTableTypes  = TIPO.outTableTypes;
        	}
              | TS TIPO compute {
	                TS[1].inTabelaTipos  = TS[0].inTabelaTipos;

                        TIPO.inTabelaTipos   = TS[1].outTableTypes;
                        
                        TS[0].outTableTypes = TIPO.outTableTypes;      
              };
            }

rule Tipo {
		TIPO::= #Id #Number compute {
			TIPO.outTableTypes   = addItem(TIPO.inTabelaTipos, #Id.value(), #Number.value());
		};
           }
           
           
rule Vars {
		VARS ::=  compute {
			VARS.outProlog    = "";
		}
		| variaveis VS compute {
			VS.inTabelaTipos  = VARS.inTabelaTipos;
			VS.inEnd       = 0;
			
			VARS.outProlog     = VS.outProlog;
		};
	}
	
	
rule Vs {
		VS ::= SINGLE  compute { 
	     	     	SINGLE.inEnd     = VS.inEnd;

		     	SINGLE.inTabelaTipos = VS.inTabelaTipos;

			VS.outProlog         = SINGLE.outProlog;
			VS.outEnd         = SINGLE.outEnd;
		}
	     | VS SINGLE compute {
	     	VS[1].inEnd       = VS[0].inEnd;
	     		     
     	     	SINGLE.inEnd      = VS[1].outEnd;

	     	SINGLE.inTabelaTipos = VS[0].inTabelaTipos;

	     	VS[1].inTabelaTipos  = VS[0].inTabelaTipos;

	     	VS[0].outEnd       = SINGLE.outEnd;
	     	VS[0].outProlog       = VS[1].outProlog + SINGLE.outProlog;   	
	 };
} 

rule Single {
		SINGLE ::= IDS \: #Id compute {
					IDS.inEnd        = SINGLE.inEnd;
					IDS.inTipo          = #Id.value();
					IDS.inTabelaTipos   = SINGLE.inTabelaTipos;
					
					SINGLE.outEnd    = IDS.outEnd;
					SINGLE.outProlog    = IDS.outProlog;
				};
	}
	
	

rule Ids {
		IDS ::= #Id compute {	
			IDS.outProlog    = "variavel(" + #Id.value() + "," + IDS.inTipo + "," + IDS.inEnd + ").\n";
			IDS.outEnd    = IDS.inEnd + lookupLengthType(IDS.inTabelaTipos,IDS.inTipo);		
		}
		| IDS \, #Id compute {
			IDS[1].inEnd      = IDS[0].inEnd;
			IDS[1].inTipo        = IDS[0].inTipo;
			IDS[1].inTabelaTipos = IDS[0].inTabelaTipos;		

			IDS[0].outProlog    = IDS[1].outProlog + "variavel(" + #Id.value() + "," + IDS.inTipo + "," + IDS[1].outEnd + ").\n";		
			IDS[0].outEnd    = IDS[1].outEnd + lookupLengthType(IDS.inTabelaTipos,IDS.inTipo);		
		};
	}
	
   method Print
	 {
		import java.util.*;

		public Hashtable addItem(Hashtable in, String name, String num)
		{
		   String str, aux;
		   in = (Hashtable)in.clone();
		   
		   if (in.containsKey(name))
			System.out.println("Error: type already declared!\n");
		   in.put(name,Integer.parseInt(num));
		   return in;
		}
	
		public int lookupLengthType(Hashtable in, String name)
		{
			in = (Hashtable)in.clone();
			return ((Integer)in.get(name)).intValue();
		}
	}