public ParsingInfo GetSymbolInfo(string name,int num)
{
ParsingInfo pi = (ParsingInfo)symbolInfo[num];
if (pi==null)
symbolInfo[num] = pi = new ParsingInfo(name,num);
return pi;
}
public static ParsingInfo MandatoryChild(this ParsingInfo info, string childName)
{
var child = info.GetChild(childName);
AssertMandatory(info, child, childName);
return(child);
}
static float SolveAddition(ParsingInfo expr)
{
if (expr.IsEmpty)
{
return(0);
}
if (expr.FirstInfo.name == "Add")
{
expr = expr.FirstInfo.AsChild;
}
float sum = 0;
foreach (var pair in expr.info)
{
if (pair.Key == "Mult")
{
sum = SolveMult(pair.Value.AsChild);
}
else if (pair.Key == "add_op")
{
sum = SolveAddOperand_Multiple(sum, pair.Value.AsChild);
}
else
{
Console.WriteLine("Add has \'" + pair.Key + "\'");
}
}
return(sum);
}
public static T MandatoryToken <T>(this ParsingInfo info, string tokenName) where T : Token
{
var token = info.GetToken(tokenName) as T;
AssertMandatory(info, token, tokenName);
return(token);
}
public ParsingInfo GetSymbolInfo(string name)
{
ParsingInfo pi = (ParsingInfo)symbolInfo[name];
if (pi==null)
symbolInfo[name] = pi = new ParsingInfo(name);
return pi;
}
static float SolveAddOperand(float sumSoFar, ParsingInfo info)
{
var opSymbolToken = info.GetToken("op") as SymbolToken;
var op = opSymbolToken.Value;
//Console.WriteLine(op);
float mult = SolveMult(info["Mult"].AsChild);
switch (op)
{
case "+":
sumSoFar += mult;
break;
case "-":
sumSoFar -= mult;
break;
}
foreach (var pair in info.info)
{
if (pair.Key == "op" || pair.Key == "Mult")
{
}
else
{
Console.WriteLine("add_op has \'" + pair.Key + "\'");
}
}
return(sumSoFar);
}
static Number CreateNumber(ParsingInfo info)
{
var number = new Number();
var signal = "";
foreach (var pair in info)
{
if (pair.Key == "value")
{
var valueToken = pair.Value.AsToken as NumberToken;
number.value = valueToken.Value;
number.type = (valueToken is FloatToken) ? Memory.Variable.Type.FLOAT : Memory.Variable.Type.INT;
}
else if (pair.Key == "signal")
{
var token = pair.Value.AsToken as SymbolToken;
signal = token.Value;
}
else
{
Console.WriteLine("Number has '" + pair.Key + "'");
}
}
if (signal == "-")
{
number.value *= -1;
}
return(number);
}
public ParsingInfo GetLiteralInfo(string spell)
{
ParsingInfo pi = (ParsingInfo)literalInfo[spell];
if (pi==null)
literalInfo[spell] = pi = new ParsingInfo(spell);
return pi;
}
static Term CreateTerm(ParsingInfo info)
{
Term term = new Number()
{
value = 1337
};
foreach (var pair in info)
{
if (pair.Key == "Number")
{
return(CreateNumber(pair.Value.AsChild));
}
else if (pair.Key == "sub_expr")
{
return(CreateSubExpr(pair.Value.AsChild));
}
else if (pair.Key == "Variable")
{
return(CreateVar(pair.Value.AsChild));
}
else
{
Console.WriteLine("Term has '" + pair.Key + "'");
}
}
return(term);
}
static Command CreateFunDecl(ParsingInfo info)
{
var funDecl = new FunDeclCmd();
var nameToken = info.MandatoryToken <IdToken>("funName");
funDecl.funName = nameToken.Value;
var parameters = info.GetChild("FunParam");
if (parameters != null)
{
var argToken = parameters.MandatoryToken <IdToken>("param0");
funDecl.parameters.Add(argToken.Value);
var otherArgs = parameters.MultipleChildren("MoreParams");
foreach (var otherArg in otherArgs)
{
funDecl.parameters.Add(otherArg.MandatoryToken <IdToken>("param").Value);
}
}
funDecl.command = CreateCommand(info.MandatoryChild("Command"));
//Console.WriteLine(funDecl);
return(funDecl);
}
static XTerm CreateXTerm(ParsingInfo info)
{
var xTerm = new XTerm()
{
value = 1
};
var signal = "";
foreach (var pair in info)
{
if (pair.Key == "Number")
{
var number = CreateNumber(pair.Value.AsChild);
xTerm.value = number.value;
}
else if (pair.Key == "signal")
{
var token = pair.Value.AsToken as SymbolToken;
signal = token.Value;
}
else if (pair.Key == "var")
{
}
else
{
Console.WriteLine("XTerm has '" + pair.Key + "'");
}
}
if (signal == "-")
{
xTerm.value *= -1;
}
return(xTerm);
}
public static float SolveNumber(ParsingInfo numberInfo)
{
float value = 0;
var numberToken = numberInfo["value"].AsToken;
if (numberToken is IntToken integer)
{
value = integer.Value;
}
else if (numberToken is FloatToken floating)
{
value = floating.Value;
}
if (numberInfo.info.ContainsKey("signal"))
{
if (numberInfo["signal"].AsToken is SymbolToken symbol)
{
if (symbol.Value == "-")
{
value *= -1;
}
}
}
return(value);
}
static Command CreateVarDeclCommand(ParsingInfo info)
{
VarDeclCmd cmd = new VarDeclCmd();
var scopeToken = info.MandatoryToken <IdToken>("scope");
switch (scopeToken.Value)
{
case "local":
cmd.scope = VarDeclCmd.Scope.LOCAL;
break;
case "global":
cmd.scope = VarDeclCmd.Scope.GLOBAL;
break;
}
var varNameToken = info.MandatoryToken <IdToken>("varName");
cmd.varName = varNameToken.Value;
var init = info.GetChild("VarInit");
if (init != null)
{
var expr = init.MandatoryChild("expr");
cmd.initializer = CreateExpression(expr);
}
return(cmd);
}
static float SolveMultOperand(float productSoFar, ParsingInfo info)
{
var opSymbolToken = info.GetToken("op") as SymbolToken;
var op = opSymbolToken.Value;
//Console.WriteLine(op);
float term = SolveTerm(info["Term"].AsChild);
switch (op)
{
case "*":
productSoFar *= term;
break;
case "/":
productSoFar *= term;
break;
}
foreach (var pair in info.info)
{
if (pair.Key == "op" || pair.Key == "Term")
{
}
else
{
Console.WriteLine("mult_op has \'" + pair.Key + "\'");
}
}
return(productSoFar);
}
static Equation CreateEquation(ParsingInfo info)
{
if (info.FirstInfo.name == "Equation")
{
return(CreateEquation(info.FirstInfo.AsChild));
}
Equation eq = new Equation();
foreach (var pair in info)
{
if (pair.Key == "Add")
{
eq.lhs = CreateAdd(pair.Value.AsChild);
}
else if (pair.Key == "Add_")
{
eq.rhs = CreateAdd(pair.Value.AsChild);
}
else if (pair.Key == "equality")
{
}
else
{
Console.WriteLine("Equation has '" + pair.Key + "'");
}
}
return(eq);
}
public static Command CreateCommand(ParsingInfo info)
{
foreach (var pair in info)
{
if (pair.Key == "ExprAttr")
{
return(CreateAttribuition(info));
}
else if (pair.Key == "Print")
{
return(CreatePrintCommand(pair.Value.AsChild));
}
else if (pair.Key == "List")
{
return(CreateListCommand(pair.Value.AsChild));
}
else if (pair.Key == "IfCmd")
{
return(CreateIfCommand(pair.Value.AsChild));
}
else if (pair.Key == "CmdBlock")
{
return(CreateCommandBlock(pair.Value.AsChild));
}
else if (pair.Key == "Read")
{
return(CreateReadCommand(pair.Value.AsChild));
}
else if (pair.Key == "Run")
{
return(CreateRunCommand(pair.Value.AsChild));
}
else if (pair.Key == "While")
{
return(CreateWhileCommand(pair.Value.AsChild));
}
else if (pair.Key == "Break")
{
return(new BreakCmd());
}
else if (pair.Key == "VarDecl")
{
return(CreateVarDeclCommand(pair.Value.AsChild));
}
else if (pair.Key == "FunDecl")
{
return(CreateFunDecl(pair.Value.AsChild));
}
else if (pair.Key == "FunCall")
{
return(CreateFunCall(pair.Value.AsChild));
}
else
{
Console.WriteLine("Command has '" + pair.Key + "'");
}
}
return(new DoNothingCmd());
}
public static void AssertMandatory(ParsingInfo info, object child, string childName)
{
if (child == null)
{
PrintContentNames(info);
throw new Exception("Missing " + childName);
}
}
static float SolveAddOperand_Multiple(float sumSoFar, ParsingInfo info)
{
foreach (var pair in info.info)
{
sumSoFar = SolveAddOperand(sumSoFar, pair.Value.AsChild);
}
return(sumSoFar);
}
static Command CreateReadCommand(ParsingInfo info)
{
ReadCmd cmd = new ReadCmd();
cmd.varName = info.MandatoryToken <IdToken>("varName").Value;
return(cmd);
}
private static Command CreateRunCommand(ParsingInfo info)
{
var cmd = new RunCmd();
cmd.fileName = info.MandatoryToken <Rules.StringToken>("fileName").Value;
return(cmd);
}
static Command CreateElse(ParsingInfo info)
{
if (info == null)
{
return(null); // is optional
}
return(CreateCommand(info.GetChild("Command")));
}
private static Command CreateWhileCommand(ParsingInfo info)
{
var cmd = new WhileCmd();
cmd.condition = CreateCondition(info.MandatoryChild("condition"));
cmd.command = CreateCommand(info.MandatoryChild("Command"));
return(cmd);
}
static ExpressionAttribuition CreateExpressionAttribuition(ParsingInfo info)
{
ExpressionAttribuition attr = new ExpressionAttribuition();
attr.varName = info.MandatoryToken <IdToken>("varName").Value;
attr.expression = CreateExpression(info.MandatoryChild("expr"));
return(attr);
}
public static Attribuition CreateAttribuition(ParsingInfo info)
{
var exprAttr = info.GetChild("ExprAttr");
if (exprAttr != null)
{
return(CreateExpressionAttribuition(exprAttr));
}
return(null);
}
static PrintCommand CreatePrintCommand(ParsingInfo info)
{
PrintCommand cmd = new PrintCommand();
var args = info.MultipleChildren("arg");
foreach (var arg in args)
{
cmd.ArgList.Add(CreateArg(arg));
}
return(cmd);
}
static IfCommand CreateIfCommand(ParsingInfo info)
{
IfCommand cmd = new IfCommand();
cmd.condition = CreateCondition(info.MandatoryChild("condition"));
cmd.command = CreateCommand(info.MandatoryChild("Command"));
cmd.elseCommand = CreateElse(info.GetChild("else"));
return(cmd);
}
internal Parser(string input, Quantifier quantifier, ParsingInfo parsingInfo)
{
if (input == null)
throw new ArgumentNullException("input");
if (quantifier == null)
throw new ArgumentNullException("quantifier");
this.input = input;
this.rootQuantifier = quantifier;
this.parsingInfo = parsingInfo;
}
static Command CreateCommandBlock(ParsingInfo info)
{
CommandBlock block = new CommandBlock();
var commands = info.MultipleChildren("Commands");
foreach (var cmd in commands)
{
block.commands.Add(CreateCommand(cmd));
//Console.WriteLine("created command " + block.commands[block.commands.Count - 1]);
}
return(block);
}
public static List <ParsingInfo> MultipleChildren(this ParsingInfo info, string childName)
{
var list = new List <ParsingInfo>();
var chldren = info.GetChild(childName);
if (chldren != null) // Multiple
{
foreach (var child in chldren)
{
list.Add(child.Value.AsChild);
}
}
return(list);
}
public static Condition CreateCondition(ParsingInfo info)
{
var condition = new Condition();
condition.expr = CreateExpression(info.GetChild("expr"));
if (condition.expr == null)
{
Console.WriteLine(info.ReduceToString(p => "condition has '" + p.Key + "'", "\n"));
throw new Exception("Condition doesn't have 'expr'");
}
condition.comparation = CreateComparation(info.GetChild("comparation"));
return(condition);
}
static Variable CreateVar(ParsingInfo info)
{
var variable = new Variable();
foreach (var pair in info)
{
if (pair.Key == "varName")
{
var token = pair.Value.AsToken as IdToken;
variable.varName = token.Value;
}
else
{
Console.WriteLine("Var has '" + pair.Key + "'");
}
}
return(variable);
}
static float SolveMult(ParsingInfo info)
{
float product = 0;
foreach (var pair in info.info)
{
if (pair.Key == "Term")
{
product = SolveTerm(pair.Value.AsChild);
}
else if (pair.Key == "mult_op")
{
product = SolveMultOperand_Multiple(product, pair.Value.AsChild);
}
else
{
Console.WriteLine("Mult has \'" + pair.Key + "\'");
}
}
//Console.WriteLine("Mult solved to " + product);
return(product);
}
static float SolveTerm(ParsingInfo info)
{
float term = 0;
foreach (var pair in info.info)
{
if (pair.Key == "Number")
{
term = SolveNumber(pair.Value.AsChild);
}
else if (pair.Key == "sub_expr")
{
term = SolveSubExpr(pair.Value.AsChild);
}
else
{
Console.WriteLine("Term has \'" + pair.Key + "\'");
}
}
//Console.WriteLine("Term solved to " + term);
return(term);
}
static MultOp CreateMultOp(ParsingInfo info)
{
MultOp op = new MultOp();
foreach (var pair in info)
{
if (pair.Key == "op")
{
var symbolToken = pair.Value.AsToken as SymbolToken;
op.operatorSymbol = symbolToken.Value;
}
else if (pair.Key == "Term")
{
op.term = CreateTerm(pair.Value.AsChild);
}
else
{
Console.WriteLine("Mult has '" + pair.Key + "'");
}
}
return(op);
}
void PrintTransition(ParsingInfo pi)
{
ParserEntry pe = (ParserEntry)pi.m_parsetable[m_state];
if (pe!=null)
{
Console.Write(" {0} {1} ", pi.m_name,pe.str);
if (pe.m_action!=null)
pe.m_action.Print();
Console.WriteLine();
}
}
void _Create()
{
ptokens tks = new ptokens(erh);
m_outname = "syntax";
tks.m_sgen = this;
m_lexer = tks;
m_symbols.erh = erh;
m_symbols.ClassInit(this);
m_outname = "syntax";
m_outFile.WriteLine("using System;using Tools;");
Production special = new Production(this,m_symbols.Special);
m_lexer.yytext = "error";
CSymbol e = (new CSymbol(this)).Resolve();
e.m_symtype = CSymbol.SymType.nonterminal;
e.m_defined=true;
// 1: INPUT
// top-down parsing of script
m_lexer.Start(m_inFile);
m_tok = (TOKEN)m_lexer.Next();
//Console.WriteLine("Token <{0}> {1}",m_tok.yytext,m_tok.GetType().Name);
while (m_tok!=null)
ParseProduction();
// that's the end of the script
if (!m_parserseen)
Error(30,0,"no parser directive detected - possibly incorrect text encoding?");
m_outFile.WriteLine(m_actions); // output the action function
m_outFile.WriteLine("} return null; }");
special.AddToRhs(m_symbols.m_startSymbol);
special.AddToRhs(m_symbols.EOFSymbol);
// 2: PROCESSING
Console.WriteLine("First");
DoFirst();
Console.WriteLine("Follow");
DoFollow();
Console.WriteLine("Parse Table");
ParseState start = new ParseState(this,null);
m_symbols.m_states[0] = start;
start.MaybeAdd(new ProdItem(special,0));
start.Closure();
start.AddEntries();
Transition tfinal = (Transition)start.m_transitions[m_symbols.m_startSymbol.yytext];
ParserShift pe = tfinal.m_next;
m_symbols.m_accept = pe.m_next;
if (m_symbols.m_accept==null)
m_symbols.erh.Error(new CSToolsFatalException(43,0,0,"","No accept state. ParserGenerator cannot continue."));
// 2A: Reduce States for the LR(0) parser
foreach (ParseState ps in m_symbols.m_states.Values)
ps.ReduceStates();
/* if (m_showParser)
{
foreach (ParseState ps in m_symbols.m_states.Values)
{
ps.Print0();
if (ps==m_symbols.m_accept)
Console.WriteLine(" EOF accept");
}
} */
// 3: Compute Look-ahead sets
if (m_lalrParser)
{
m_symbols.Transitions(new Builder(Transition.BuildDR));
/* if (m_showParser)
m_symbols.PrintTransitions(new Func(Transition.DR),"DR"); */
m_symbols.Transitions(new Builder(Transition.BuildReads));
new Digraph(this,
new Relation(Transition.reads),
new Func(Transition.DR),
new Func(Transition.Read),
new AddToFunc(Transition.AddToRead)).Compute();
// detect cycles in Read TBD
/* if (m_showParser)
m_symbols.PrintTransitions(new Func(Transition.Read),"Read"); */
m_symbols.Transitions(new Builder(Transition.BuildIncludes));
m_symbols.Transitions(new Builder(Transition.BuildLookback));
new Digraph(this,
new Relation(Transition.includes),
new Func(Transition.Read),
new Func(Transition.Follow),
new AddToFunc(Transition.AddToFollow)).Compute();
// detect cycles for which Read is non empty TBD
/* if (m_showParser)
m_symbols.PrintTransitions(new Func(Transition.Follow),"Follow"); */
m_symbols.Transitions(new Builder(Transition.BuildLA));
}
// 5: OUTPUT
// output the run-time ParsingInfo table
Console.WriteLine("Building parse table");
m_symbols.Transitions(new Builder(Transition.BuildParseTable));
foreach (CSymbol v in m_symbols.symbols.Values)
{
if (v.m_symtype!=CSymbol.SymType.nodesymbol)
continue;
ParsingInfo pi = new ParsingInfo(v.yytext);
CSymbol r = v;
while (r.m_symtype==CSymbol.SymType.nodesymbol)
r = r.m_refSymbol;
if (m_symbols.symbolInfo[v.yytext]!=null)
m_symbols.erh.Error(new CSToolsException(45,"Bad %node/%symbol hierarchy"));
pi.m_parsetable = m_symbols.GetSymbolInfo(r.yytext).m_parsetable;
m_symbols.symbolInfo[v.yytext] = pi;
}
Console.WriteLine("Writing the output file");
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public yy"+m_outname+"():base() { arr = new int[] { ");
m_symbols.Emit(m_outFile);
// output the class factories
CSymbol s;
Console.WriteLine("Class factories");
IDictionaryEnumerator de = m_symbols.symbols.GetEnumerator();
for (int pos = 0; pos<m_symbols.symbols.Count; pos++)
{
de.MoveNext();
string str = (string)de.Key;
s = (CSymbol)de.Value;
if ((s==null) // might happen because of error recovery
|| (s.m_symtype!=CSymbol.SymType.nonterminal && s.m_symtype!=CSymbol.SymType.nodesymbol))
continue;
//Console.WriteLine("{0} {1}",s.yytext,s.m_symtype);
m_outFile.WriteLine("new Sfactory(this,\"{0}\",new SCreator({0}_factory));",str);
}
m_outFile.WriteLine("}");
de.Reset();
for (int pos = 0; pos<m_symbols.symbols.Count; pos++)
{
de.MoveNext();
string str = (string)de.Key;
s = (CSymbol)de.Value;
if ((s==null) // might happen because of error recovery
|| (s.m_symtype!=CSymbol.SymType.nonterminal && s.m_symtype!=CSymbol.SymType.nodesymbol))
continue;
//Console.WriteLine("{0} {1}",s.yytext,s.m_symtype);
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public static object "+str+"_factory(Parser yyp) { return new "+str+"(yyp); }");
}
m_outFile.WriteLine("}");
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public class "+m_outname+": Parser {");
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public "+m_outname+"():base(new yy"+m_outname+"(),new "+m_lexerClass+"()) {}");
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public "+m_outname+"(Symbols syms):base(syms,new "+m_lexerClass+"()) {}");
m_outFile.WriteLine(@"/// <summary/>");
m_outFile.WriteLine("public "+m_outname+"(Symbols syms,ErrorHandler erh):base(syms,new "+m_lexerClass+"(erh)) {}");
m_outFile.WriteLine(m_actvars);
m_outFile.WriteLine(" }");
if (m_namespace)
m_outFile.WriteLine("}");
Console.WriteLine("Done");
if (m_showParser)
{
foreach (ParseState ps in m_symbols.m_states.Values)
{
ps.Print();
if (ps==m_symbols.m_accept)
Console.WriteLine(" EOF accept");
}
}
}
