procedure main(){
  token();
  production();
  analysis();
  utils();
  lexer();
  parser();
}

//******************
//Token
//******************

procedure token(){
  macroFile = loadmacro("tokens.txt");

  foreach token in Tokens{
	if (PackageName == ""){
		nodePackageName = "node";
		import = "analysis";
	}
	else{
		nodePackageName = PackageName + ".node";
		import = PackageName + ".analysis";
	}
	
	dir = DirName + "/node";

	file = createfile(dir, token.name + ".java");

	if(token.isConstant){
		macro(file, macroFile, "VariableTextToken", nodePackageName, import, token.name);
	}
	else{
		macro(file, macroFile, "FixedTextToken", nodePackageName, import, token.name, token.text);
	}

	close(file);
  }
}

//******************
//Production
//******************

procedure production(){
  macroFile = loadmacro("productions.txt");

  foreach production in Productions{
	if (PackageName == ""){
		nodePackageName = "node";
	}
	else{
		nodePackageName = PackageName + ".node";
	}

	dir = DirName + "/node";

	file = createfile(dir, production.name + ".java");
	macro(file, macroFile,  "Production", nodePackageName, production.name);

	macroFileAlt = loadmacro("alternatives.txt");

	foreach alternative in production.alternatives{

		fileAlt = createfile(dir, alternative.name + ".java");

		if (PackageName == ""){
			import = "analysis";
		}
		else{
			import = PackageName + ".analysis";
		}

		macro(fileAlt, macroFileAlt, "AlternativeHeader", nodePackageName, import, alternative.name, production.name);

		foreach term in alternative.terms{

			nodeName = toLowerCase(term.name, 0, 1);
			if(term.isNode){
				macro(fileAlt, macroFileAlt, "NodeElement", term.type, nodeName);
			}
			else{
				macro(fileAlt, macroFileAlt, "ListElement", term.name, nodeName);
			}
		}

		macro(fileAlt, macroFileAlt, "ConstructorHeader", alternative.name);
		macro(fileAlt, macroFileAlt, "ConstructorBodyHeader");
		macro(fileAlt, macroFileAlt, "ConstructorBodyTail");

		if(alternative.terms.count > 0){
			macro(fileAlt, macroFileAlt, "ConstructorHeader", alternative.name);

			foreach term in alternative.terms{
				if(term.hasNext){
					next = ",";
				}
				else{
					next = "";
				}

				nodeName = toLowerCase(term.name, 0, 1);
				if(term.isNode){
					macro(fileAlt, macroFileAlt, "ConstructorHeaderDeclNode", term.type, nodeName, next);
				}
				else{
					macro(fileAlt, macroFileAlt, "ConstructorHeaderDeclList", "List", nodeName, next);
				}
			}

			macro(fileAlt, macroFileAlt, "ConstructorBodyHeader");

			foreach term in alternative.terms{
				nodeName = toLowerCase(term.name, 0, 1);
				if(term.isNode){
					macro(fileAlt, macroFileAlt, "ConstructorBodyNode", term.name, nodeName);
				}
				else{
					macro(fileAlt, macroFileAlt, "ConstructorBodyList", nodeName);
				}
			}

			macro(fileAlt, macroFileAlt, "ConstructorBodyTail");
		}

		macro(fileAlt, macroFileAlt, "CloneHeader", alternative.name);

		foreach term in alternative.terms{
			if(term.hasNext){
				next = ",";
			}
			else{
				next = "";
			}

			nodeName = toLowerCase(term.name, 0, 1);
			if(term.isNode){
				macro(fileAlt, macroFileAlt, "CloneBodyNode", term.type, nodeName, next);
			}
			else{
				macro(fileAlt, macroFileAlt, "CloneBodyList", nodeName, next);
			}
		}

		macro(fileAlt, macroFileAlt, "CloneTail");
		macro(fileAlt, macroFileAlt, "Apply", alternative.name);

		foreach term in alternative.terms{
			nodeName = toLowerCase(term.name, 0, 1);
			if(term.isNode){
				macro(fileAlt, macroFileAlt, "GetSetNode", term.type, term.name, nodeName);
			}
			else{
				macro(fileAlt, macroFileAlt, "GetSetList", term.name, nodeName);
			}
		}

		macro(fileAlt, macroFileAlt, "ToStringHeader");

		foreach term in alternative.terms{
			nodeName = toLowerCase(term.name, 0, 1);
			if(term.isNode){
				macro(fileAlt, macroFileAlt, "ToStringBodyNode", nodeName);
			}
			else{
				macro(fileAlt, macroFileAlt, "ToStringBodyList", nodeName);
			}
		}

		macro(fileAlt, macroFileAlt, "ToStringTail");
		macro(fileAlt, macroFileAlt, "RemoveChildHeader");

		foreach term in alternative.terms{
			nodeName = toLowerCase(term.name, 0, 1);
			if(term.isNode){
				macro(fileAlt, macroFileAlt, "RemoveChildNode", nodeName);
			}
			else{
				macro(fileAlt, macroFileAlt, "RemoveChildList", nodeName);
			}
		}

		macro(fileAlt, macroFileAlt, "RemoveChildTail");
		macro(fileAlt, macroFileAlt, "ReplaceChildHeader");

		foreach term in alternative.terms{
			nodeName = toLowerCase(term.name, 0, 1);
			if(term.isNode){
				macro(fileAlt, macroFileAlt, "ReplaceChildNode", nodeName, term.name, term.type);
			}
			else{
				macro(fileAlt, macroFileAlt, "ReplaceChildList", nodeName);
			}
		}

		macro(fileAlt, macroFileAlt, "ReplaceChildTail");

		foreach term in alternative.terms{
			if(term.isNode){
			}
			else{
				macro(fileAlt, macroFileAlt, "Cast", term.name,  term.type, alternative.name);
			}
		}

		macro(fileAlt, macroFileAlt, "AlternativeTail");
		
		close(fileAlt);
	}
	
	close(file);
  }
}

