public AstFloat(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.Float);
CheckIsLeaf(node);
value = double.Parse(ToString());
}
public AstMetaDataLabel(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.MetaDataLabel);
CheckIsLeaf(node);
Trace.Assert(children.Count == 0);
}
public AstMacroTypeVar(PegAstNode node)
: base(node)
{
CheckChildCount(node, 1);
msName = node.GetChild(0).ToString();
CheckLabel(AstLabel.MacroTypeVar);
}
public AstBin(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.Bin);
CheckIsLeaf(node);
string s = ToString();
int n = 0;
int place = 1;
for (int i = s.Length; i > 0; --i)
{
if (s[i - 1] == '1')
{
n += place;
}
else
{
if (s[i - 1] != '0')
{
throw new Exception("Invalid binary number");
}
}
place *= 2;
}
value = n;
}
public AstHex(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.Hex);
CheckIsLeaf(node);
value = int.Parse(ToString(), NumberStyles.AllowHexSpecifier);
}
public AstMacroStackVar(PegAstNode node)
: base(node)
{
if (node.GetNumChildren() < 1)
{
throw new Exception("invalid macro stack variable");
}
if (node.GetNumChildren() > 2)
{
throw new Exception("invalid macro stack variable");
}
msName = node.GetChild(0).ToString();
if (node.GetNumChildren() == 2)
{
AstFxnType typeNode = new AstFxnType(node.GetChild(1));
mType = CatFxnType.Create(typeNode) as CatFxnType;
if (mType == null)
{
throw new Exception("expected function type " + typeNode.ToString());
}
}
CheckLabel(AstLabel.MacroStackVar);
}
public AstInt(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.Int);
CheckIsLeaf(node);
value = int.Parse(ToString());
}
public AstLambda(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.Lambda);
CheckChildCount(node, 2);
AstParam name = new AstParam(node.GetChild(0));
mIdentifiers.Add(name.ToString());
CatAstNode tmp = Create(node.GetChild(1));
// lambda nodes either contain quotes or other lambda nodes
if (!(tmp is AstQuote))
{
if (!(tmp is AstLambda))
{
throw new Exception("expected lambda expression or quotation");
}
AstLambda lambda = tmp as AstLambda;
mIdentifiers.AddRange(lambda.mIdentifiers);
// Take ownership of the terms from the child lambda expression
mTerms = lambda.mTerms;
}
else
{
AstQuote q = tmp as AstQuote;
// Take ownership of the terms from the quote
mTerms = q.mTerms;
}
}
public void CheckChildCount(PegAstNode node, int n)
{
if (node.GetNumChildren() != n)
{
throw new Exception("expected " + n.ToString() + " children, instead found " + node.GetNumChildren().ToString());
}
}
public AstMacro(PegAstNode node)
: base(node)
{
CheckChildCount(node, 2);
CheckLabel(AstLabel.MacroRule);
mSrc = new AstMacroPattern(node.GetChild(0));
mDest = new AstMacroPattern(node.GetChild(1));
}
public AstRoot(PegAstNode node)
: base(node)
{
foreach (PegAstNode child in node.GetChildren())
{
Defs.Add(new AstDef(child));
}
}
public RubyScript(PegAstNode node)
: base(node)
{
foreach (PegAstNode child in node.GetChildren())
{
RubyAstNode statement = RubyAstNode.Create(child);
mStatements.Add(statement);
}
}
public AstFxnType(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.FxnType);
CheckChildCount(node, 3);
mCons = new AstStack(node.GetChild(0));
mbSideEffects = node.GetChild(1).ToString().Equals("~>");
mProd = new AstStack(node.GetChild(2));
}
public AstString(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.String);
CheckIsLeaf(node);
// strip quotes
string s = ToString();
value = s.Substring(1, s.Length - 2);
}
public AstMetaData(PegAstNode node)
: base(node)
{
foreach (PegAstNode child in node.GetChildren())
{
AstMetaData x = Create(child) as AstMetaData;
if (x == null)
{
throw new Exception("Meta data-nodes can only have meta-data nodes as children");
}
children.Add(x);
}
}
public CatAstNode(PegAstNode node)
{
if (node.GetLabel() != null)
{
mLabel = (AstLabel)node.GetLabel();
}
else
{
mLabel = AstLabel.AstRoot;
}
msText = node.ToString();
}
public RubyAstNode(PegAstNode node)
{
if (node.GetLabel() != null)
{
mLabel = (ASTNodeType)node.GetLabel();
}
else
{
mLabel = ASTNodeType.SELF;
}
mText = node.ToString();
}
public AstMacroQuote(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.MacroQuote);
foreach (PegAstNode child in node.GetChildren())
{
AstMacroTerm term = Create(child) as AstMacroTerm;
if (term == null)
{
throw new Exception("internal grammar error: macro quotations can only contain macro terms");
}
mTerms.Add(term);
}
}
public AstStack(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.Stack);
foreach (PegAstNode child in node.GetChildren())
{
CatAstNode tmp = Create(child);
if (!(tmp is AstType))
{
throw new Exception("stack AST node should only have type AST nodes as children");
}
mTypes.Add(tmp as AstType);
}
}
public AstQuote(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.Quote);
foreach (PegAstNode child in node.GetChildren())
{
CatAstNode tmp = CatAstNode.Create(child);
if (!(tmp is AstExpr))
{
throw new Exception("invalid child node " + child.ToString() + ", expected an expression node");
}
mTerms.Add(tmp as AstExpr);
}
}
public AstMacroPattern(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.MacroPattern);
foreach (PegAstNode child in node.GetChildren())
{
AstMacroTerm tmp = CatAstNode.Create(child) as AstMacroTerm;
if (tmp == null)
{
throw new Exception("invalid grammar: only macro terms can be children of an ast macro mPattern");
}
mPattern.Add(tmp);
}
}
public AstChar(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.Char);
CheckIsLeaf(node);
string s = ToString();
s = s.Substring(1, s.Length - 2);
switch (s)
{
case "\\t": value = '\t'; break;
case "\\n": value = '\n'; break;
case "\\'": value = '\''; break;
case "\\\"": value = '\"'; break;
case "\\r": value = '\r'; break;
default: value = char.Parse(s); break;
}
}
public AstMacroName(PegAstNode node)
: base(node)
{
CheckChildCount(node, 0);
CheckLabel(AstLabel.MacroName);
}
public AstMacroTerm(PegAstNode node)
: base(node)
{
}
public AstMacroProperty(PegAstNode node)
: base(node)
{
}
public AstType(PegAstNode node)
: base(node)
{
}
public AstMetaDataContent(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.MetaDataContent);
}
public AstSimpleType(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.TypeName);
CheckChildCount(node, 0);
}
public AstMetaDataBlock(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.MetaDataBlock);
}
public AstStackVar(PegAstNode node)
: base(node)
{
CheckLabel(AstLabel.StackVar);
CheckChildCount(node, 0);
}
