public void SimplifiedRepresentation_Hierarchy_CorrectString()
{
var expressionBlock = new ExpressionBlock(1);
expressionBlock.AppendNode(new Number(1));
expressionBlock.AppendOperation(new Division());
var child1 = new ExpressionBlock(2);
child1.AppendNode(new Number(2));
child1.AppendOperation(new Subtraction());
child1.AppendNode(new Number("b"));
expressionBlock.AppendNode(child1);
expressionBlock.AppendOperation(new Multiplication());
var child2 = new ExpressionBlock(3);
child2.AppendNode(new Number(3));
child2.AppendOperation(new Multiplication());
child2.AppendNode(new Number(4));
expressionBlock.AppendNode(child2);
expressionBlock.AppendOperation(new Division());
expressionBlock.AppendNode(new Number(2));
Assert.Equal("6 / (2 - b)", expressionBlock.SimplifiedRepresentation(true, true));
Assert.Equal("12 / (2 - b) / 2", expressionBlock.SimplifiedRepresentation(false, true));
}
public void GetNumericValue_MultipleNodesHierarchy_Value()
{
var parent = new ExpressionBlock(1);
parent.AppendNode(new Number(10));
parent.AppendOperation(new Division());
parent.AppendNode(new Number(5));
parent.AppendOperation(new Multiplication());
parent.AppendNode(new Number(4));
parent.AppendOperation(new Multiplication());
parent.AppendNode(new Number("a"));
var firstChild = new ExpressionBlock(2);
firstChild.AppendNode(new Number(2));
firstChild.AppendOperation(new Addition());
firstChild.AppendNode(new Number(2));
var secondChild = new ExpressionBlock(3);
secondChild.AppendNode(new Number(10));
secondChild.AppendOperation(new Division());
secondChild.AppendNode(new Number("b"));
parent.AppendOperation(new Division());
parent.AppendNode(firstChild);
parent.AppendOperation(new Multiplication());
parent.AppendNode(secondChild);
Assert.Equal(2, parent.GetNumericValue(true));
Assert.Equal(40, parent.GetNumericValue(false));
}
private static ExpressionBlock <T> CompileBlocks <T>(RuleBlock _ruleBlock)
{
//Process all expressions inside the block
List <ExpressionBase <T> > _exp_list = new List <ExpressionBase <T> >();
foreach (var _axiom in _ruleBlock.getAxioms())
{
ExpressionMaker exp_maker = new ExpressionMaker(_axiom);
ExpressionBase <T> _exp_inst = new ExpressionBase <T>(_axiom.id, exp_maker.Make);
_exp_list.Add(_exp_inst);
}
//Process all blocks inside the block
List <ExpressionBlock <T> > _block_list = new List <ExpressionBlock <T> >();
foreach (var sub_block in _ruleBlock.getBlocks())
{
_block_list.Add(CompileBlocks <T>(sub_block));
}
//TODO: FIX PARAMETER ARGUMENTS FOR THE EXPRESSION BLOCK
ExpressionBlock <T> _expblock = new ExpressionBlock <T>(_ruleBlock.getOperator(), _exp_list, _block_list);
return(_expblock);
}
public override void Emit(Emitter e)
{
var kind = (HasWin) ? ExpressionKinds.HasWin
: (Accums > 0) ? ExpressionKinds.HasFold
: (Lookup == null) ? ExpressionKinds.Closed : ExpressionKinds.Open;
e.OutSeg(ExpressionBlock.Create(Name, kind, Value.Compile(), Value.DataType, Lookup, Accums));
}
public void AppendNode_AppendNodeWithParent_Exception()
{
var parentExpressionBlock = new ExpressionBlock(0);
var child = new Number(1);
parentExpressionBlock.AppendNode(child);
Assert.Throws <InvalidOperationException>(() => parentExpressionBlock.AppendNode(child));
}
public void GetNumericValue_SingleNode_Value()
{
var parent = new ExpressionBlock(1);
parent.AppendNode(new Number(5));
Assert.Equal(5, parent.GetNumericValue(true));
Assert.Equal(5, parent.GetNumericValue(false));
}
public void ExpressionInCode(string expression, bool isImplicit)
{
ExpressionBlock expressionBlock;
if (isImplicit)
{
expressionBlock = new ExpressionBlock(
Factory.CodeTransition(),
Factory
.Code(expression)
.AsImplicitExpression(VBCodeParser.DefaultKeywords, acceptTrailingDot: true)
.Accepts(AcceptedCharacters.NonWhiteSpace)
);
}
else
{
expressionBlock = new ExpressionBlock(
Factory.CodeTransition(),
Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
Factory.Code(expression).AsExpression(),
Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
);
}
string code;
if (isImplicit)
{
code =
"If foo IsNot Nothing Then"
+ Environment.NewLine
+ " @"
+ expression
+ Environment.NewLine
+ "End If";
}
else
{
code =
"If foo IsNot Nothing Then"
+ Environment.NewLine
+ " @("
+ expression
+ ")"
+ Environment.NewLine
+ "End If";
}
ParseBlockTest(
code,
new StatementBlock(
Factory.Code("If foo IsNot Nothing Then\r\n ").AsStatement(),
expressionBlock,
Factory.Code("\r\nEnd If").AsStatement().Accepts(AcceptedCharacters.None)
)
);
}
public void AppendNode_AppendToFilled_Exception()
{
var parentExpressionBlock = new ExpressionBlock(0);
var firstChild = new Number(1);
var secondChild = new Number(2);
parentExpressionBlock.AppendNode(firstChild);
Assert.Throws <InvalidOperationException>(() => parentExpressionBlock.AppendNode(secondChild));
}
public void Init_WithValidPriority_CheckState(int priority)
{
var expressionBlock = new ExpressionBlock(priority);
Assert.Equal(priority, expressionBlock.Priority);
Assert.False(expressionBlock.IsAtomic);
Assert.False(expressionBlock.IsVariable);
Assert.False(expressionBlock.IsFilled);
Assert.Empty(expressionBlock.Nodes);
Assert.Single(expressionBlock.Operations);
}
private void RunInCodeExpressionTest(string expression, ExpressionBlock expressionBlock)
{
ParseBlockTest(@"If foo IsNot Nothing Then
@" + expression + @"
End If",
new StatementBlock(
new CodeSpan(@"If foo IsNot Nothing Then
"),
expressionBlock,
new CodeSpan(@"
End If", hidden: false, acceptedCharacters: AcceptedCharacters.None)));
}
public void AppendNode_AppendNext_AppendedAndAddedParent()
{
var parentExpressionBlock = new ExpressionBlock(0);
var childExpressionBlock = new ExpressionBlock(1);
childExpressionBlock.AppendNode(new Number("a"));
parentExpressionBlock.AppendNode(childExpressionBlock);
Assert.Single(parentExpressionBlock.Nodes);
Assert.True(childExpressionBlock == parentExpressionBlock.Nodes.ElementAt(0));
Assert.True(childExpressionBlock.Parent == parentExpressionBlock);
Assert.True(childExpressionBlock.IsVariable && parentExpressionBlock.IsVariable);
}
public void MergeChildren_SingleNode_Merge()
{
var parent = new ExpressionBlock(0);
var child = new ExpressionBlock(2);
var leaf = new Number(1);
child.AppendNode(leaf);
parent.AppendNode(child);
parent.MergeChildren();
Assert.Equal(leaf, parent.Nodes.ElementAt(0));
Assert.Equal(parent, leaf.Parent);
}
public void SimplifiedRepresentation_WithVariable_CorrectString()
{
var expressionBlock = new ExpressionBlock(1);
expressionBlock.AppendNode(new Number(1));
expressionBlock.AppendOperation(new Division());
expressionBlock.AppendNode(new Number("a"));
expressionBlock.AppendOperation(new Multiplication());
expressionBlock.AppendNode(new Number(3));
expressionBlock.AppendOperation(new Multiplication());
expressionBlock.AppendNode(new Number(4));
Assert.Equal("12 / a", expressionBlock.SimplifiedRepresentation(true, true));
Assert.Equal("12 / a", expressionBlock.SimplifiedRepresentation(false, true));
}
public void GetNumericValue_MultipleNodesVariable_Value()
{
var parent = new ExpressionBlock(1);
parent.AppendNode(new Number(10));
parent.AppendOperation(new Division());
parent.AppendNode(new Number(5));
parent.AppendOperation(new Multiplication());
parent.AppendNode(new Number(4));
parent.AppendOperation(new Multiplication());
parent.AppendNode(new Number("a"));
Assert.Equal(8, parent.GetNumericValue(true));
Assert.Equal(40, parent.GetNumericValue(false));
}
public override void Emit(Emitter e)
{
Logger.Assert(DataType.IsVariable || DataType == DataTypes.Void, DataType);
e.Out(Opcodes.LDACCBLK);
e.OutLoad(NumberValue.Create(AccumIndex));
e.OutLoad(DataType.DefaultValue());
var seed = FoldedOp.GetSeed(DataType);
var code = (FoldedOp.IsDefFunc)
? FoldedExpr.Compile(InvokeOp, CallInfo.Name, seed)
: FoldedExpr.Compile(FoldedOp, seed, CallInfo);
var eb = ExpressionBlock.Create("&i", ExpressionKinds.IsFolded, code, FoldedExpr.DataType, null, AccumIndex);
e.OutSeg(eb);
e.OutCall(Func);
}
private string PrintExpression(ExpressionBlock expression)
{
var sb = new StringBuilder();
sb.AppendLine("{");
indent += 2;
foreach (var exp in expression.Inner)
{
sb.Append(new string(' ', indent));
sb.AppendLine(PrintExpression((dynamic)exp));
}
indent -= 2;
sb.Append(new string(' ', indent));
sb.Append("}");
return(sb.ToString());
}
public void MergeChildren_SeveralNodes_NoMerge()
{
var parent = new ExpressionBlock(0);
var child = new ExpressionBlock(2);
var firstLeaf = new Number(1);
var secondLeaf = new Number(2);
child.AppendNode(firstLeaf);
child.AppendOperation(new Addition());
child.AppendNode(secondLeaf);
parent.AppendNode(child);
parent.MergeChildren();
Assert.Equal(parent, child.Parent);
Assert.Single(parent.Nodes);
}
public override void Emit(Emitter e)
{
var kind = (HasWin) ? ExpressionKinds.HasWin
: (Accums > 0) ? ExpressionKinds.HasFold
: (Lookup == null) ? ExpressionKinds.Closed : ExpressionKinds.Open;
var eb = ExpressionBlock.Create(Name, kind, Value.Compile(), DataType, Lookup, Accums);
//var eb = ExpressionBlock.Create(Name, kind, Value.Compile(), Value.DataType, Lookup, Accums);
if (AsCode)
{
e.OutLoad(CodeValue.Create(eb));
}
else
{
e.OutSeg(eb);
}
}
protected void ParseCodeBlocks()
{
MatchCollection matches = _codeRegex.Matches(_doc.Contents);
CodeBlock cb = null;
foreach (Match m in matches)
{
string s = m.Value;
Block block = null;
if (s.StartsWith("<%=") || s.StartsWith("<%:"))
{
block = new ExpressionBlock();
}
else if (s.StartsWith("<%--"))
{
block = new CommentBlock();
}
else if (s.StartsWith("<asp:ContentPlaceHolder"))
{
string id = m.Groups["id"].Value;
block = new ContentPlaceHolderBlock {
ID = id
};
}
else
{
block = new CodeBlock();
if (cb == null)
{
cb = (CodeBlock)block;
cb.IsFirst = true;
}
else
{
cb.NextCodeBlock = (CodeBlock)block;
cb = (CodeBlock)block;
}
}
block.Index = m.Index;
block.Length = m.Length;
_doc.Blocks.Add(block);
}
}
public void AppendOperation_AppendSeveral_Appended()
{
var parentExpressionBlock = new ExpressionBlock(0);
parentExpressionBlock.AppendNode(new ExpressionBlock(1));
parentExpressionBlock.AppendOperation(new Addition());
parentExpressionBlock.AppendNode(new ExpressionBlock(1));
parentExpressionBlock.AppendOperation(new Subtraction());
parentExpressionBlock.AppendNode(new ExpressionBlock(1));
parentExpressionBlock.AppendOperation(new Multiplication());
parentExpressionBlock.AppendNode(new ExpressionBlock(1));
Assert.False(parentExpressionBlock.ContainsDivision);
parentExpressionBlock.AppendOperation(new Division());
Assert.True(parentExpressionBlock.ContainsDivision);
Assert.Equal(5, parentExpressionBlock.Operations.Count());
}
public static IExpressionBlock ParseBlockWithContext(IBlockLiteral tokenBlock, IContext context)
{
var block = new ExpressionBlock();
foreach (var tokenLine in tokenBlock.Lines)
{
using (var it = tokenLine.Tokens.GetEnumerator()) {
if (it.MoveNext())
{
var done = false;
var expression = ParseLineExpression(it, context, ref done);
if (expression != null)
{
block.Expressions.Add(expression);
}
}
}
}
return(block);
}
public void AddRemoveTagHelperChunk_AddsChunkToTopLevelChunkTree()
{
// Arrange
var spanFactory = SpanFactory.CreateCsHtml();
var builder = new ChunkTreeBuilder();
var block = new ExpressionBlock();
var removeTagHelperDirective = spanFactory.MetaCode(SyntaxConstants.CSharp.RemoveTagHelperKeyword + " ");
// Act
builder.StartParentChunk<ExpressionBlockChunk>(block);
builder.AddRemoveTagHelperChunk("some text", removeTagHelperDirective);
builder.EndParentChunk();
// Assert
Assert.Equal(2, builder.Root.Children.Count);
var parentChunk = Assert.IsType<ExpressionBlockChunk>(builder.Root.Children.First());
Assert.Empty(parentChunk.Children);
var removeTagHelperChunk = Assert.IsType<RemoveTagHelperChunk>(builder.Root.Children.Last());
Assert.Equal(removeTagHelperChunk.LookupText, "some text");
}
public void AddRemoveTagHelperChunk_AddsChunkToTopLevelChunkTree()
{
// Arrange
var spanFactory = SpanFactory.CreateCsHtml();
var builder = new ChunkTreeBuilder();
var block = new ExpressionBlock();
var removeTagHelperDirective = spanFactory.MetaCode(SyntaxConstants.CSharp.RemoveTagHelperKeyword + " ");
// Act
builder.StartParentChunk <ExpressionBlockChunk>(block);
builder.AddRemoveTagHelperChunk("some text", removeTagHelperDirective);
builder.EndParentChunk();
// Assert
Assert.Equal(2, builder.Root.Children.Count);
var parentChunk = Assert.IsType <ExpressionBlockChunk>(builder.Root.Children.First());
Assert.Empty(parentChunk.Children);
var removeTagHelperChunk = Assert.IsType <RemoveTagHelperChunk>(builder.Root.Children.Last());
Assert.Equal(removeTagHelperChunk.LookupText, "some text");
}
public void AddAddTagHelperChunk_AddsChunkToTopLevelCodeTree()
{
// Arrange
var spanFactory = SpanFactory.CreateCsHtml();
var builder = new CodeTreeBuilder();
var block = new ExpressionBlock();
var addTagHelperDirective = spanFactory.MetaCode(SyntaxConstants.CSharp.AddTagHelperKeyword + " ");
// Act
builder.StartChunkBlock <ExpressionBlockChunk>(block);
builder.AddAddTagHelperChunk("some text", addTagHelperDirective);
builder.EndChunkBlock();
// Assert
Assert.Equal(2, builder.CodeTree.Chunks.Count);
var chunkBlock = Assert.IsType <ExpressionBlockChunk>(builder.CodeTree.Chunks.First());
Assert.Empty(chunkBlock.Children);
var addTagHelperChunk = Assert.IsType <AddTagHelperChunk>(builder.CodeTree.Chunks.Last());
Assert.Equal(addTagHelperChunk.LookupText, "some text");
}
public void AppendNode_AppendToSelf_Exception()
{
var expressionBlock = new ExpressionBlock(0);
Assert.Throws <InvalidOperationException>(() => expressionBlock.AppendNode(expressionBlock));
}
//public void OutSegs(IEnumerable<ExpressionBlock> eblocks) {
// foreach (var eb in eblocks)
// OutSeg(eb);
//}
public void OutSeg(ExpressionBlock eblock)
{
Out(Opcodes.LDSEG);
_pw.Write(eblock);
}
// create an expression for this info
internal ExpressionBlock Expression()
{
return(ExpressionBlock.Create(Sym.Name, Sym.DataType, Grouped, Descending));
}
// Create an expression block with a specified name (specially for fields)
internal ExpressionBlock Expression(string name, DataHeading lookup = null)
{
Logger.Assert(!(IsFolded && HasFold), name);
return(ExpressionBlock.Create(name, Kind, Code, DataType, AccumCount, lookup));
}
// Create an expression block using the symbol as name
internal ExpressionBlock Expression(DataHeading lookup = null, bool lazy = false)
{
Logger.Assert(!(IsFolded && HasFold), Name);
return(ExpressionBlock.Create(Name, Kind, Code, DataType, AccumCount, lookup ?? GetLookup(), lazy));
}
internal ExpressionBlock Expression()
{
return(Kind == ExpressionKinds.Project ? ExpressionBlock.Create(Sym.Name, Sym.Name, DataType)
: Kind == ExpressionKinds.Rename ? ExpressionBlock.Create(Sym.Name, OldSym.Name, DataType)
: ExprInfo.Expression(Sym.Name, Lookup));
}
public void AppendOperation_AppendToNotFilled_Exception()
{
var expressionBlock = new ExpressionBlock(0);
Assert.Throws <InvalidOperationException>(() => expressionBlock.AppendOperation(new Addition()));
}