//******************
//Analysis
//******************

procedure analysis(){
  macroFile = loadmacro("analyses.txt");

  if (PackageName == ""){
	nodePackageName = "analysis";
	import = "node";
  }
  else{
	nodePackageName = PackageName + ".analysis";
	import = PackageName + ".node";
  }

  dir = DirName + "/analysis";

  //Analysis
  file = createfile(dir, "Analysis.java");
  macro(file, macroFile,  "AnalysisHeader", nodePackageName, import);
  macro(file, macroFile,  "AnalysisStart");

  foreach alternative in Alternatives{
	macro(file, macroFile,  "AnalysisBody", alternative.name);
  }

  macro(file, macroFile,  "NewLine");

  foreach token in Tokens{
	macro(file, macroFile,  "AnalysisBody", token.name);
  }

  macro(file, macroFile,  "AnalysisTail");
  
  close(file);

  //AnalysisAdapter
  file = createfile(dir, "AnalysisAdapter.java");
  macro(file, macroFile,  "AnalysisAdapterHeader", nodePackageName, import);
  macro(file, macroFile,  "AnalysisAdapterStart");

  foreach alternative in Alternatives{
	macro(file, macroFile,  "AnalysisAdapterBody", alternative.name);
  }

  foreach token in Tokens{
	macro(file, macroFile,  "AnalysisAdapterBody", token.name);
  }

  macro(file, macroFile,  "AnalysisAdapterTail");
  
  close(file);

  //DepthFirstAdapter
  file = createfile(dir, "DepthFirstAdapter.java");
  macro(file, macroFile,  "DepthFirstAdapterHeader", nodePackageName, import, Productions.first.name);

  foreach alternative in Alternatives{
	macro(file, macroFile,  "DepthFirstAdapterInOut", alternative.name);
	macro(file, macroFile,  "DepthFirstAdapterCaseHeader", alternative.name);

	foreach term in alternative.terms{
		if(term.isNode){
			macro(file, macroFile, "DepthFirstAdapterCaseBodyNode", term.name);
		}
		else{
			macro(file, macroFile, "DepthFirstAdapterCaseBodyList", term.name, term.type);
		}
	}

	macro(file, macroFile,  "DepthFirstAdapterCaseTail", alternative.name);
  }

  macro(file, macroFile,  "DepthFirstAdapterTail");
  
  close(file);

  //ReversedDepthFirstAdapter
  file = createfile(dir, "ReversedDepthFirstAdapter.java");
  macro(file, macroFile,  "ReversedDepthFirstAdapterHeader", nodePackageName, import, Productions.first.name);

  foreach alternative in Alternatives{
	macro(file, macroFile,  "DepthFirstAdapterInOut", alternative.name);
	macro(file, macroFile,  "DepthFirstAdapterCaseHeader", alternative.name);

	foreach term in reversed alternative.terms{
		if(term.isNode){
			macro(file, macroFile, "DepthFirstAdapterCaseBodyNode", term.name);
		}
		else{
			macro(file, macroFile, "ReversedDepthFirstAdapterCaseBodyList", term.name, term.type);
		}
	}

	macro(file, macroFile,  "DepthFirstAdapterCaseTail", alternative.name);
  }

  macro(file, macroFile,  "DepthFirstAdapterTail");
  
  close(file);
}

