public FarmDataRoot(BlockNode.BLOCK_NAME block_name, BufferNode.BUFFER_NAME buffer_name)
{
Guid = Guid.NewGuid();
Block = new BlockNode(block_name);
Buffer = new BufferNode(buffer_name);
TempValueNode = new ValueNode();
}
public FarmDataRoot()
{
Guid = Guid.NewGuid();
Block = new BlockNode();
Buffer = new BufferNode();
TempValueNode = new ValueNode();
}
public void VisitProgram(BlockNode prog)
{
this.depth = 0;
string spaces = HandleDepth();
this.io.WriteLine($"{spaces}Program: (");
string spaces2 = IncreaseDepth();
this.io.WriteLine($"{spaces2}Statements: [");
VisitStatements(prog);
this.io.WriteLine($"{spaces2}]");
this.io.WriteLine($"{spaces})");
}
public List <BlockNode> GetGroupControlChildren(BlockNode parent)
{
var gcChildren = new List <BlockNode>();
foreach (var child in parent.Children)
{
if (child.Name.Kind.TypeName == GroupControlTemplateName)
{
gcChildren.Add(child);
}
}
return(gcChildren);
}
public override void VisitBlockNode(BlockNode bl)
{
Node parent = st.Pop();
st.Push(parent);
if (bl != null)
{
bl.Parent = parent;
}
st.Push(bl);
base.VisitBlockNode(bl);
st.Pop();
}
private Node If()
{
// IF! condition block else?
SourcePosition pos = Match(TokenType.IF).Position;
Node test = Condition();
BlockNode thenBlock = Block();
Node elseBlock = null;
if (LookAhead(1) == TokenType.ELSE)
{
elseBlock = Else();
}
return(new IfNode(pos, test, thenBlock, elseBlock));
}
public void Apply_Move45Depth1_ShouldApplyALock()
{
var field = Field.Create(0, 0, 0, @"
..........
..X......." );
var actual = BlockNode.Apply(field, 1, new ApplyParameters(new MT19937Generator())
{
Round = 45
});
FieldAssert.AreEqual(@"
..X......." , 0, 0, 0, actual);
}
private IEnumerable <ControlState> GetSubtreeStatesImpl(BlockNode node)
{
var childstates = node.Children?.SelectMany(child => GetSubtreeStatesImpl(child)) ?? Enumerable.Empty <ControlState>();
if (!_editorStateStore.TryGetControlState(node.Name.Identifier, out var state))
{
return(childstates);
}
return(childstates.Concat(new List <ControlState>()
{
state
}));
}
public override Node VisitBlock(BlockContext context)
{
_blockDepth++;
var blockNode = new BlockNode(context.Start, _blockDepth);
foreach (StatementContext x in context.statement())
{
blockNode.AddChild(Visit(x));
}
_blockDepth--;
return(blockNode);
}
private ExpressionNode Evaluate(BlockNode node, Context context)
{
ExpressionNode result = new ExpressionNode()
{
Context = context
};
foreach (var exp in node.Code)
{
result = Evaluate((dynamic)exp, context);
}
return(result);
}
private void AddComponentDefaults(BlockNode topParent, Dictionary<string, ControlTemplate> templateDefaults)
{
var type = topParent.Name.Kind.TypeName;
if (!_templateStore.TryGetTemplate(type, out var template) || !(template.IsComponentTemplate ?? false))
return;
var componentTemplate = new ControlTemplate(type, "", "");
foreach (var prop in topParent.Properties)
{
componentTemplate.InputDefaults.Add(prop.Identifier, prop.Expression.Expression);
}
templateDefaults.Add(type, componentTemplate);
}
protected virtual BlockArgumentNode ParseBlockArgument(BlockNode parent, SpecialCharacterToken colon)
{
// PARSE: <block argument> ::= ':' identifier
Token token = this.GetNextTokenxx(Preference.Default);
if (!(token is IdentifierToken))
{
this.ReportParserError(parent, SemanticErrors.MissingBlockArgument, token);
this.ResidueToken = token;
// NB: BlockArgumentNode must be able to handle null for argument name token.
return(new BlockArgumentNode(parent, colon, null));
}
return(new BlockArgumentNode(parent, colon, (IdentifierToken)token));
}
public override void VisitBlockNode(BlockNode bl)
{
if (bl == null)
{
return;
}
foreach (var st in bl.StList)
{
if (st != null)
{
st.Visit(this);
}
}
}
private void GetFuncsFromTree(BlockNode tree, ref List <FunctionDefinitionNode> funcs)
{
foreach (Node child in tree.Children)
{
if (child is FunctionDefinitionNode funcDef)
{
funcs.Add(funcDef);
}
else if (child is BlockNode block)
{
GetFuncsFromTree(block, ref funcs);
}
}
}
public override ASTN VisitBlock([NotNull] BlockContext context)
{
BlockNode node = new BlockNode(context)
{
ExprBlock = new List <ExprNode>()
};
foreach (var expr in context.expr())
{
node.ExprBlock.Add(VisitExpr(expr) as ExprNode);
}
return(node);
}
public void CanGetRequirementsFromBlockNode()
{
var node = new BlockNode();
node.Init(s_DescriptorB);
var iMayRequireNormals = node as IMayRequireNormal;
Assert.IsNotNull(iMayRequireNormals);
var neededCoordinateSpace = iMayRequireNormals.RequiresNormal(ShaderStageCapability.Fragment);
Assert.AreEqual(NeededCoordinateSpace.World, neededCoordinateSpace);
}
public void Should_throw_with_empty_blocks(BlockNode emptyBlock)
{
var model = new { X = true };
var template = SyntaxTree.Block(
SyntaxTree.Conditional(
SyntaxTreeExpression.Property(model.GetType(), "X"),
emptyBlock,
emptyBlock
));
Assert.Throws <VeilCompilerException>(() =>
{
this.ExecuteTemplate(template, model);
});
}
public override void VisitBlockNode(BlockNode bl)
{
Console.WriteLine(Tag + " VisitBlockNode");
if (bl == null)
{
return;
}
foreach (var st in bl.StList)
{
if (st != null)
{
st.Visit(this);
}
}
}
public IEnumerable <string> Transform(BlockNode item)
{
Scopes.Root.AddBlock(item.Name, item.BlockContents);
if (ShouldRender)
{
Scopes.Root.CurrentBlockName = item.Name;
Scopes.Root.CurrentBlockIndex = 0;
var containerNode = Scopes.Root.GetBlock(item.Name) ?? item.BlockContents;
foreach (var output in containerNode.Transform(this))
{
yield return(output);
}
Scopes.Root.CurrentBlockName = null;
}
}
private Node blockExpansion()
{
if (peek() is Colon)
{
Token token = expect(typeof(Colon))
;
Colon colon = (Colon)token;
BlockNode blockNode = new BlockNode();
blockNode.setLineNumber(colon.getLineNumber());
blockNode.setFileName(filename);
blockNode.getNodes().AddLast(parseExpr());
return(blockNode);
}
return(block());
}
private void AddControlStates(BlockNode root, EditorStateStore stateStore)
{
foreach (var child in root.Children)
{
AddControlStates(child, stateStore);
}
var name = root.Name.Identifier;
// If the state exists, add to merged document
if (ControlStates.TryGetValue(name, out var state))
{
stateStore.TryAddControl(state);
}
}
public override void Visit(BlockNode node)
{
PrettyPrintNewLine();
CSharpString.Append("{");
IndentationLevel++;
PrettyPrintNewLine();
foreach (StmtNode stmt in node.StmtNodes)
{
stmt.Accept(this);
}
IndentationLevel--;
PrettyPrintNewLine();
CSharpString.Append("}");
PrettyPrintNewLine();
}
public override void Visit(BlockNode node)
{
WriteIndent();
ProgramBuilder.Append('{');
NewLine();
IncreaseIndent();
foreach (var s in node.StList)
{
s.Visit(this);
}
DecreaseIndent();
WriteIndent();
ProgramBuilder.Append('}');
NewLine();
}
void refreshBlock(BlockNode block)
{
int x = (int)block.coord.x;
int y = (int)block.coord.y;
int z = (int)block.coord.z;
if (block.BlockType != 0)
{
InformationHolder holder = new InformationHolder();
holder.cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
holder.cube.transform.position = Vector3.zero;
createObjectMesh(holder, MapData [x, y, z].BlockType, MapData [x, y, z].coord);
Destroy(holder.cube.GetComponent <BoxCollider> ());
}
}
public void CanAddBlockNodeToContext()
{
GraphData graph = new GraphData();
graph.AddContexts();
var node = new BlockNode();
node.Init(s_DescriptorA);
graph.AddBlock(node, graph.fragmentContext, 0);
Assert.AreEqual(0, graph.edges.Count());
Assert.AreEqual(1, graph.GetNodes <BlockNode>().Count());
Assert.AreEqual(1, graph.fragmentContext.blocks.Count());
}
public static void Optimize(BlockNode block)
{
while (PropagateConstants(block) || RemoveUnusedVariables(block) || TransformToIncDec(block))
{
}
foreach (var child in block.GetChildren())
{
if (child is IfNode ifnode)
{
Optimize(ifnode.IfTrue);
Optimize(ifnode.IfFalse);
}
}
}
public TetrisGrid(int width, int height)
{
Width = width;
Height = height;
mAllNodes = new BlockNode[width, height];
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
mAllNodes[i, j] = new BlockNode(i, j);
}
}
}
public BlockScope CollectIdentifiers(BlockNode block)
{
DeclaringScope declaringScope = DeclaringScope.MethodLike;
if (block.Parent is ClassTypeDeclerationNode)
{
declaringScope = DeclaringScope.ClassLike;
}
ListDictionary <string, TypeInformation> scope = new ListDictionary <string, TypeInformation>();
foreach (var child in block)
{
if (child.Type == NodeType.VariableDecleration)
{
VariableDeclerationNode variableNode = (VariableDeclerationNode)child;
foreach (var decleration in variableNode.Declerations)
{
string name = decleration.Identifier.Name;
scope.Add(name,
new TypeInformation(
variableNode.DeclerationType.ActualType,
variableNode.ProtectionLevel,
decleration.Interval.a,
declaringScope));
}
}
else if (child.Type == NodeType.MethodDecleration)
{
MethodDeclerationNode methodNode = (MethodDeclerationNode)child;
string name = methodNode.Identifier.Value;
scope.Add(name,
new TypeInformation(
methodNode.MethodSignature.ActualType,
methodNode.ProtectionLevel,
methodNode.Interval.a,
declaringScope));
}
}
ConcurrentDictionary <string, TypeInformation[]> newscope = new ConcurrentDictionary <string, TypeInformation[]>(_scopeDictionary);
foreach (KeyValuePair <string, List <TypeInformation> > pair in scope)
{
newscope.TryAdd(pair.Key, pair.Value.ToArray());
}
return(new BlockScope(newscope, _classes));
}
public void BeforeWrite(BlockNode node, bool inResponsiveContext)
{
var controlName = node.Name.Identifier;
var templateName = node.Name.Kind.TypeName;
var variantName = node.Name.Kind.OptionalVariant;
var styleName = $"default{templateName.FirstCharToUpper()}Style";
HashSet <string> propNames = null;
if (_controlStore.TryGetControlState(controlName, out var controlState))
{
styleName = controlState.StyleName;
propNames = new HashSet <string>(controlState.Properties.Select(state => state.PropertyName)
.Concat(controlState.DynamicProperties?.Select(state => state.PropertyName) ?? Enumerable.Empty <string>()));
}
ControlTemplate template;
if (!_templateStore.TryGetValue(templateName, out template))
{
template = null;
}
var defaults = new DefaultRuleHelper(styleName, template, templateName, variantName, _theme, inResponsiveContext).GetDefaultRules();
foreach (var property in node.Properties)
{
defaults.Remove(property.Identifier);
}
foreach (var defaultkvp in defaults)
{
if (propNames != null && !propNames.Contains(defaultkvp.Key))
{
continue;
}
node.Properties.Add(new PropertyNode
{
Identifier = defaultkvp.Key,
Expression = new ExpressionNode
{
Expression = defaultkvp.Value
}
});
}
}
public void Visit(BlockNode node)
{
// Ignore test templates here.
// Test templates have control-like syntax, but allowed to repeat names:
// Step4 As TestStep:
if (AppTestTransform.IsTestSuite(node.Name.Kind.TypeName))
{
return;
}
this.Visit(node.Name);
foreach(var child in node.Children )
{
this.Visit(child);
}
}
public void CanCreateSlotFromCustomSlotBlockDescriptor()
{
var node = new BlockNode();
node.Init(s_CustomSlotDescriptor);
List <MaterialSlot> slots = new List <MaterialSlot>();
node.GetSlots(slots);
Assert.IsNotNull(slots);
Assert.AreEqual(1, slots.Count);
Assert.AreNotEqual(s_MaterialSlot, slots[0]); //We actually WANT to create a new slot in this case
Assert.AreEqual(s_MaterialSlot.displayName, slots[0].displayName);
Assert.AreEqual(s_MaterialSlot.valueType, slots[0].valueType);
Assert.AreEqual(s_MaterialSlot.value, ((Vector3MaterialSlot)slots[0]).value);
}
private void ParseBlock(Node subtree)
{
SymbolTable.EnterScope();
BlockNode block = new BlockNode(subtree);
while (tokens.CurrentToken != TokenType.End)
{
if (tokens.CurrentToken.Type == TokenType.EOF)
{
ErrorHandler.RaiseError(new Error(tokens.CurrentToken.LineNo, "Unexpected end of file. Maybe missing an 'End'?"));
Fail();
}
ParseStatement(block);
}
tokens.ConsumeToken(TokenType.End).ConsumeToken(TokenType.Delim);
SymbolTable.ExitScope();
}
public void GenerateCode(BlockNode node, ICIL_CodeGenerator codeGenerator)
{
node.Holder = codeGenerator.DefineVariable();
codeGenerator.AddLocalVariable(
new CIL_LocalVariable((Variable)node.Holder));
foreach (var expression in node.Expression)
{
GenerateCode(expression, codeGenerator);
}
var last = node.Expression.Last();
codeGenerator.AddInstruction(
new Assign((Variable)node.Holder, last.Holder));
}
// For global variables (accessable anywhere)
//NullableDictionnary globalVariables = new NullableDictionnary();
// For main variables (accessable anywhere but methods)
//NullableDictionnary mainVariables = new NullableDictionnary();
// This should tell the statements where they have to look up variables
//NullableDictionnary variableAccess = mainVariables;
//String output;
//public String GetOutput() {
// return output;
//}
// $ANTLR start "compilationUnit"
// C:\\Users\\Dominik Halfkann\\Documents\\Visual Studio 2010\\Projects\\SGLParserTester\\SGL\\SGLTreeWalker.g:41:1: compilationUnit : ( mainStatement )+ EOF ;
public void compilationUnit() // throws RecognitionException [1]
{
BlockNode bn = new BlockNode();
node = bn;
Scope scope = new Scope(currentScope);
currentScope = scope;
try
{
// C:\\Users\\Dominik Halfkann\\Documents\\Visual Studio 2010\\Projects\\SGLParserTester\\SGL\\SGLTreeWalker.g:51:2: ( ( mainStatement )+ EOF )
// C:\\Users\\Dominik Halfkann\\Documents\\Visual Studio 2010\\Projects\\SGLParserTester\\SGL\\SGLTreeWalker.g:51:4: ( mainStatement )+ EOF
{
// C:\\Users\\Dominik Halfkann\\Documents\\Visual Studio 2010\\Projects\\SGLParserTester\\SGL\\SGLTreeWalker.g:51:4: ( mainStatement )+
int cnt1 = 0;
do
{
int alt1 = 2;
int LA1_0 = input.LA(1);
if ( ((LA1_0 >= VARDEF && LA1_0 <= ASSIGN) || LA1_0 == 30) )
{
alt1 = 1;
}
switch (alt1)
{
case 1 :
// C:\\Users\\Dominik Halfkann\\Documents\\Visual Studio 2010\\Projects\\SGLParserTester\\SGL\\SGLTreeWalker.g:51:4: mainStatement
{
PushFollow(FOLLOW_mainStatement_in_compilationUnit70);
mainStatement();
state.followingStackPointer--;
}
break;
default:
if ( cnt1 >= 1 ) goto loop1;
EarlyExitException eee1 =
new EarlyExitException(1, input);
throw eee1;
}
cnt1++;
} while (true);
loop1:
; // Stops C# compiler whining that label 'loop1' has no statements
Match(input,EOF,FOLLOW_EOF_in_compilationUnit73);
}
currentScope = currentScope.parent();
}
catch (RecognitionException re)
{
ReportError(re);
Recover(input,re);
}
finally
{
}
return ;
}
public void PushBlock(BlockNode block)
{
stack.Push(block);
variables = new ScopedDictionary<string, ValueProviderBase>(variables);
}
void ParseInternal()
{
this.mainBlock = new BlockNode(null);
this.stack = new Stack<BlockNode>();
this.errors = new List<TemplateError>();
PushBlock(mainBlock);
var matches = TemplateUtils.KeywordsRegex.Matches(text);
if (matches.Count == 0)
{
stack.Peek().Nodes.Add(new LiteralNode { Text = text });
stack.Pop();
return;
}
int index = 0;
foreach (Match match in matches)
{
if (index < match.Index)
{
stack.Peek().Nodes.Add(new LiteralNode { Text = text.Substring(index, match.Index - index) });
}
var type = match.Groups["type"].Value;
var token = match.Groups["token"].Value;
var keyword = match.Groups["keyword"].Value;
var dec = match.Groups["dec"].Value;
switch (keyword)
{
case "":
case "raw":
var tok = TemplateUtils.TokenFormatRegex.Match(token);
if (!tok.Success)
AddError(true, "{0} has invalid format".FormatWith(token));
else
{
var t = TryParseValueProvider(type, tok.Groups["token"].Value, dec);
stack.Peek().Nodes.Add(new ValueNode(t, tok.Groups["format"].Value.DefaultText(null), isRaw: keyword.Contains("raw")));
DeclareVariable(t);
}
break;
case "declare":
{
var t = TryParseValueProvider(type, token, dec);
stack.Peek().Nodes.Add(new DeclareNode(t, this.AddError));
DeclareVariable(t);
}
break;
case "any":
{
AnyNode any;
ValueProviderBase vp;
var filter = TemplateUtils.TokenOperationValueRegex.Match(token);
if (!filter.Success)
{
vp = TryParseValueProvider(type, token, dec);
any = new AnyNode(vp);
}
else
{
vp = TryParseValueProvider(type, filter.Groups["token"].Value, dec);
var comparer = filter.Groups["comparer"].Value;
var value = filter.Groups["value"].Value;
any = new AnyNode(vp, comparer, value, this.AddError);
}
stack.Peek().Nodes.Add(any);
PushBlock(any.AnyBlock);
DeclareVariable(vp);
break;
}
case "notany":
{
var an = (AnyNode)PopBlock(typeof(AnyNode)).owner;
if (an != null)
PushBlock(an.CreateNotAny());
break;
}
case "endany":
{
PopBlock(typeof(AnyNode));
break;
}
case "foreach":
{
ValueProviderBase vp = TryParseValueProvider(type, token, dec);
var fn = new ForeachNode(vp);
stack.Peek().Nodes.Add(fn);
PushBlock(fn.Block);
vp.IsForeach = true;
DeclareVariable(vp);
break;
}
case "endforeach":
{
PopBlock(typeof(ForeachNode));
}
break;
case "if":
{
IfNode ifn;
ValueProviderBase vp;
var filter = TemplateUtils.TokenOperationValueRegex.Match(token);
if (!filter.Success)
{
vp = TryParseValueProvider(type, token, dec);
ifn = new IfNode(vp, this);
}
else
{
vp = TryParseValueProvider(type, filter.Groups["token"].Value, dec);
var comparer = filter.Groups["comparer"].Value;
var value = filter.Groups["value"].Value;
ifn = new IfNode(vp, comparer, value, this.AddError);
}
stack.Peek().Nodes.Add(ifn);
PushBlock(ifn.IfBlock);
DeclareVariable(vp);
break;
}
case "else":
{
var ifn = (IfNode)PopBlock(typeof(IfNode)).owner;
if (ifn != null)
PushBlock(ifn.CreateElse());
break;
}
case "endif":
{
PopBlock(typeof(IfNode));
break;
}
default :
AddError(true, "'{0}' is deprecated".FormatWith(keyword));
break;
}
index = match.Index + match.Length;
}
if (stack.Count != 1)
AddError(true, "Last block is not closed: {0}".FormatWith(stack.Peek()));
var lastM = matches.Cast<Match>().LastOrDefault();
if (lastM != null && lastM.Index + lastM.Length < text.Length)
stack.Peek().Nodes.Add(new LiteralNode { Text = text.Substring(lastM.Index + lastM.Length) });
stack.Pop();
}
public UserFunction(ParameterNode parameters, BlockNode body, Environment father)
{
_parameters = parameters;
_body = body;
_father = father;
}
public ForeachNode(ValueProviderBase valueProvider)
{
this.ValueProvider = valueProvider;
this.Block = new BlockNode(this);
}
public ITreeNode Program()
{
ITreeNode programNode = new ErrorNode();
switch (curTokenType)
{
case TokenType.BEGINBL:
Match(ref matchToken, TokenType.BEGINBL);
ITreeNode someStatement = Program();
BlockNode block = new BlockNode();
block.addStatement(someStatement);
while (curTokenType != TokenType.ENDBL)
{
someStatement = Program();
block.addStatement(someStatement);
}
Match(ref matchToken, TokenType.ENDBL);
programNode = block;
break;
case TokenType.LABEL:
Match(ref matchToken, TokenType.LABEL);
LabelNode labeledBlock = new LabelNode(matchToken.getValue());
ITreeNode labeledStatement;
do
{
labeledStatement = Program();
labeledBlock.addStatement(labeledStatement);
}
while (curTokenType != TokenType.EOF);
programNode = labeledBlock;
break;
case TokenType.INTDEC:
Match(ref matchToken, TokenType.INTDEC);
Match(ref matchToken, TokenType.ID);
programNode = new IdentifierDeclarationNode(IdentifierType.INT, matchToken.getValue());
Match(ref matchToken, TokenType.EOS);
break;
case TokenType.BOOLDEC:
Match(ref matchToken, TokenType.BOOLDEC);
Match(ref matchToken, TokenType.ID);
programNode = new IdentifierDeclarationNode(IdentifierType.BOOL, matchToken.getValue());
Match(ref matchToken, TokenType.EOS);
break;
case TokenType.FOR:
Match(ref matchToken, TokenType.FOR);
Match(ref matchToken, TokenType.LPAREN);
AssignmentNode init = (AssignmentNode)Program();
AssignmentNode step = (AssignmentNode)Program();
BooleanExpressionNode condition = (BooleanExpressionNode)BooleanExpression();
Match(ref matchToken, TokenType.RPAREN);
BlockNode forBody = (BlockNode)Program();
programNode = new ForNode(init, step, condition, forBody);
break;
/*case TokenType.FUN:
Match(ref matchToken, TokenType.FUN);
IdentifierNode id = (IdentifierNode)Factor();
programNode = new FunctionNode(id);
Match(ref matchToken, TokenType.EOS);
break;*/
case TokenType.GOTO:
Match(ref matchToken, TokenType.GOTO);
Match(ref matchToken, TokenType.ID);
IdentifierNode gotoLabel = new IdentifierNode(matchToken.getValue(), IdentifierType.LABEL);
programNode = new GotoNode(gotoLabel);
Match(ref matchToken, TokenType.EOS);
break;
case TokenType.ID:
Match(ref matchToken, TokenType.ID);
IdentifierNode assignId = new IdentifierNode(matchToken.getValue(), IdentifierType.UNKNOWN);
Match(ref matchToken, TokenType.ASSIGN);
BooleanExpressionNode assignValue = (BooleanExpressionNode)BooleanExpression();
programNode = new AssignmentNode(assignId, assignValue);
Match(ref matchToken, TokenType.EOS);
break;
case TokenType.IF:
Match(ref matchToken, TokenType.IF);
ITreeNode thenBranch;
ITreeNode elseBranch;
Match(ref matchToken, TokenType.LPAREN);
BooleanExpressionNode ifCondition = (BooleanExpressionNode)BooleanExpression();
Match(ref matchToken, TokenType.RPAREN);
Match(ref matchToken, TokenType.THEN);
thenBranch = (BlockNode)Program();
if (curTokenType == TokenType.ELSE)
{
Match(ref matchToken, TokenType.ELSE);
elseBranch = (BlockNode)Program();
}
else
{
elseBranch = new BlankNode();
}
programNode = new IfNode(ifCondition, thenBranch, elseBranch);
break;
/*case TokenType.LET:
Match(ref matchToken, TokenType.LET);
IdentifierNode shortId = (IdentifierNode)Factor();
Match(ref matchToken, TokenType.ASSIGN);
BooleanExpressionNode subst = (BooleanExpressionNode)BooleanExpression();
Match(ref matchToken, TokenType.IN);
BooleanExpressionNode target = (BooleanExpressionNode)BooleanExpression();
programNode = new LetNode(shortId, subst, target);
Match(ref matchToken, TokenType.EOS);
break;*/
case TokenType.PRINT:
Match(ref matchToken, TokenType.PRINT);
Match(ref matchToken, TokenType.LPAREN);
BooleanExpressionNode printArgument = (BooleanExpressionNode)BooleanExpression();
Match(ref matchToken, TokenType.RPAREN);
programNode = new PrintNode(printArgument);
Match(ref matchToken, TokenType.EOS);
break;
case TokenType.WHILE:
Match(ref matchToken, TokenType.WHILE);
Match(ref matchToken, TokenType.LPAREN);
BooleanExpressionNode whileCondition = (BooleanExpressionNode)BooleanExpression();
Match(ref matchToken, TokenType.RPAREN);
BlockNode whileBody = (BlockNode)Program();
programNode = new WhileNode(whileCondition, whileBody);
break;
case TokenType.EOF:
programNode = new BlankNode();
break;
default:
Expect(TokenType.UNKNOWN, lookAheadToken);
break;
}
return programNode;
}
internal AnyNode(ValueProviderBase valueProvider)
{
this.ValueProvider = valueProvider;
AnyBlock = new BlockNode(this);
}
public BlockNode CreateNotAny()
{
NotAnyBlock = new BlockNode(this);
return NotAnyBlock;
}
public BlockNode CreateElse()
{
ElseBlock = new BlockNode(this);
return ElseBlock;
}
internal IfNode(ValueProviderBase valueProvider, string operation, string value, Action<bool, string> addError)
{
this.ValueProvider = valueProvider;
this.Operation = FilterValueConverter.ParseOperation(operation);
this.Value = value;
ValueProvider.ValidateConditionValue(value, Operation, addError);
this.IfBlock = new BlockNode(this);
}
internal IfNode(ValueProviderBase valueProvider, TemplateWalker walker)
{
this.ValueProvider = valueProvider;
this.IfBlock = new BlockNode(this);
}
