public static void CreateASTNodesForCmd(CommonTree ast, ASTNode cmdNode, int depth)
{
if (DetectNullNode(ast))
{
//not sure why this happens in ANTLR: some empty CommonTree nodes
//we filter them out: otherwise they just create empty
//lines in the generated C# code (with linenumber=0 which is no good either)
//No children = we are not cutting anything real from the AST tree anyway
return;
}
cmdNode.Text = ast.Text;
if (ast.Text != null)
{
bool flag = false;
if (ast.Text.Contains("¤"))
{
if (ast.Text.StartsWith("ASTMETA" + "¤")) //Handles SERIES, that is ASTGENR/ASTUPD
{
flag = true;
}
else if (ast.Text.StartsWith("ASTSHOW" + "¤"))
{
flag = true;
}
else if (ast.Text.StartsWith("ASTPRTELEMENT" + "¤"))
{
flag = true;
}
else if (ast.Text.StartsWith("ASTOLSELEMENT" + "¤"))
{
flag = true;
}
else if (ast.Text.StartsWith("ASTDECOMP" + "¤"))
{
flag = true;
}
else if (ast.Text.StartsWith("ASTLIST" + "¤"))
{
flag = true;
}
}
if (flag)
{
string[] ss = ast.Text.Split('¤');
for (int i = 0; i < ss.Length; i++)
{
ss[i] = G.ReplaceGlueNew(ss[i]);
}
cmdNode.Text = ss[0];
cmdNode.specialExpressionAndLabelInfo = ss;
}
}
if (cmdNode.Text != null)
{
if (Globals.addGlue)
{
cmdNode.Text = G.ReplaceGlueNew(cmdNode.Text);
}
}
cmdNode.Line = ast.Line;
if (ast.Children == null)
{
return;
}
int num = ast.Children.Count;
cmdNode.CreateChildren(num);
for (int i = 0; i < num; ++i)
{
CommonTree d = (CommonTree)(ast.Children[i]);
if (DetectNullNode(d))
{
continue;
}
ASTNode cmdNodeChild = new ASTNode(null); //unknown text
cmdNodeChild.Parent = cmdNode;
cmdNode.Add(cmdNodeChild);
CreateASTNodesForCmd(d, cmdNodeChild, depth + 1);
}
}
private ASTNode AssembleRecursive(IEnumerator<KeyValuePair<string, Tokens>> tokens)
{
if (!tokens.MoveNext())
throw new ParseError("Out of tokens");
KeyValuePair<string, Tokens> token = tokens.Current;
ASTNode n = new ASTNode(token);
ASTNode left, right, child, cond, actn;
switch(token.Value)
{
case Tokens.TOK_COMMENT:
break;
case Tokens.TOK_KEYWORD:
if (token.Key.Equals("ON"))
{
cond = AssembleRecursive(tokens);
if (cond.mToken.Value == Tokens.TOK_KEYWORD)
throw new ParseError("ON cond was bad: " + cond.ToString());
n.Add(cond);
actn = AssembleRecursive(tokens);
if (actn.mToken.Value != Tokens.TOK_KEYWORD || !(actn.mToken.Key.Equals("DO") || actn.mToken.Key.Equals("HIBERNATE")))
throw new ParseError("ON DO was bad: " + actn.ToString());
n.Add(actn);
break;
}
if (token.Key.Equals("IF"))
{
cond = AssembleRecursive(tokens);
if (cond.mToken.Value == Tokens.TOK_KEYWORD)
throw new ParseError("IF cond was bad: " + cond.ToString());
n.Add(cond);
actn = AssembleRecursive(tokens);
if (actn.mToken.Value != Tokens.TOK_KEYWORD || !actn.mToken.Key.Equals("THEN"))
throw new ParseError("IF THEN was bad: " + actn.ToString());
n.Add(actn);
break;
}
if (token.Key.Equals("DO"))
{
actn = AssembleRecursive(tokens);
if (actn.mToken.Value != Tokens.TOK_SEMI &&
actn.mToken.Value != Tokens.TOK_AT)
throw new ParseError("DO actn was bad: " + actn.ToString());
n.Add(actn);
break;
}
if (token.Key.Equals("THEN"))
{
actn = AssembleRecursive(tokens);
if (actn.mToken.Value != Tokens.TOK_SEMI &&
actn.mToken.Value != Tokens.TOK_AT)
throw new ParseError("THEN actn was bad: " + actn.ToString());
n.Add(actn);
break;
}
if (token.Key.Equals("HIBERNATE"))
{
cond = AssembleRecursive(tokens);
if (cond.mToken.Value == Tokens.TOK_KEYWORD ||
cond.mToken.Value == Tokens.TOK_AT ||
cond.mToken.Value == Tokens.TOK_COMMA ||
cond.mToken.Value == Tokens.TOK_SEMI)
throw new ParseError("HIBERNATE wake-up condition was bad: " + cond.ToString());
n.Add(cond);
break;
}
throw new ParseError(token.Key); // can't happen
case Tokens.TOK_LOG_OP:
case Tokens.TOK_ARITH_OP:
case Tokens.TOK_COMP_OP:
left = AssembleRecursive(tokens);
if (left.mToken.Value == Tokens.TOK_KEYWORD ||
left.mToken.Value == Tokens.TOK_AT ||
left.mToken.Value == Tokens.TOK_COMMA ||
left.mToken.Value == Tokens.TOK_SEMI)
throw new ParseError(token.Key + " left expr was bad: " + left.ToString());
n.Add(left);
right = AssembleRecursive(tokens);
if (right.mToken.Value == Tokens.TOK_KEYWORD ||
right.mToken.Value == Tokens.TOK_AT ||
right.mToken.Value == Tokens.TOK_COMMA ||
right.mToken.Value == Tokens.TOK_SEMI)
throw new ParseError(token.Key + " right expr was bad: " + right.ToString());
n.Add(right);
break;
case Tokens.TOK_UN_OP:
child = AssembleRecursive(tokens);
if (child.mToken.Value == Tokens.TOK_KEYWORD ||
child.mToken.Value == Tokens.TOK_AT ||
child.mToken.Value == Tokens.TOK_COMMA ||
child.mToken.Value == Tokens.TOK_SEMI)
throw new ParseError(token.Key + " child expr was bad: " + child.ToString());
n.Add(child);
break;
case Tokens.TOK_IDENT:
case Tokens.TOK_LITERAL:
break;
case Tokens.TOK_AT:
left = AssembleRecursive(tokens);
if (left.mToken.Value != Tokens.TOK_IDENT)
throw new ParseError(token.Key + " left expr was bad: " + left.ToString());
n.Add(left);
right = AssembleRecursive(tokens);
if (right.mToken.Value == Tokens.TOK_KEYWORD ||
right.mToken.Value == Tokens.TOK_AT ||
right.mToken.Value == Tokens.TOK_SEMI)
throw new ParseError(token.Key + " right expr was bad: " + right.ToString());
n.Add(right);
break;
case Tokens.TOK_COMMA:
left = AssembleRecursive(tokens);
if (left.mToken.Value == Tokens.TOK_KEYWORD ||
left.mToken.Value == Tokens.TOK_AT ||
left.mToken.Value == Tokens.TOK_SEMI)
throw new ParseError(token.Key + " left expr was bad: " + left.ToString());
n.Add(left);
right = AssembleRecursive(tokens);
if (right.mToken.Value == Tokens.TOK_KEYWORD ||
right.mToken.Value == Tokens.TOK_AT ||
right.mToken.Value == Tokens.TOK_SEMI ||
right.mToken.Value == Tokens.TOK_COMMA)
throw new ParseError(token.Key + " right expr was bad: " + right.ToString());
n.Add(right);
break;
case Tokens.TOK_SEMI:
left = AssembleRecursive(tokens);
if (left.mToken.Value != Tokens.TOK_IDENT &&
left.mToken.Value != Tokens.TOK_AT &&
left.mToken.Value != Tokens.TOK_SEMI)
throw new ParseError("; left expr was bad: " + left.ToString());
n.Add(left);
right = AssembleRecursive(tokens);
if (right.mToken.Value != Tokens.TOK_IDENT &&
right.mToken.Value != Tokens.TOK_AT)
throw new ParseError("; right expr was bad: " + right.ToString());
n.Add(right);
break;
default:
throw new ParseError(token.Value.ToString() + ": " + token.Key); // can't happen
}
return n;
}