//******************
//GenUtils
//******************

procedure utils(){
  macroFile = loadmacro("utils.txt");

  if (PackageName == ""){
	nodePackageName = "node";
	import = "analysis";
  }
  else{
	nodePackageName = PackageName + ".node";
	import = PackageName + ".analysis";
  }

  dir = DirName + "/node";

  //Start
  file = createfile(dir, "Start.java");
  firstNodeName = toLowerCase(Productions.first.name, 0, 1);
  macro(file, macroFile,  "Start", nodePackageName, import, Productions.first.name, firstNodeName);
  close(file);

  //EOF
  file = createfile(dir, "EOF.java");
  macro(file, macroFile,  "EOF", nodePackageName, import);
  close(file);

  //Node
  file = createfile(dir, "Node.java");
  macro(file, macroFile,  "Node", nodePackageName, import);
  close(file);

  //NodeCast
  file = createfile(dir, "NodeCast.java");
  macro(file, macroFile,  "NodeCast", nodePackageName);
  close(file);

  //Token
  file = createfile(dir, "Token.java");
  macro(file, macroFile,  "Token", nodePackageName);
  close(file);

  //Switch
  file = createfile(dir, "Switch.java");
  macro(file, macroFile,  "Switch", nodePackageName);
  close(file);

  //Switchable
  file = createfile(dir, "Switchable.java");
  macro(file, macroFile,  "Switchable", nodePackageName);
  close(file);

  //TypedLinkedList
  file = createfile(dir, "TypedLinkedList.java");
  macro(file, macroFile,  "TypedLinkedList", nodePackageName);
  close(file);

  //Cast
  file = createfile(dir, "Cast.java");
  macro(file, macroFile,  "Cast", nodePackageName);
  close(file);

  //NoCast
  file = createfile(dir, "NoCast.java");
  macro(file, macroFile,  "NoCast", nodePackageName);
  close(file);
}

//******************
//Lexer
//******************

