private List <INode> GetNodes(List <int> numbers)
{
if (numbers.Count == 1)
{
return(new List <INode>()
{
new IntegerNode(numbers.First())
});
}
else
{
List <INode> results = new List <INode>();
int first = numbers.First();
INode left = new IntegerNode(first);
List <int> theRest = numbers.Skip(1).ToList();
List <INode> backNodes = GetNodes(theRest);
foreach (INode node in backNodes)
{
foreach (Operator o in Enum.GetValues(typeof(Operator)))
{
INode n = ConditionallyCreateCalculationNode(left, node, o);
if (n != null)
{
results.Add(n);
}
}
}
return(results);
}
}
public void GenerateCode(IntegerNode node, ICIL_CodeGenerator codeGenerator)
{
#region .CODE
var value = codeGenerator.DefineVariable();
codeGenerator.AddLocalVariable(
new CIL_LocalVariable(value));
codeGenerator.AddInstruction(
new Assign(value, node.Value));
//IntObj
node.Holder = codeGenerator.DefineVariable();
codeGenerator.AddLocalVariable(
new CIL_LocalVariable((Variable)node.Holder));
codeGenerator.AddInstruction(
new Allocate((Variable)node.Holder, $"{BuiltIn.Int}"));
codeGenerator.AddInstruction(
new SetAttr((Variable)node.Holder,
"Int_value",
value));
#endregion
}
public void TestIntegerNodes(int number)
{
INode node = new IntegerNode(number);
Assert.Equal(1, node.Complexity);
Assert.Equal(number, node.Value);
}
public void CheckSemantic(IntegerNode node, IScope scope = null)
{
if (TypeTable.IsDefinedType("Int", out var type))
{
node.ComputedType = type;
}
}
public FlirProperties(string spinnakerLibraryVersion, IManagedCamera camera)
{
SpinnakerLibraryVersion = spinnakerLibraryVersion;
PixelFormat = new EnumNode <PixelFormatEnums>(camera, nameof(camera.PixelFormat));
AcquisitionMode = new EnumNode <AcquisitionModeEnums>(camera, nameof(camera.AcquisitionMode));
TestPattern = new EnumNode <TestPatternEnums>(camera, nameof(camera.TestPattern));
TestPatternGeneratorSelector = new EnumNode <TestPatternGeneratorSelectorEnums>(camera, nameof(camera.TestPatternGeneratorSelector));
GainSelector = new EnumNode <GainSelectorEnums>(camera, nameof(camera.GainSelector));
GainAuto = new EnumNode <GainAutoEnums>(camera, nameof(camera.GainAuto));
AutoGainUpperLimit = new FloatNode(camera, "AutoGainUpperLimit"); //todo nameof
AutoGainLowerLimit = new FloatNode(camera, "AutoGainLowerLimit"); //todo nameof
Gain = new FloatNode(camera, nameof(camera.Gain));
ExposureMode = new EnumNode <ExposureModeEnums>(camera, nameof(camera.ExposureMode));
ExposureAuto = new EnumNode <ExposureAutoEnums>(camera, nameof(camera.ExposureAuto));
ExposureAutoUpperLimit = new FloatNode(camera, nameof(camera.AutoExposureExposureTimeUpperLimit));
ExposureAutoLowerLimit = new FloatNode(camera, nameof(camera.AutoExposureExposureTimeLowerLimit));
ExposureTime = new FloatNode(camera, nameof(camera.ExposureTime));
ExposureTimeAbs = new FloatNode(camera, "ExposureTimeAbs"); //todo abs
DeviceVendorName = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceVendorName));
DeviceModelName = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceModelName));
DeviceVersion = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceVersion));
DeviceSerialNumber = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceSerialNumber));
DeviceID = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceID));
DeviceUserID = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceUserID));
DeviceGenCpVersionMajor = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceGenCPVersionMajor));
DeviceGenCPVersionMinor = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceGenCPVersionMinor));
DeviceFamilyName = new Flir.Nodes.StringNode(camera, nameof(camera.DeviceFamilyName));
DeviceTemperatureSelector = new EnumNode <DeviceTemperatureSelectorEnums>(camera, nameof(camera.DeviceTemperatureSelector));
DeviceTemperature = new FloatNode(camera, nameof(camera.DeviceTemperature));
Width = new IntegerNode(camera, nameof(camera.Width));
Height = new IntegerNode(camera, nameof(camera.Height));
FPS = new FloatNode(camera, nameof(camera.AcquisitionFrameRate));
}
/// <summary>
/// Converts a field choice to a node.
/// If field is variable, instead of creating a new node, returns an existing
/// </summary>
/// <param name="field"></param>
/// <param name="rootNode"></param>
/// <returns></returns>
protected IntegerNode FieldToNode(FieldChoice field, RootNode rootNode)
{
HighlightableButton highlightableButton = (GameObjectHelper.HasComponent <HighlightableButton>(this.gameObject)) ? this.GetComponent <HighlightableButton>() : null;
IntegerNode fieldNode = null;
// If it is a variable, the variable has already been created
// so we are going to search for it
if (field.isVariable)
{
// When it is a variable, value will have its name
ICodeNode variable = rootNode.SearchChildByName(field.value);
if (variable != null && GameObjectHelper.CanBeCastedAs <IntegerNode>(variable))
{
fieldNode = (IntegerNode)variable;
}
else
{
throw new System.Exception("Expected " + field.value + " to be an integer node");
}
}
// User has input a numeric value
else
{
int value = int.Parse(field.value);
fieldNode = new IntegerNode(null, value);
}
return(fieldNode);
}
private Node SumExpression()
{
// term ((PLUS^|MINUS^) term)*
Node termExpression = Term();
TokenType next = LookAhead(1);
if (LookAhead(2) != TokenType.STRING_LITERAL)
{
while (next == TokenType.PLUS ||
next == TokenType.PLUS_PLUS ||
next == TokenType.PLUS_ASSIGN ||
next == TokenType.MINUS ||
next == TokenType.MINUS_MINUS ||
next == TokenType.MINUS_ASSIGN)
{
if (next == TokenType.PLUS)
{
termExpression = new AddOpNode(Match(TokenType.PLUS).Position, termExpression, Term());
}
else if (next == TokenType.PLUS_PLUS)
{
Node increment = new IntegerNode(Match(TokenType.PLUS_PLUS).Position, 1);
Node addNode = new AddOpNode(increment.Position, termExpression, increment);
termExpression = new AssignNode(termExpression.Position, termExpression, addNode, false);
}
else if (next == TokenType.PLUS_ASSIGN)
{
Token plusAssign = Match(TokenType.PLUS_ASSIGN);
Node increment = Expression();
Node addNode = new AddOpNode(plusAssign.Position, termExpression, increment);
termExpression =
new AssignNode(termExpression.Position, termExpression, addNode, false);
}
else if (next == TokenType.MINUS)
{
termExpression =
new SubtractOpNode(Match(TokenType.MINUS).Position, termExpression, Term());
}
else if (next == TokenType.MINUS_MINUS)
{
Node deincrement = new IntegerNode(Match(TokenType.MINUS_MINUS).Position, 1);
Node subtractNode = new SubtractOpNode(deincrement.Position, termExpression, deincrement);
termExpression =
new AssignNode(termExpression.Position, termExpression, subtractNode, false);
}
else if (next == TokenType.MINUS_ASSIGN)
{
Token minusAssign = Match(TokenType.MINUS_ASSIGN);
Node deincrement = Expression();
Node subtractNode = new SubtractOpNode(minusAssign.Position, termExpression, deincrement);
termExpression =
new AssignNode(termExpression.Position, termExpression, subtractNode, false);
}
next = LookAhead(1);
}
}
return(termExpression);
}
public IntegerNode Integer(string value)
{
IntegerNode integerNode = new IntegerNode();
Match(TokenType.INTEGER);
integerNode.Value = int.Parse(value);
return(integerNode);
}
public void Deserialize_Int_Test(int source)
{
var node = new IntegerNode(source);
var res = _deserializer.Deserialize <int>(node);
Assert.That(res, Is.TypeOf <int>());
Assert.AreEqual(source, res);
}
public void Deserialize_Long_Test(long source)
{
var node = new IntegerNode(source);
var res = _deserializer.Deserialize <long>(node);
Assert.That(res, Is.TypeOf <long>());
Assert.AreEqual(source, res);
}
public void AST_CreateInteger_Succeeds(int value)
{
var node = new IntegerNode(value);
var expectedFloat = (float)value;
var expectedBool = value != 0;
Assert.Equal(ValueType.Integer, node.ValueType);
Assert.Equal(value, node.IntegerValue);
Assert.True(Math.IsNearlyEqual(expectedFloat, node.FloatValue));
Assert.Equal(expectedBool, node.BooleanValue);
}
public void AST_BuildInteger_Overflows()
{
Assert.Throws <OverflowException>(() =>
{
var node = new IntegerNode();
var rpn = new Stack <Node>();
node.Build(rpn, new Element(new Token("2147483648", TokenType.Integer), ElementType.Integer),
Compiler.Options.None, null,
null);
});
}
public IntegerNode getElement(int pos)
{
int c = 0;
IntegerNode node = head;
while (c != pos)
{
c++;
node = node.NextNode;
}
return(node);
}
public String ToString()
{
String list = "";
IntegerNode node = head;
while (node != null)
{
list += "-" + node.Value;
node = node.NextNode;
}
return(list);
}
public ArithmeticOperationNode CreateNode(RootNode rootNode)
{
HighlightableButton highlightableButton = (GameObjectHelper.HasComponent <HighlightableButton>(this.gameObject)) ? this.GetComponent <HighlightableButton>() : null;
IntegerNode field1 = GetField1Node(rootNode);
IntegerNode field2 = GetField2Node(rootNode);
// Converts the arithmetic operator choosen to the proper enum
ArithmeticOperationNode.ArithmeticOperation operation = GetOperation(GetOperator());
ArithmeticOperationNode arithOpNode = new ArithmeticOperationNode(highlightableButton, field1, field2, operation);
return(arithOpNode);
}
public void AST_BuildInteger_Succeeds(Element element, ValueType expectedNodeType, int expectedInt,
float expectedFloat, bool expectedBool)
{
var node = new IntegerNode();
var rpn = new Stack <Node>();
node.Build(rpn, element, Compiler.Options.None, null,
null);
Assert.Equal(expectedNodeType, node.ValueType);
Assert.Equal(expectedInt, node.IntegerValue);
Assert.True(Math.IsNearlyEqual(expectedFloat, node.FloatValue));
Assert.Equal(expectedBool, node.BooleanValue);
}
public void Add(int value)
{
if (head == null)
{
head = new IntegerNode(value);
System.Diagnostics.Trace.WriteLine("The node " + head.Value + " has been succesfully added to our linked list");
}
else
{
getElement(NumberOfElements - 1).NextNode = new IntegerNode(value);
System.Diagnostics.Trace.WriteLine("The node " + getElement(NumberOfElements - 1).NextNode.Value + " has been succesfully added to our linked list");
}
NumberOfElements++;
}
public void ToNodes(ICodeNode parentNode)
{
HighlightableButton highlightableButton = (GameObjectHelper.HasComponent <HighlightableButton>(this.gameObject)) ? this.GetComponent <HighlightableButton>() : null;
//Creates an integer node for the counter
//This won't correspond to an integer blox.
IntegerNode counter = new IntegerNode(null, int.Parse(GetValue()));
counter.NodeName = this.GetName();
//Adds it to parent
parentNode.AddChildNode(counter);
//Creates the for node
ForNode forNode = new ForNode(highlightableButton, counter, int.Parse(FromField.text), int.Parse(ToField.text));
parentNode.AddChildNode(forNode);
//This node has child nodes. Ensures that child nodes are created from child bloxes
CompileChildrenToNodes(forNode);
}
public void ToNodes(ICodeNode parentNode)
{
RootNode rootNode = parentNode.GetRootNode();
HighlightableButton highlightableButton = (GameObjectHelper.HasComponent <HighlightableButton>(this.gameObject)) ? this.GetComponent <HighlightableButton>() : null;
//Checks if this blox has a param if it has creates an ArithmeticOperationNode instead of an Integer node
if (this.BloxParams.Count > 0)
{
ArithmeticOperatorBlox arithOpBlox = BloxParams[0].GetComponent <ArithmeticOperatorBlox>();
ArithmeticOperationNode arithOpNode = arithOpBlox.CreateNode(rootNode);
arithOpNode.NodeName = this.GetName();
parentNode.AddChildNode(arithOpNode);
}
else
{
IntegerNode intNode = new IntegerNode(highlightableButton, GetValueAsInt());
intNode.NodeName = this.GetName();
parentNode.AddChildNode(intNode);
}
}
public void Remove(int pos)
{
if (pos >= 0)
{
int value = 0;
if (pos == 0)
{
head = head.NextNode;
System.Diagnostics.Trace.WriteLine("The node " + head.Value + " has been succesfully removed from our linked list");
}
else
{
IntegerNode aux = getElement(pos - 1);
value = aux.NextNode.Value;
aux.NextNode = aux.NextNode.NextNode;
System.Diagnostics.Trace.WriteLine("The node " + value + " has been succesfully removed from our linked list");
}
NumberOfElements--;
}
}
void ReplaceNode(ITree parent, int index, object val, SimpleTypeEnum type)
{
CommonTree node = null;
var token = new CommonToken(-1, val.ToString());
switch (type)
{
case SimpleTypeEnum.Bool:
node = new BoolNode(token);
break;
case SimpleTypeEnum.Byte:
node = new ByteNode(token);
break;
case SimpleTypeEnum.Char:
node = new CharNode(token);
break;
case SimpleTypeEnum.Int:
node = new IntegerNode(token);
break;
case SimpleTypeEnum.Float:
node = new FloatNode(token);
break;
case SimpleTypeEnum.Double:
node = new RealNode(token);
break;
default:
throw new ArgumentOutOfRangeException("type", type, null);
}
parent.ReplaceChildren(index, index, node);
}
protected void MethodCallNodeExecuteCall <T>(T objectValue, AbstractSyntaxTreeNode item)
{
var method = objectValue.GetType().GetMethod(((MethodCallNode)item).Name);
if (method != null)
{
var objectList = new List <object>();
for (int parameterCount = 0; parameterCount < ((MethodCallNode)item).parameterList.Count; parameterCount++)
{
var parameter = ((MethodCallNode)item).parameterList[parameterCount];
if (parameter is StringNode)
{
var value = ((StringNode)parameter).Value;
DateTime dateTime = new DateTime();
if (DateTime.TryParse(value, out dateTime))
{
objectList.Add(dateTime);
}
else
{
objectList.Add(value);
}
}
else if (parameter is DateTimeNode)
{
var value = ((DateTimeNode)parameter).Value;
objectList.Add(value);
}
else if (parameter is BooleanNode)
{
var value = ((BooleanNode)parameter).Value;
objectList.Add(value);
}
else if (parameter is DoubleNode)
{
var value = ((DoubleNode)parameter).Value;
objectList.Add(value);
}
else if (parameter is IntegerNode)
{
var value = ((IntegerNode)parameter).Value;
objectList.Add(value);
}
}
var result = method.Invoke(objectValue, objectList.ToArray());
int intOutValue;
double doubleOutValue;
bool boolOutValue;
DateTime dateTimeOutValue;
if (result == null)
{
NullNode nullNode = new NullNode();
valueStack.Push(nullNode);
}
else if (int.TryParse(result.ToString(), out intOutValue))
{
IntegerNode integerNode = new IntegerNode();
integerNode.Value = intOutValue;
valueStack.Push(integerNode);
}
else if (double.TryParse(result.ToString(), out doubleOutValue))
{
DoubleNode doubleNode = new DoubleNode();
doubleNode.Value = doubleOutValue;
valueStack.Push(doubleNode);
}
else if (bool.TryParse(result.ToString(), out boolOutValue))
{
BooleanNode booleanNode = new BooleanNode();
booleanNode.Value = boolOutValue;
valueStack.Push(booleanNode);
}
else if (DateTime.TryParse(result.ToString(), out dateTimeOutValue))
{
DateTimeNode dateTimeNode = new DateTimeNode();
dateTimeNode.Value = dateTimeOutValue;
valueStack.Push(dateTimeNode);
}
else
{
StringNode stringNode = new StringNode();
stringNode.Value = result.ToString();
valueStack.Push(stringNode);
}
}
}
public void Visit(IntegerNode node)
{
AddAssembly(typeof(int).Assembly);
Nodes.Push(new IntegerNode(node.ObjValue.ToString()));
_schemaFromArgs.Add(node.ObjValue);
}
public void Visit(IntegerNode node)
{
node.Accept(_visitor);
}
private void Parsing(IntegerNode node, StringBuilder sb, ref int lineNum)
{
typeVar = "int32";
PrintCommand(sb, String.Format("ldc.i4 {0}", node.GetChild(0).Text), ref lineNum);
}
public virtual void Visit(IntegerNode node)
{
node.Accept(Visitor);
}
public AstNode VisitInteger(IntegerNode n)
{
Append(n.Value.ToString(CultureInfo.InvariantCulture));
return(n);
}
private SwitchCase ProcessNode(DeserializerTypeContext ctx, IntegerNode node)
{
var bodyExpressions = new List<Expression>();
var callExtractInt = Expression.Call(null, _extractInt32, ctx.IteratorVar, ctx.StringParam);
var accessMember = Expression.MakeMemberAccess(ctx.InstanceVar, node.Member);
var assignMember = Expression.Assign(accessMember, callExtractInt);
//var assignToSubStr = Expression.Assign(ctx.SubStringVar, callExtractString);
bodyExpressions.Add(assignMember);
bodyExpressions.Add(Expression.Empty());
var body = Expression.Block(bodyExpressions);
var @case = Expression.SwitchCase(body, GetSwitchConstant(ctx, node));
return @case;
}
public virtual T VisitInteger(IntegerNode integer)
{
throw new NotImplementedException();
}
public void Visit(IntegerNode node)
{
Nodes.Push(new IntegerNode(node.ObjValue.ToString()));
}
public void Visit(IntegerNode node)
{
}
public IArithmeticNode Expression()
{
IArithmeticNode firstOpNode = Term();
IArithmeticNode intConst;
IArithmeticNode secondOpNode;
IArithmeticNode exprNode = new ExpressionNode(TokenType.UNKNOWN, firstOpNode, null);
while ((curTokenType == TokenType.PLUS) ||
(curTokenType == TokenType.MINUS) ||
(curTokenType == TokenType.DEC) ||
(curTokenType == TokenType.INC))
{
switch (curTokenType)
{
case TokenType.PLUS:
Match(ref matchToken, TokenType.PLUS);
secondOpNode = Expression();
exprNode = new ExpressionNode(TokenType.PLUS, firstOpNode, secondOpNode);
break;
case TokenType.MINUS:
Match(ref matchToken, TokenType.MINUS);
secondOpNode = Expression();
exprNode = new ExpressionNode(TokenType.MINUS, firstOpNode, secondOpNode);
break;
case TokenType.DEC:
Match(ref matchToken, TokenType.DEC);
intConst = new IntegerNode(1);
exprNode = new ExpressionNode(TokenType.MINUS, intConst, firstOpNode);
break;
case TokenType.INC:
Match(ref matchToken, TokenType.INC);
intConst = new IntegerNode(1);
exprNode = new ExpressionNode(TokenType.PLUS, firstOpNode, intConst);
break;
default:
Expect(TokenType.UNKNOWN, lookAheadToken);
break;
}
}
return exprNode;
}
public IArithmeticNode Factor()
{
IArithmeticNode factorNode = new BlankNode();
switch (curTokenType)
{
case TokenType.LPAREN:
Match(ref matchToken, TokenType.LPAREN);
factorNode = BooleanExpression();
Match(ref matchToken, TokenType.RPAREN);
break;
case TokenType.ID:
String idName = lookAheadToken.getValue();
factorNode = new IdentifierNode(idName, IdentifierType.UNKNOWN);
Match(ref matchToken, TokenType.ID);
/*if (lookAheadToken.getType() == TokenType.LPAREN)
{
Match(ref matchToken, TokenType.LPAREN);
ITreeNode argument = BooleanExpression();
Match(ref matchToken, TokenType.RPAREN);
factorNode = new FunctionCallNode(idName, argument);
}*/
break;
case TokenType.INTEGER:
factorNode = new IntegerNode(int.Parse(lookAheadToken.getValue()));
Match(ref matchToken, TokenType.INTEGER);
break;
case TokenType.MINUS: //unary minus
Match(ref matchToken, TokenType.MINUS);
IArithmeticNode tempNode = Expression();
tempNode.setNegative();
factorNode = tempNode;
break;
default:
Expect(TokenType.UNKNOWN, lookAheadToken);
break;
}
return factorNode;
}
