public State CreateInputState(string program)
{
var result = new PythonAstNode(
new SuiteStatement(
new Statement[1] {
new ExpressionStatement(
new OrExpression(
new NameExpression("a"),
new ParenthesisExpression(
new OrExpression(
new NameExpression("a"),
new NameExpression("b")
)
)
)
)
}
), false, ModuleOptions.Initialize, false
);
var content = ASTHelper.ParseContent(program);
var astBefore = NodeWrapper.Wrap(content);
var input = State.CreateForExecution(Grammar.Value.InputSymbol, astBefore);
return(input);
}
public State CreateInputState(string program)
{
var astBefore = NodeWrapper.Wrap(ASTHelper.ParseContent(program));
var input = State.CreateForExecution(Grammar.Value.InputSymbol, astBefore);
return(input);
}
public string Visit(ForeachNode node) => ASTHelper.PrintToken(node.Token) + ASTHelper.PrintToken(node.OpenParenthesis) + ASTHelper.PrintValue(node.ItemName) + ASTHelper.PrintToken(node.InToken) + ASTHelper.PrintValue(node.CollectionRef) + ASTHelper.PrintToken(node.CloseParenthesis) + Visit(node.Body);
public string Visit(OperationNode node)
{
switch (node.OperationType)
{
// prefix stuff
case OperationType.Positive:
case OperationType.Negative:
case OperationType.Not:
case OperationType.PrefixIncrement:
case OperationType.PrefixDecrement:
return(ASTHelper.PrintToken(node.Token) + Print(node.Operands[0]));
// postfix stuff
case OperationType.PostfixIncrement:
case OperationType.PostfixDecrement:
return(Print(node.Operands[0]) + ASTHelper.PrintToken(node.Token));
// normal infix stuff
case OperationType.Addition:
case OperationType.Substraction:
case OperationType.Multiplication:
case OperationType.Division:
case OperationType.Power:
case OperationType.Modulo:
case OperationType.Or:
case OperationType.And:
case OperationType.Xor:
case OperationType.Equal:
case OperationType.NotEqual:
case OperationType.Less:
case OperationType.LessOrEqual:
case OperationType.Greater:
case OperationType.GreaterOrEqual:
case OperationType.Access:
case OperationType.Assign:
return(Print(node.Operands[0])
+ ASTHelper.PrintToken(node.Token)
+ Print(node.Operands[1]));
case OperationType.ArrayAccess:
return(Print(node.Operands[0]) // name of the array
+ ASTHelper.PrintToken(node.Token) // '['
+ Utilities.Join(",", Print, node.Operands.Skip(1)) // indices
+ ASTHelper.PrintToken(node.AdditionalTokens[0])); // ']'
case OperationType.Conditional:
return(Print(node.Operands[0])
+ ASTHelper.PrintToken(node.Token)
+ Print(node.Operands[1])
+ ASTHelper.PrintToken(node.AdditionalTokens[0])
+ Print(node.Operands[2]));
default:
throw new Exception("Oho, someone forgot to implement a printer for an operation type...");
}
}
private ExampleSpec CreateExampleSpec(List <Tuple <string, string> > examples)
{
var proseExamples = new Dictionary <State, object>();
foreach (var example in examples)
{
var input = CreateInputState(example.Item1);
var astAfter = NodeWrapper.Wrap(ASTHelper.ParseContent(example.Item2));
proseExamples.Add(input, astAfter);
}
var spec = new ExampleSpec(proseExamples);
return(spec);
}
static string printParameter(FunctionParameter param)
{
var output = "";
if (param.Type != ValueNode.NULL)
{
output += ASTHelper.PrintValue(param.Type);
}
output += ASTHelper.PrintValue(param.Name);
if (param.HasDefaultValue)
{
output += ASTHelper.PrintToken(param.EqualSign) + ASTHelper.PrintValue(param.DefaultValue);
}
return(output);
}
static Func <FileInfo, bool, Task <int> > ConstHandlerFactory(Action <Graph> act)
=> (file, force) => {
var g = MakeGraph(
file,
Enumerable.OfType <TopLevelStatementNode>, // filter
(n => ASTHelper.ShowConstants(n)), // transform
force,
out int exitCode
);
if (exitCode != 0 && !force)
{
return(Task.FromResult(exitCode));
}
act(g);
return(Task.FromResult(0));
};
static Graph MakeGraph(FileInfo file, bool force, out int exitCode)
{
var tokenizer = GetTokenizerForFile(file);
exitCode = HandleParsing(tokenizer, out var tlNodes);
var g = new Graph("AST");
if (exitCode == 0 || force)
{
AddGraphPrelude(g, file);
foreach (var node in tlNodes)
{
g.AddNode(ASTHelper.ToGraphNode(node));
}
}
return(g);
}
static Task <int> PrintHandler(FileInfo file, bool force)
{
var tokenizer = GetTokenizerForFile(file);
var exitCode = HandleParsing(tokenizer, out var tlNodes);
if (exitCode != 0 && !force)
{
return(Task.FromResult(exitCode));
}
foreach (var node in tlNodes)
{
Console.Write(ASTHelper.PrintTopLevel(node));
}
string s;
if ((s = ASTHelper.PrintToken(tokenizer.Current)).Length >= 2)
{
// print the last (EOF) token, which is not consumed by the parser
Console.WriteLine(s[..^ 2]);
public string Visit(EnumNode node)
{
var s = "";
if (node.AccessKeyword != Token.NULL)
{
s = ASTHelper.PrintToken(node.AccessKeyword);
}
s += ASTHelper.PrintToken(node.EnumToken);
if (node.Parent != ValueNode.NULL)
{
s += ASTHelper.PrintNode(node.Parent)
+ "::";
}
return(s + ASTHelper.PrintNode(node.Name)
+ ASTHelper.PrintToken(node.OpenBracket)
+ String.Join(", ", node.Values.Select(ASTHelper.PrintNode))
+ ASTHelper.PrintToken(node.CloseBracket));
}
public string Visit(BoolNode node) => ASTHelper.PrintToken(node.Token);
public string Default(ValueNode node) => ASTHelper.PrintToken(node.Token);
public string Visit(ObjectCreationNode node) => ASTHelper.PrintToken(node.Token) + Print(node.Invocation);
public string Visit(DeclarationNode node) => ASTHelper.PrintToken(node.Token) + ASTHelper.PrintToken(node.Name) + ASTHelper.PrintToken(node.EqualToken) + ASTHelper.PrintValue(node.Value);
public string Default(ValueNode node) => ASTHelper.PrintValue(node);
public string Visit(NamespaceNode node) // FIXME: Add AccMods as well => ASTHelper.PrintToken(node.Token) + ASTHelper.PrintValue(node.Name);
public string Visit(ImportNode node)
=> Visit(node.FromStatement)
+ ASTHelper.PrintToken(node.Token)
+ Utilities.Join(",", ASTHelper.PrintValue, node.Names);
public string Visit(TupleNode node)
=> ASTHelper.PrintToken(node.OpeningToken)
+ Utilities.Join(",", Print, node.Values)
+ ASTHelper.PrintToken(node.ClosingToken);
public override GraphNode Default(ValueNode node) => BaseDefault(node).SetColor(ASTHelper.IsContant(node) ? ConstantColor : NonConstantColor);
public string Visit(ElseNode node) => ASTHelper.PrintToken(node.Token) + node.BlockOrIfNode.Match(b => Visit(b), n => Print(n));
public string Visit(TopLevelStatementNode node) => ASTHelper.PrintStatement(node.Statement);
public string Visit(FromNode node) => ASTHelper.PrintToken(node.Token) + ASTHelper.PrintValue(node.OriginName);
public string Visit(UsingNode node) => ASTHelper.PrintToken(node.Token) + ASTHelper.PrintValue(node.Name);
public string Visit(FunctionDeclarationNode node)
{
var output = ASTHelper.PrintToken(node.Token) + ASTHelper.PrintToken(node.Name) + ASTHelper.PrintToken(node.OpeningParenthesis);
public string Default(TopLevelNode node) => ASTHelper.PrintToken(node.Token);
private PythonNode Parse(string code)
{
return(NodeWrapper.Wrap(ASTHelper.ParseContent(code)));
}
public string Default(StatementNode node) => ASTHelper.PrintToken(node.Token);
public override GraphNode ToGraphNode(ValueNode node) => node.Accept(this).SetColor(ASTHelper.IsContant(node) ? ConstantColor : NonConstantColor);
public string Visit(ForNode node)
=> ASTHelper.PrintToken(node.Token)
+ ASTHelper.PrintToken(node.OpeningParenthesis)
+ Utilities.Join(",", Print, node.Header)
+ ASTHelper.PrintToken(node.ClosingParenthesis)
+ Visit(node.Body);