procedure lexer(){
  macroFile = loadmacro("lexer.txt");

  if (PackageName == ""){
	nodePackageName = "lexer";
	import = "node";
  }
  else{
	nodePackageName = PackageName + ".lexer";
	import = PackageName + ".node";
  }
  
  dir = DirName + "/lexer";

  file = createfile(dir, "LexerException.java");
  macro(file, macroFile,  "LexerException", nodePackageName);
  close(file);

  file = createfile(dir, "Lexer.java");

  startState = "INITIAL";
  if(StateLists.count > 0){
    startState = StateLists.first.name;
  }

  macro(file, macroFile,  "LexerHeader", nodePackageName, import, startState);

  foreach token in Tokens{

    if(token.isFixed){
      macro(file, macroFile,  "LexerFixedToken", token.index, token.name);
    }
    else{
      macro(file, macroFile,  "LexerVariableToken", token.index, token.name);
    }

    if(token.transitions.count > 0){
      macro(file, macroFile,  "TokenSwitchHeader");

      foreach transition in token.transitions{
        macro(file, macroFile,  "TokenCase", transition.sourceState, transition.destinationState);
      }

      macro(file, macroFile,  "TokenSwitchTail");
    }

      macro(file, macroFile,  "LexerTokenTail");
  }

  macro(file, macroFile,  "LexerBody1");

  foreach token in Tokens{

    if(token.isFixed){
      macro(file, macroFile,  "LexerNewFixedToken", token.index, token.name);
    }
    else{
      macro(file, macroFile,  "LexerNewVariableToken", token.index, token.name);
    }
  }


  macro(file, macroFile,  "LexerBody2");
  macro(file, macroFile,  "LexerAcceptHeader");
  macro(file, macroFile,  "LexerAcceptTail");
  macro(file, macroFile,  "LexerStateHeader");

  if(StateLists.count > 0){

    foreach stateList in StateLists{
      macro(file, macroFile,  "LexerStateBody", stateList.name, stateList.index);
    }
  }
  else{
	macro(file, macroFile,  "LexerStateBody", "INITIAL", "0");
  }


  macro(file, macroFile,  "LexerStateTail");
  macro(file, macroFile,  "LexerTail");
  
  close(file);

}

//******************
//Parser
//******************

