//******************
//Token
//******************
macroFile = loadmacro("tokens.txt");

foreach token in Tokens{
	if (Package.isDefined){
		nodePackageName = "node";
		import = "analysis";
	}
	else{
		nodePackageName = Package.name + ".node";
		import = Package.name + ".analysis";
	}

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

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

//******************
//Production
//******************
macroFile = loadmacro("productions.txt");

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

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

	macroFileAlt = loadmacro("alternatives.txt");

	foreach alternative in production.Alternatives{

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

		if (Package.isDefined){
			import = "analysis";
		}
		else{
			import = Package.name + ".analysis";
		}

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

		foreach term in alternative.Terms{

			if(term.isNode){
				macro(fileAlt, macroFileAlt, "NodeElement", term.type, term.Name);
			}
			else{
				macro(fileAlt, macroFileAlt, "ListElement", term.name, term.Name);
			}
		}

		macro(fileAlt, macroFileAlt, "ConstructorHeader", altermative.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 = "";
				}

				if(term.isNode){
					macro(fileAlt, macroFileAlt, "ConstructorHeaderDeclNode", term.type, term.Name, next);
				}
				else{
					macro(fileAlt, macroFileAlt, "ConstructorHeaderDeclList", "List", term.Name, next);
				}
			}

			macro(fileAlt, macroFileAlt, "ConstructorBodyHeader");

			foreach term in alternative.Terms{
				if(term.isNode){
					macro(fileAlt, macroFileAlt, "ConstructorBodyNode", term.name, term.Name);
				}
				else{
					macro(fileAlt, macroFileAlt, "ConstructorBodyList", term.Name);
				}
			}

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

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

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

			if(term.isNode){
				macro(fileAlt, macroFileAlt, "CloneBodyNode", term.type, term.Name, next);
			}
			else{
				macro(fileAlt, macroFileAlt, "CloneBodyList", term.Name, next);
			}
		}

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

		foreach term in alternative.Terms{
			if(term.isNode){
				macro(fileAlt, macroFileAlt, "GetSetNode", term.type, term.name, term.Name);
			}
			else{
				macro(fileAlt, macroFileAlt, "GetSetList", term.name, term.Name);
			}
		}

		macro(fileAlt, macroFileAlt, "ToStringHeader");

		foreach term in alternative.Terms{
			if(term.isNode){
				macro(fileAlt, macroFileAlt, "ToStringBodyNode", term.Name);
			}
			else{
				macro(fileAlt, macroFileAlt, "ToStringBodyList", term.Name);
			}
		}
		
		macro(fileAlt, macroFileAlt, "ToStringTail");
		macro(fileAlt, macroFileAlt, "RemoveChildHeader");
		
		foreach term in alternative.Terms{
			if(term.isNode){
				macro(fileAlt, macroFileAlt, "RemoveChildNode", term.Name);
			}
			else{
				macro(fileAlt, macroFileAlt, "RemoveChildList", term.Name);
			}
		}
		
		macro(fileAlt, macroFileAlt, "RemoveChildTail");
		macro(fileAlt, macroFileAlt, "ReplaceChildHeader");

		foreach term in alternative.Terms{
			if(term.isNode){
				macro(fileAlt, macroFileAlt, "ReplaceChildNode", term.Name, term.name, term.type);
			}
			else{
				macro(fileAlt, macroFileAlt, "ReplaceChildList", term.Name);
			}
		}
		
		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");
	}
}

//******************
//Analysis
//******************
macroFile = loadmacro("analyses.txt");

if (Package.isDefined){
	nodePackageName = "analysis";
	import = "node";
}
else{
	nodePackageName = Package.name + ".analysis";
	import = Package.name + ".node";
}

//Analysis
file = createfile(nodePackageName, "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");

//AnalysisAdapter
file = createfile(nodePackageName, "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");

//DepthFirstAdapter
file = createfile(nodePackageName, "DepthFirstAdapter.java");
macro(file, macroFile,  "DepthFirstAdapterHeader", nodePackageName, import, mainProduction);

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");

//ReversedDepthFirstAdapter
file = createfile(nodePackageName, "Analysis.java");
macro(file, macroFile,  "ReversedDepthFirstAdapterHeader", nodePackageName, import, mainProduction);

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, "ReversedDepthFirstAdapterCaseBodyList", term.name, term.type);
		}
	}

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

macro(file, macroFile,  "DepthFirstAdapterTail");

//******************
//GenUtils
//******************
macroFile = loadmacro("utils.txt");

if (Package.isDefined){
	nodePackageName = "node";
	import = "analysis";
}
else{
	nodePackageName = Package.name + ".node";
	import = Package.name + ".analysis";
}

//Start
file = createfile(nodePackageName, "Start.java");
macro(file, macroFile,  "Start", nodePackageName, import, mainProduction, Alts.MainProduction);

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

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

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

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

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

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

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

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

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

//******************
//Lexer
//******************
macroFile = loadmacro("lexer.txt");

if (Package.isDefined){
	nodePackageName = "lexer";
	import = "node";
}
else{
	nodePackageName = Package.name + ".lexer";
	import = Package.name + ".node";
}

file = createfile(nodePackageName, "LexerException.java");
macro(file, macroFile,  "LexerException", nodePackageName);
macro(file, macroFile,  "LexerHeader", nodePackageName, import, StartState.name);

foreach token in Tokens{
	i = 0;

	if(token.isConstant){
		macro(file, macroFile,  "LexerFixedToken", i);
		i++;
	}
	else{
		macro(file, macroFile,  "LexerVariableToken", i);
		i++;
	}

	if(token.TokenStates.exist){
		macro(file, macroFile,  "TokenSwitchHeader");

		j  = 0;
		foreach tokenState in token.Tokenstates{
			macro(file, macroFile,  "TokenCase", j, tokenState.name);
			j++;
		}

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

macro(file, macroFile,  "LexerBody1");

foreach token in Tokens{
	i = 0;

	if(token.isConstant){
		macro(file, macroFile,  "LexerNewFixedToken", i, token.name);
		i++;
	}
	else{
		macro(file, macroFile,  "LexerNewVariableToken", i, token.name);
		i++;
	}
}

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

if(StateList.isDefined){
	i = 0;

	foreach stateList in StateList{
		macro(file, macroFile,  "LexerStateBody", stateList.name, i);
		i++;
	}
}
else{
	macro(file, macroFile,  "LexerStateBody", "INITIAL", 0);
}

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