procedure parser(){
  macroFile = loadmacro("parser.txt");

  if (PackageName == ""){
	nodePackageName = "parser";
	importLexer = "lexer";
	importNode = "node";
	importAnalysis = "analysis";
  }
  else{
	nodePackageName = PackageName + ".parser";
	importLexer = PackageName + ".lexer";
	importNode = PackageName + ".node";
	importAnalysis = PackageName + ".analysis";
  }

  dir = DirName + "/parser";

  fileParser = createfile(dir, "Parser.java");
  macro(fileParser, macroFile,  "ParserHeader", nodePackageName, importLexer, importNode, importAnalysis);

  if(ActivateFilter && !GrammarHasTransformations){
  	macro(fileParser, macroFile,  "ParserNoInliningPushHeader");
	macro(fileParser, macroFile,  "ParserCommon", ", true", ", false");
  }
  else{
  	macro(fileParser, macroFile,  "ParserNoInliningPushHeader");
	macro(fileParser, macroFile,  "ParserCommon", "", "");
  }

  foreach reduce in Reduces{
  	if(ActivateFilter && !GrammarHasTransformations){
		macro(fileParser, macroFile,  "ParserNoInliningReduce", reduce.index, reduce.productionNameIndex, reduce.startsWith, reduce.productionName);
	}
	else{
		macro(fileParser, macroFile,  "ParserInliningReduce", reduce.index, reduce.productionNameIndex, reduce.productionName);
	}
  }

  macro(fileParser, macroFile,  "ParserParseTail", Productions.first.name);

  foreach reduce in Reduces{
  	macro(fileParser, macroFile,  "ParserNewHeader", reduce.index, reduce.productionName);

	foreach node in reduce.nodes{
	  //macro(fileParser, macroFile,  node.macro, node.arguments);
	  switch(node.nodeType){
	    case "inAAltTransform", "inAParams":{
	      if(node.typeNameStartsWith == "L"){
                macro(fileParser, macroFile,  "ParserListVariableDeclaration", node.position);
	      }
	      else{
	        if(node.typeNameStartsWith == ""){
                  macro(fileParser, macroFile,  "ParserNullVariableDeclaration", node.position);
	        }
	        else{
                  macro(fileParser, macroFile,  "ParserSimpleVariableDeclaration", node.typeName, node.typeNameLowerCase, node.position);
	        }
	      }
	    }

	    case "outAAltTransform":{
	      foreach term in node.terms{
                macro(fileParser, macroFile,  "ParserNewBodyListAdd", term.typeName, term.position);
	      }
              macro(fileParser, macroFile,  "ParserNewTail");
	    }

	    case "inASimpleTerm", "inASimpleListTerm":{
              macro(fileParser, macroFile,  "ParserSimpleTerm", node.typeNameLowerCase, node.position, node.type, node.elementPosition, node.positionMap);
	    }

	    case "inANewTerm", "inANewListTerm":{
              macro(fileParser, macroFile,  "ParserBraceOpening");
	    }

	    case "inAListTerm":{
              macro(fileParser, macroFile,  "ParserBraceOpening");
	      foreach term in node.terms{
                if(term.typeNameStartsWith == "L"){
                  macro(fileParser, macroFile,  "ParserListVariableDeclaration", term.position);
	        }
	        else{
	          if(term.typeNameStartsWith == ""){
                    macro(fileParser, macroFile,  "ParserNullVariableDeclaration", term.position);
	          }
	          else{
                    macro(fileParser, macroFile,  "ParserSimpleVariableDeclaration", term.typeName, term.typeNameLowerCase, term.position);
	          }
	        }
	      }
	    }

	    case "outAListTerm":{
	      foreach term in node.terms{
	        if(term.typeNameStartsWith == "L"){
                  macro(fileParser, macroFile,  "ParserTypedLinkedListAddAll", "list", term.listPosition, "list", term.position);
	        }
	        else{
                  macro(fileParser, macroFile,  "ParserTypedLinkedListAdd", "list", term.listPosition, term.typeNameLowerCase, term.position);
	        }
	      }
	      macro(fileParser, macroFile,  "ParserBraceClosing");
	    }

	    case "outANewTerm", "outANewListTerm":{
	      macro(fileParser, macroFile,  "ParserNewBodyNew", node.typeName, node.position, node.newAltName);
	      i=0;
	      foreach param in node.params{
	        if(param.paramTypeName == ""){
		  if(i == 0){
                    macro(fileParser, macroFile,  "ParserNew&ListBodyParamsNull", "null");
		  }
		  else{
	            macro(fileParser, macroFile,  "ParserNew&ListBodyParamsNull", ", null");
		  }
	        }
	        else{
		  if(i == 0){
		    macro(fileParser, macroFile,  "ParserNew&ListBodyParams", param.paramTypeName, param.paramPosition);
		  }
		  else{
		    name = ", " + param.paramTypeName;
                    macro(fileParser, macroFile,  "ParserNew&ListBodyParams", name, param.paramPosition);
		  }
	        }
		i = i + 1;
	      }
	      macro(fileParser, macroFile,  "ParserNewBodyNewTail");
	      macro(fileParser, macroFile,  "ParserBraceClosing");
	    }

	    case "caseAElem":{
	      macro(fileParser, macroFile,  "ParserNewBodyDecl", node.current);
	    }
	  }
	}
  }

  macro(fileParser, macroFile,  "ParserActionHeader");
  macro(fileParser, macroFile,  "ParserActionTail");
  macro(fileParser, macroFile,  "ParserGotoHeader");
  macro(fileParser, macroFile,  "ParserGotoTail");
  macro(fileParser, macroFile,  "ParserErrorsHeader");
  macro(fileParser, macroFile,  "ParserErrorsTail");
  macro(fileParser, macroFile,  "ParserErrorIndexHeader");
  macro(fileParser, macroFile,  "ParserErrorIndexTail");
  macro(fileParser, macroFile,  "ParserTail");

  close(fileParser);

  fileToken = createfile(dir, "TokenIndex.java");
  macro(fileToken, macroFile,  "TokenIndexHeader", nodePackageName, importNode, importAnalysis);

  i = 0;
  foreach terminal in Tokens{
    if(terminal.isTerminal){
      macro(fileToken, macroFile,  "TokenIndexBody", terminal.name, i);
      i = i + 1;
    }
  }

  macro(fileToken, macroFile,  "TokenIndexTail", i);

  close(fileToken);

  fileParserException = createfile(dir, "ParserException.java");
  macro(fileParserException, macroFile,  "ParserException", nodePackageName, importNode);
  close(fileParserException);

  fileState = createfile(dir, "State.java");
  macro(fileState, macroFile,  "State", nodePackageName);
  close(fileState);

}