public override IEnumerable<AssociativeNode> BuildOutputAst(List<AssociativeNode> inputAstNodes)
{
// Set default values.
if (!HasConnectedInput(0))
{
inputAstNodes[0] = new IntNode(0);
}
if (!HasConnectedInput(1))
{
inputAstNodes[1] = new IntNode(9);
}
if (!HasConnectedInput(2))
{
inputAstNodes[2] = new IntNode(1);
}
return new[]
{
AstFactory.BuildAssignment(
GetAstIdentifierForOutputIndex(0),
new RangeExprNode
{
From = inputAstNodes[0],
To = inputAstNodes[1],
Step = inputAstNodes[2],
StepOperator = ProtoCore.DSASM.RangeStepOperator.StepSize
})
};
}
public RangeExprNode()
{
IntNode defaultStep = new IntNode();
defaultStep.value = "1";
StepNode = defaultStep;
}
public override IEnumerable<AssociativeNode> BuildOutputAst(List<AssociativeNode> inputAstNodes)
{
AssociativeNode rhs = null;
if (IsPartiallyApplied)
{
var connectedInputs = new List<AssociativeNode>();
var functionNode = new IdentifierNode(functionName);
var paramNumNode = new IntNode(1);
var positionNode = AstFactory.BuildExprList(connectedInputs);
var arguments = AstFactory.BuildExprList(inputAstNodes);
var inputParams = new List<AssociativeNode>
{
functionNode,
paramNumNode,
positionNode,
arguments,
AstFactory.BuildBooleanNode(true)
};
rhs = AstFactory.BuildFunctionCall("_SingleFunctionObject", inputParams);
}
else
{
rhs = AstFactory.BuildFunctionCall(functionName, inputAstNodes);
}
return new[]
{
AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), rhs)
};
}
public override IEnumerable<AssociativeNode> BuildOutputAst(List<AssociativeNode> inputAstNodes)
{
if (HasUnconnectedInput())
{
var connectedInput = Enumerable.Range(0, InPortData.Count)
.Where(HasConnectedInput)
.Select(x => new IntNode(x) as AssociativeNode)
.ToList();
var paramNumNode = new IntNode(InPortData.Count);
var positionNode = AstFactory.BuildExprList(connectedInput);
var arguments = AstFactory.BuildExprList(inputAstNodes);
var functionNode = new IdentifierListNode
{
LeftNode = new IdentifierNode("DSCore.List"),
RightNode = new IdentifierNode("__Create")
};
var inputParams = new List<AssociativeNode>
{
functionNode,
paramNumNode,
positionNode,
arguments,
AstFactory.BuildBooleanNode(false)
};
return new[]
{
AstFactory.BuildAssignment(
GetAstIdentifierForOutputIndex(0),
AstFactory.BuildFunctionCall("_SingleFunctionObject", inputParams))
};
}
else
{
return new[]
{
AstFactory.BuildAssignment(
GetAstIdentifierForOutputIndex(0),
AstFactory.BuildExprList(inputAstNodes))
};
}
}
public override IEnumerable<AssociativeNode> BuildOutputAst(List<AssociativeNode> inputAstNodes)
{
var lhs = GetAstIdentifierForOutputIndex(0);
AssociativeNode rhs;
if (IsPartiallyApplied)
{
var connectedInputs = Enumerable.Range(0, InPorts.Count)
.Where(index=>InPorts[index].IsConnected)
.Select(x => new IntNode(x) as AssociativeNode)
.ToList();
var functionNode = new IdentifierNode(Constants.kInlineConditionalMethodName);
var paramNumNode = new IntNode(3);
var positionNode = AstFactory.BuildExprList(connectedInputs);
var arguments = AstFactory.BuildExprList(inputAstNodes);
var inputParams = new List<AssociativeNode>
{
functionNode,
paramNumNode,
positionNode,
arguments,
AstFactory.BuildBooleanNode(true)
};
rhs = AstFactory.BuildFunctionCall("__CreateFunctionObject", inputParams);
}
else
{
rhs = new InlineConditionalNode
{
ConditionExpression = inputAstNodes[0],
TrueExpression = inputAstNodes[1],
FalseExpression = inputAstNodes[2]
};
}
return new[]
{
AstFactory.BuildAssignment(lhs, rhs)
};
}
void Associative_Number(out ProtoCore.AST.AssociativeAST.AssociativeNode node) {
node = null;
int sign = 1;
int line = ProtoCore.DSASM.Constants.kInvalidIndex;
int col = ProtoCore.DSASM.Constants.kInvalidIndex;
if (la.kind == 15) {
Get();
sign = -1;
line = t.line;
col = t.col;
}
if (la.kind == 2) {
Get();
Int64 value;
if (Int64.TryParse(t.val, System.Globalization.NumberStyles.Number, System.Globalization.CultureInfo.InvariantCulture, out value))
{
node = new ProtoCore.AST.AssociativeAST.IntNode(value * sign);
}
else
{
node = new ProtoCore.AST.AssociativeAST.NullNode();
}
if (ProtoCore.DSASM.Constants.kInvalidIndex == line
&& ProtoCore.DSASM.Constants.kInvalidIndex == col)
{
NodeUtils.SetNodeLocation(node, t);
}
else
{
node.line = line; node.col = col;
node.endLine = t.line; node.endCol = t.col;
}
} else if (la.kind == 3) {
Get();
double value;
if (Double.TryParse(t.val, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out value))
{
node = new ProtoCore.AST.AssociativeAST.DoubleNode(value * sign);
}
else
{
node = new ProtoCore.AST.AssociativeAST.NullNode();
}
if (ProtoCore.DSASM.Constants.kInvalidIndex == line
&& ProtoCore.DSASM.Constants.kInvalidIndex == col)
{
NodeUtils.SetNodeLocation(node, t);
}
else
{
node.line = line; node.col = col;
}
} else SynErr(98);
}
/// <summary>
/// TODO: Deprecate
/// Emit IntNode or DoubleNode
/// </summary>
/// <param name="node"></param>
/// <param name="outnode"></param>
private void EmitLiteralNode(LiteralNode node, out AssociativeNode outnode)
{
Validity.Assert(node != null);
Validity.Assert(node.children.Count == 0);
// Create temp identifier and assign it to the literal (IntNode or DoubleNode) to create a BinaryExpressionNode
// Return the temp IdentifierNode
//BinaryExpressionNode expressionNode = new BinaryExpressionNode();
AssociativeNode rightNode = null;
Int64 number;
double real;
bool flag;
string val = node.ToScript();
// If LiternalNode is double
if(Double.TryParse(val, NumberStyles.Number, CultureInfo.InvariantCulture, out real))
{
rightNode = new DoubleNode(real);
}
// If LiteralNode type is Int
else if (Int64.TryParse(val, NumberStyles.Number, CultureInfo.InvariantCulture, out number))
{
rightNode = new IntNode(number);
}
// If LiteralNode is bool
else if (Boolean.TryParse(val, out flag))
{
rightNode = new BooleanNode(flag);
}
/*IdentifierNode ident = CreateTempIdentifierNode(node);
expressionNode.RightNode = rightNode;
expressionNode.LeftNode = ident;
expressionNode.Optr = ProtoCore.DSASM.Operator.assign;*/
//(AstRootNode as CodeBlockNode).Body.Add(expressionNode);
//outnode = expressionNode;
outnode = CreateBinaryExpNode(node, rightNode);
}
void Associative_Number(out ProtoCore.AST.AssociativeAST.AssociativeNode node)
{
node = null; String localvalue = String.Empty;
int line = ProtoCore.DSASM.Constants.kInvalidIndex; int col = ProtoCore.DSASM.Constants.kInvalidIndex;
if (la.kind == 12) {
Get();
localvalue = "-"; line = t.line; col = t.col;
}
if (la.kind == 2) {
Get();
node = new ProtoCore.AST.AssociativeAST.IntNode() { value = localvalue + t.val };
if ( ProtoCore.DSASM.Constants.kInvalidIndex == line
&& ProtoCore.DSASM.Constants.kInvalidIndex == col)
{
NodeUtils.SetNodeLocation(node, t);
}
else
{
node.line = line; node.col = col;
}
} else if (la.kind == 3) {
Get();
node = new ProtoCore.AST.AssociativeAST.DoubleNode() { value = localvalue + t.val };
if ( ProtoCore.DSASM.Constants.kInvalidIndex == line
&& ProtoCore.DSASM.Constants.kInvalidIndex == col)
{
NodeUtils.SetNodeLocation(node, t);
}
else
{
node.line = line; node.col = col;
}
} else SynErr(101);
}
public void DFSTraverse(ref AST.AssociativeAST.AssociativeNode node)
{
if (node is AST.AssociativeAST.IdentifierNode)
{
EmitIdentifierNode(ref node);
}
else if (node is ProtoCore.AST.AssociativeAST.IdentifierListNode)
{
AST.AssociativeAST.IdentifierListNode identList = node as ProtoCore.AST.AssociativeAST.IdentifierListNode;
EmitIdentifierListNode(ref identList);
}
else if (node is ProtoCore.AST.AssociativeAST.IntNode)
{
AST.AssociativeAST.IntNode intNode = node as ProtoCore.AST.AssociativeAST.IntNode;
EmitIntNode(ref intNode);
}
else if (node is ProtoCore.AST.AssociativeAST.DoubleNode)
{
AST.AssociativeAST.DoubleNode doubleNode = node as ProtoCore.AST.AssociativeAST.DoubleNode;
EmitDoubleNode(ref doubleNode);
}
else if (node is ProtoCore.AST.AssociativeAST.FunctionCallNode)
{
AST.AssociativeAST.FunctionCallNode funcCallNode = node as ProtoCore.AST.AssociativeAST.FunctionCallNode;
EmitFunctionCallNode(ref funcCallNode);
}
else if (node is ProtoCore.AST.AssociativeAST.FunctionDotCallNode)
{
AST.AssociativeAST.FunctionDotCallNode funcDotCall = node as ProtoCore.AST.AssociativeAST.FunctionDotCallNode;
EmitFunctionDotCallNode(ref funcDotCall);
}
else if (node is ProtoCore.AST.AssociativeAST.BinaryExpressionNode)
{
ProtoCore.AST.AssociativeAST.BinaryExpressionNode binaryExpr = node as ProtoCore.AST.AssociativeAST.BinaryExpressionNode;
if (binaryExpr.Optr != DSASM.Operator.assign)
{
;
}
//EmitCode("(");
EmitBinaryNode(ref binaryExpr);
if (binaryExpr.Optr == DSASM.Operator.assign)
{
//EmitCode(ProtoCore.DSASM.Constants.termline);
}
if (binaryExpr.Optr != DSASM.Operator.assign)
{
;
}
//EmitCode(")");
}
else if (node is ProtoCore.AST.AssociativeAST.FunctionDefinitionNode)
{
AST.AssociativeAST.FunctionDefinitionNode funcDefNode = node as ProtoCore.AST.AssociativeAST.FunctionDefinitionNode;
EmitFunctionDefNode(ref funcDefNode);
}
else if (node is ProtoCore.AST.AssociativeAST.ClassDeclNode)
{
AST.AssociativeAST.ClassDeclNode classDeclNode = node as ProtoCore.AST.AssociativeAST.ClassDeclNode;
EmitClassDeclNode(ref classDeclNode);
}
else if (node is ProtoCore.AST.AssociativeAST.NullNode)
{
AST.AssociativeAST.NullNode nullNode = node as ProtoCore.AST.AssociativeAST.NullNode;
EmitNullNode(ref nullNode);
}
else if (node is ProtoCore.AST.AssociativeAST.ArrayIndexerNode)
{
AST.AssociativeAST.ArrayIndexerNode arrIdxNode = node as ProtoCore.AST.AssociativeAST.ArrayIndexerNode;
EmitArrayIndexerNode(ref arrIdxNode);
}
else if (node is ProtoCore.AST.AssociativeAST.ExprListNode)
{
AST.AssociativeAST.ExprListNode exprListNode = node as ProtoCore.AST.AssociativeAST.ExprListNode;
EmitExprListNode(ref exprListNode);
}
}
private void TraverseDotCallArguments(FunctionCallNode funcCall,
FunctionDotCallNode dotCall,
ProcedureNode procCallNode,
List<ProtoCore.Type> arglist,
string procName,
int classIndex,
string className,
bool isStaticCall,
bool isConstructor,
GraphNode graphNode,
ProtoCore.CompilerDefinitions.Associative.SubCompilePass subPass,
BinaryExpressionNode bnode)
{
// Update graph dependencies
if (subPass != ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kUnboundIdentifier && graphNode != null)
{
if (isStaticCall)
{
Validity.Assert(classIndex != Constants.kInvalidIndex);
Validity.Assert(!string.IsNullOrEmpty(className));
SymbolNode classSymbol = new SymbolNode();
classSymbol.name = className;
classSymbol.classScope = classIndex;
PushSymbolAsDependent(classSymbol, graphNode);
}
}
int funtionArgCount = 0;
for (int n = 0; n < funcCall.FormalArguments.Count; ++n)
{
if (isStaticCall || isConstructor)
{
if (n != Constants.kDotArgIndexArrayArgs)
{
continue;
}
}
AssociativeNode paramNode = funcCall.FormalArguments[n];
ProtoCore.Type paramType = TypeSystem.BuildPrimitiveTypeObject(PrimitiveType.kTypeVar, 0);
emitReplicationGuide = false;
// If it's a binary node then continue type check, otherwise
// disable type check and just take the type of paramNode itself
enforceTypeCheck = !(paramNode is BinaryExpressionNode);
if (ProtoCore.DSASM.Constants.kDotArgIndexPtr == n)
{
// Traversing the first arg (the LHS pointer/Static instanct/Constructor
// Replication guides only allowed on method, e.g.,
//
// x = p<1>.f({1,2}<2>);
//
// But not on getter, e.g.,
//
// c = a<1>.x<2>;
if (!CoreUtils.IsGetterSetter(procName) && !isConstructor)
{
emitReplicationGuide = true;
}
DfsTraverse(paramNode, ref paramType, false, graphNode, subPass, bnode);
}
else if (ProtoCore.DSASM.Constants.kDotArgIndexArrayArgs == n)
{
// Traversing the actual arguments passed into the function
// (not the dot function)
int defaultArgNumber = 0;
// If its null this is the second call in a chained dot
if (null != procCallNode)
{
defaultArgNumber = procCallNode.ArgumentInfos.Count - dotCall.FunctionCall.FormalArguments.Count;
}
// Enable graphnode dependencies if its a setter method
bool allowDependentState = null != graphNode ? graphNode.allowDependents : false;
if (CoreUtils.IsSetter(procName))
{
// If the arguments are not temporaries
ExprListNode exprList = paramNode as ExprListNode;
Validity.Assert(1 == exprList.Exprs.Count);
string varname = string.Empty;
if (exprList.Exprs[0] is IdentifierNode)
{
varname = (exprList.Exprs[0] as IdentifierNode).Name;
if (!CoreUtils.IsAutoGeneratedVar(varname))
{
graphNode.allowDependents = true;
}
else if (CoreUtils.IsSSATemp(varname) && core.Options.GenerateSSA)
{
graphNode.allowDependents = true;
}
}
else
{
graphNode.allowDependents = true;
}
}
emitReplicationGuide = true;
if (defaultArgNumber > 0)
{
ExprListNode exprList = paramNode as ExprListNode;
if (subPass != ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kUnboundIdentifier)
{
for (int i = 0; i < defaultArgNumber; i++)
{
exprList.Exprs.Add(new DefaultArgNode());
}
}
if (!isStaticCall && !isConstructor)
{
DfsTraverse(paramNode, ref paramType, false, graphNode, subPass);
funtionArgCount = exprList.Exprs.Count;
}
else
{
foreach (AssociativeNode exprListNode in exprList.Exprs)
{
bool repGuideState = emitReplicationGuide;
if (subPass == ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kUnboundIdentifier)
{
emitReplicationGuide = false;
}
DfsTraverse(exprListNode, ref paramType, false, graphNode, subPass, bnode);
emitReplicationGuide = repGuideState;
arglist.Add(paramType);
}
}
}
else
{
ExprListNode exprList = paramNode as ExprListNode;
// Comment Jun: This is a getter/setter or a an auto-generated thisarg function...
// ...add the dynamic sv that will be resolved as a pointer at runtime
if (!isStaticCall && !isConstructor)
{
// TODO Jun: pls get rid of subPass checking outside the core travesal
if (ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kNone == subPass)
{
exprList.Exprs.Insert(0, new DynamicNode());
}
}
if (exprList.Exprs.Count > 0)
{
foreach (AssociativeNode exprListNode in exprList.Exprs)
{
bool repGuideState = emitReplicationGuide;
if (subPass == ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kUnboundIdentifier)
{
emitReplicationGuide = false;
}
DfsTraverse(exprListNode, ref paramType, false, graphNode, subPass, bnode);
emitReplicationGuide = repGuideState;
arglist.Add(paramType);
}
if (subPass != ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kUnboundIdentifier &&
!isStaticCall &&
!isConstructor)
{
EmitInstrConsole(ProtoCore.DSASM.kw.alloca, exprList.Exprs.Count.ToString());
EmitPopArray(exprList.Exprs.Count);
if (exprList.ArrayDimensions != null)
{
int dimensions = DfsEmitArrayIndexHeap(exprList.ArrayDimensions, graphNode);
EmitInstrConsole(ProtoCore.DSASM.kw.pushindex, dimensions.ToString() + "[dim]");
EmitPushArrayIndex(dimensions);
}
}
}
else
{
if (!isStaticCall && !isConstructor)
{
if (exprList != null)
{
bool emitReplicationGuideState = emitReplicationGuide;
emitReplicationGuide = false;
DfsTraverse(paramNode, ref paramType, false, graphNode, subPass);
emitReplicationGuide = emitReplicationGuideState;
}
else
{
DfsTraverse(paramNode, ref paramType, false, graphNode, subPass);
}
}
}
funtionArgCount = exprList.Exprs.Count;
}
emitReplicationGuide = false;
// Restore the state only if it is a setter method
if (ProtoCore.Utils.CoreUtils.IsSetter(procName))
{
graphNode.allowDependents = allowDependentState;
}
}
else if (ProtoCore.DSASM.Constants.kDotArgIndexArgCount == n)
{
IntNode argNumNode = new IntNode(funtionArgCount);
DfsTraverse(argNumNode, ref paramType, false, graphNode, subPass);
}
else
{
DfsTraverse(paramNode, ref paramType, false, graphNode, subPass);
}
emitReplicationGuide = false;
enforceTypeCheck = true;
if (!isStaticCall || !isConstructor)
{
arglist.Add(paramType);
}
}
}
private void EmitRangeExprNode(AssociativeNode node, ref ProtoCore.Type inferedType, ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone)
{
RangeExprNode range = node as RangeExprNode;
// Do some static checking...
if ((range.FromNode is IntNode || range.FromNode is DoubleNode) &&
(range.ToNode is IntNode || range.ToNode is DoubleNode) &&
(range.StepNode == null || (range.StepNode != null && (range.StepNode is IntNode || range.StepNode is DoubleNode))))
{
decimal current = (range.FromNode is IntNode) ? Int64.Parse((range.FromNode as IntNode).value) : Decimal.Parse((range.FromNode as DoubleNode).value);
decimal end = (range.ToNode is IntNode) ? Int64.Parse((range.ToNode as IntNode).value) : Decimal.Parse((range.ToNode as DoubleNode).value);
ProtoCore.DSASM.RangeStepOperator stepoperator = range.stepoperator;
decimal step = 1;
if (range.StepNode != null)
{
step = (range.StepNode is IntNode) ? Int64.Parse((range.StepNode as IntNode).value) : Decimal.Parse((range.StepNode as DoubleNode).value);
}
if (stepoperator == ProtoCore.DSASM.RangeStepOperator.stepsize)
{
if (range.StepNode == null && end < current)
{
step = -1;
}
if (step == 0)
{
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kInvalidRangeExpression, ProtoCore.BuildData.WarningMessage.kRangeExpressionWithStepSizeZero, compileStateTracker.CurrentDSFileName, range.StepNode.line, range.StepNode.col);
EmitNullNode(new NullNode(), ref inferedType);
return;
}
if ((end > current && step < 0) || (end < current && step > 0))
{
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kInvalidRangeExpression, ProtoCore.BuildData.WarningMessage.kRangeExpressionWithInvalidStepSize, compileStateTracker.CurrentDSFileName, range.StepNode.line, range.StepNode.col);
EmitNullNode(new NullNode(), ref inferedType);
return;
}
}
else if (stepoperator == ProtoCore.DSASM.RangeStepOperator.num)
{
if (range.StepNode != null && !(range.StepNode is IntNode))
{
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kInvalidRangeExpression, ProtoCore.BuildData.WarningMessage.kRangeExpressionWithNonIntegerStepNumber, compileStateTracker.CurrentDSFileName, range.StepNode.line, range.StepNode.col);
EmitNullNode(new NullNode(), ref inferedType);
return;
}
if (step <= 0)
{
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kInvalidRangeExpression, ProtoCore.BuildData.WarningMessage.kRangeExpressionWithNegativeStepNumber, compileStateTracker.CurrentDSFileName, range.StepNode.line, range.StepNode.col);
EmitNullNode(new NullNode(), ref inferedType);
return;
}
}
else if (stepoperator == ProtoCore.DSASM.RangeStepOperator.approxsize)
{
if (step == 0)
{
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kInvalidRangeExpression, ProtoCore.BuildData.WarningMessage.kRangeExpressionWithStepSizeZero, compileStateTracker.CurrentDSFileName, range.StepNode.line, range.StepNode.col);
EmitNullNode(new NullNode(), ref inferedType);
return;
}
}
}
// Replace with build-in RangeExpression() function. - Yu Ke
bool emitReplicationgGuideState = emitReplicationGuide;
emitReplicationGuide = false;
BooleanNode hasStep = new BooleanNode { value = range.StepNode == null ? "false" : "true" };
IntNode op = new IntNode();
switch (range.stepoperator)
{
case ProtoCore.DSASM.RangeStepOperator.stepsize:
op.value = "0";
break;
case ProtoCore.DSASM.RangeStepOperator.num:
op.value = "1";
break;
case ProtoCore.DSASM.RangeStepOperator.approxsize:
op.value = "2";
break;
default:
op.value = "-1";
break;
}
var rangeExprFunc = nodeBuilder.BuildFunctionCall(Constants.kFunctionRangeExpression,
new List<AssociativeNode> { range.FromNode, range.ToNode, range.StepNode == null ? new NullNode() : range.StepNode, op, hasStep });
EmitFunctionCallNode(rangeExprFunc, ref inferedType, false, graphNode, subPass);
emitReplicationGuide = emitReplicationgGuideState;
if (subPass != ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
if (range.ArrayDimensions != null)
{
int dimensions = DfsEmitArrayIndexHeap(range.ArrayDimensions, graphNode);
EmitInstrConsole(ProtoCore.DSASM.kw.pushindex, dimensions.ToString() + "[dim]");
EmitPushArrayIndex(dimensions);
}
if (compileStateTracker.Options.TempReplicationGuideEmptyFlag && emitReplicationGuide)
{
int replicationGuideNumber = EmitReplicationGuides(range.ReplicationGuides);
EmitInstrConsole(ProtoCore.DSASM.kw.pushindex, replicationGuideNumber + "[guide]");
EmitPushReplicationGuide(replicationGuideNumber);
}
}
}
private void EmitRangeExprNode(AssociativeNode node, ref ProtoCore.Type inferedType, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone)
{
// (Ayush) Using Decimal type instead of Double for the sake of precision. For eg. doing 0.3d - 0.1d gives a result a little less than 0.2. These inaccuracies propogate
// through a range expression and quickly cause wrong values to be returned.
RangeExprNode range = node as RangeExprNode;
if ((range.FromNode is NullNode || range.FromNode is BooleanNode)
|| (range.ToNode is NullNode || range.ToNode is BooleanNode)
|| (range.StepNode is NullNode || range.StepNode is BooleanNode))
{
throw new ProtoCore.Exceptions.CompileErrorsOccured("Invalid range expression");
}
else if ((range.FromNode is IntNode || range.FromNode is DoubleNode)
&& (range.ToNode is IntNode || range.ToNode is DoubleNode)
&& (range.StepNode is IntNode || range.StepNode is DoubleNode))
{
ProtoCore.Type type = new ProtoCore.Type();
type.UID = (int)PrimitiveType.kTypeVoid;
type.IsIndexable = true;
type.Name = "double";
type.UID = (int)ProtoCore.PrimitiveType.kTypeDouble;
type.rank = 1;
int totalSteps = 0;
bool terminate = false;
decimal current = (range.FromNode is IntNode) ? Int64.Parse((range.FromNode as IntNode).value) : Decimal.Parse((range.FromNode as DoubleNode).value);
decimal end = (range.ToNode is IntNode) ? Int64.Parse((range.ToNode as IntNode).value) : Decimal.Parse((range.ToNode as DoubleNode).value);
ProtoCore.DSASM.RangeStepOperator stepoperator = range.stepoperator;
decimal step = (range.StepNode is IntNode) ? Int64.Parse((range.StepNode as IntNode).value) : Decimal.Parse((range.StepNode as DoubleNode).value);
decimal stepsize = 1.0M;
if (stepoperator == ProtoCore.DSASM.RangeStepOperator.stepsize)
{
if (step == 0)
{
return;
}
if ((end > current && step < 0) || (end < current && step > 0))
{
return;
}
stepsize = step;
}
else if (stepoperator == ProtoCore.DSASM.RangeStepOperator.num)
{
if (!(range.StepNode is IntNode))
{
return;
}
if (step <= 0)
{
return;
}
if ((step - 1) == 0)
stepsize = 0;
else
stepsize = (end - current) / (step - 1);
}
else if (stepoperator == ProtoCore.DSASM.RangeStepOperator.approxsize)
{
if (step == 0)
{
return;
}
RangeExprNode rnode = range;
IntNode newStep = new IntNode();
rnode.StepNode = newStep; rnode.stepoperator = ProtoCore.DSASM.RangeStepOperator.num;
decimal dist = end - current;
if (dist == 0)
{
newStep.value = "1";
}
else
{
decimal ceilStepSize = Math.Ceiling((dist) / step);
decimal floorStepSize = Math.Floor((dist) / step);
decimal numOfSteps;
if ((ceilStepSize == 0) || (floorStepSize == 0))
numOfSteps = 2;
else
numOfSteps = (Math.Abs(dist / ceilStepSize - step) < Math.Abs(dist / floorStepSize - step)) ? ceilStepSize + 1 : floorStepSize + 1;
newStep.value = numOfSteps.ToString();
}
EmitRangeExprNode(rnode, ref inferedType);
return;
}
bool isIntArray = (range.FromNode is IntNode) &&
(range.ToNode is IntNode) &&
(range.StepNode is IntNode) &&
(Math.Equals(stepsize, Math.Truncate(stepsize)));
if (isIntArray)
{
type.Name = "int";
type.UID = (int)ProtoCore.PrimitiveType.kTypeInt;
}
if (stepsize == 0)
{
for (int i = 0; i < step; ++i)
{
if (isIntArray)
EmitIntNode(new IntNode { value = current.ToString() }, ref type);
else
EmitDoubleNode(new DoubleNode { value = current.ToString() }, ref type);
++totalSteps;
}
}
else
{
while (true)
{
if (stepoperator == ProtoCore.DSASM.RangeStepOperator.stepsize)
terminate = (step < 0) ? ((current < end) ? true : false) : ((current > end) ? true : false);
else if (stepoperator == ProtoCore.DSASM.RangeStepOperator.num)
terminate = (totalSteps >= step) ? true : false;
if (terminate) break;
if (isIntArray)
EmitIntNode(new IntNode { value = current.ToString() }, ref type);
else
EmitDoubleNode(new DoubleNode { value = current.ToString() }, ref type);
current += stepsize;
++totalSteps;
}
}
inferedType = type;
}
else
{
// traverse the from node
DfsTraverse(range.FromNode, ref inferedType);
// traverse the To node
DfsTraverse(range.ToNode, ref inferedType);
// traverse the step node
DfsTraverse(range.StepNode, ref inferedType, false, null, subPass);
inferedType.IsIndexable = true;
inferedType.rank++;
}
}
void Associative_Number(out ProtoCore.AST.AssociativeAST.AssociativeNode node) {
node = null;
int sign = 1;
int line = ProtoCore.DSASM.Constants.kInvalidIndex;
int col = ProtoCore.DSASM.Constants.kInvalidIndex;
if (la.kind == 13) {
Get();
sign = -1;
line = t.line;
col = t.col;
}
if (la.kind == 2) {
Get();
Int64 value;
if (Int64.TryParse(t.val, out value))
{
node = new ProtoCore.AST.AssociativeAST.IntNode(value * sign);
}
else
{
node = new ProtoCore.AST.AssociativeAST.NullNode();
}
if (ProtoCore.DSASM.Constants.kInvalidIndex == line
&& ProtoCore.DSASM.Constants.kInvalidIndex == col)
{
NodeUtils.SetNodeLocation(node, t);
}
else
{
node.line = line; node.col = col;
}
} else if (la.kind == 3) {
Get();
double value;
if (Double.TryParse(t.val, out value))
{
node = new ProtoCore.AST.AssociativeAST.DoubleNode(value * sign);
}
else
{
node = new ProtoCore.AST.AssociativeAST.NullNode();
}
if (ProtoCore.DSASM.Constants.kInvalidIndex == line
&& ProtoCore.DSASM.Constants.kInvalidIndex == col)
{
NodeUtils.SetNodeLocation(node, t);
}
else
{
node.line = line; node.col = col;
}
} else SynErr(104);
}
public RangeExprNode()
{
IntNode defaultStep = new IntNode();
defaultStep.value = "1";
StepNode = defaultStep;
}
public static FunctionDotCallNode GenerateCallDotNode(AssociativeNode lhs,
FunctionCallNode rhsCall, Core core = null)
{
// The function name to call
string rhsName = rhsCall.Function.Name;
int argNum = rhsCall.FormalArguments.Count;
ExprListNode argList = new ExprListNode();
foreach (AssociativeNode arg in rhsCall.FormalArguments)
{
// The function arguments
argList.Exprs.Add(arg);
}
var arguments = new List<AssociativeNode>();
int rhsIdx = DSASM.Constants.kInvalidIndex;
string lhsName = string.Empty;
if (lhs is IdentifierNode)
{
lhsName = (lhs as IdentifierNode).Name;
if (lhsName == DSDefinitions.Keyword.This)
{
lhs = new ThisPointerNode();
}
}
if (core != null)
{
DynamicFunction func;
if (core.DynamicFunctionTable.TryGetFunction(rhsName, 0, Constants.kInvalidIndex, out func))
{
rhsIdx = func.Index;
}
else
{
func = core.DynamicFunctionTable.AddNewFunction(rhsName, 0, Constants.kInvalidIndex);
rhsIdx = func.Index;
}
}
// The first param to the dot arg (the pointer or the class name)
arguments.Add(lhs);
// The second param which is the dynamic table index of the function to call
arguments.Add(new IntNode(rhsIdx));
// The array dimensions
ExprListNode arrayDimExperList = new ExprListNode();
int dimCount = 0;
if (rhsCall.Function is IdentifierNode)
{
// Number of dimensions
IdentifierNode fIdent = rhsCall.Function as IdentifierNode;
if (fIdent.ArrayDimensions != null)
{
arrayDimExperList = CoreUtils.BuildArrayExprList(fIdent.ArrayDimensions);
dimCount = arrayDimExperList.Exprs.Count;
}
else if (rhsCall.ArrayDimensions != null)
{
arrayDimExperList = CoreUtils.BuildArrayExprList(rhsCall.ArrayDimensions);
dimCount = arrayDimExperList.Exprs.Count;
}
else
{
arrayDimExperList = new ExprListNode();
}
}
arguments.Add(arrayDimExperList);
// Number of dimensions
var dimNode = new IntNode(dimCount);
arguments.Add(dimNode);
if (argNum >= 0)
{
arguments.Add(argList);
arguments.Add(new IntNode(argNum));
}
var funDotCallNode = new FunctionDotCallNode(rhsCall, arguments);
// funDotCallNode.FunctionCall.Function = rhsCall.Function;
NodeUtils.SetNodeEndLocation(funDotCallNode, rhsCall);
return funDotCallNode;
}
public void GetStatementVariables01()
{
// Create a statement of "Value = 1234".
var leftNode = new IdentifierNode("Value");
var rightNode = new IntNode(1234);
var binExprNode = new BinaryExpressionNode(
leftNode, rightNode, Operator.assign);
var statements = new List<Statement>
{
Statement.CreateInstance(binExprNode)
};
var vars = CodeBlockUtils.GetStatementVariables(statements, true);
Assert.IsNotNull(vars);
Assert.AreEqual(1, vars.Count());
var variables = vars.ElementAt(0);
Assert.IsNotNull(variables);
Assert.AreEqual(1, variables.Count());
Assert.AreEqual("Value", variables.ElementAt(0));
}
private AssociativeNode CreateFunctionObject(
AssociativeNode functionNode, List<AssociativeNode> inputs)
{
var paramNumNode = new IntNode(this.GetInputIndex());
var positionNode = AstFactory.BuildExprList(GetConnectedInputs());
var arguments = AstFactory.BuildExprList(inputs);
var inputParams = new List<AssociativeNode>
{
functionNode,
paramNumNode,
positionNode,
arguments,
AstFactory.BuildBooleanNode(true)
};
return AstFactory.BuildFunctionCall("_SingleFunctionObject", inputParams);
}
public ProtoCore.DSASM.ProcedureNode TraverseDotFunctionCall(ProtoCore.AST.Node node, ProtoCore.AST.Node parentNode, int lefttype, int depth, ref ProtoCore.Type inferedType,
ProtoCore.AssociativeGraph.GraphNode graphNode = null, ProtoCore.DSASM.AssociativeSubCompilePass subPass = ProtoCore.DSASM.AssociativeSubCompilePass.kNone,
ProtoCore.AST.AssociativeAST.BinaryExpressionNode bnode = null)
{
FunctionCallNode funcCall = null;
ProtoCore.DSASM.ProcedureNode procCallNode = null;
ProtoCore.DSASM.ProcedureNode procDotCallNode = null;
string procName = null;
List<ProtoCore.Type> arglist = new List<ProtoCore.Type>();
ProtoCore.Type dotCallType = new ProtoCore.Type();
dotCallType.UID = (int)PrimitiveType.kTypeVar;
dotCallType.IsIndexable = false;
bool isConstructor = false;
bool isStaticCall = false;
bool isStaticCallAllowed = false;
bool isUnresolvedDot = false;
bool isUnresolvedMethod = false;
int classIndex = ProtoCore.DSASM.Constants.kInvalidIndex;
string className = string.Empty;
ProtoCore.AST.AssociativeAST.FunctionDotCallNode dotCall = node as ProtoCore.AST.AssociativeAST.FunctionDotCallNode;
funcCall = dotCall.DotCall;
procName = dotCall.FunctionCall.Function.Name;
List<AssociativeNode> replicationGuide = (dotCall.FunctionCall.Function as IdentifierNode).ReplicationGuides;
var dotCallFirstArgument = dotCall.DotCall.FormalArguments[0];
if (dotCallFirstArgument is FunctionDotCallNode)
{
isUnresolvedDot = true;
}
else if (dotCallFirstArgument is IdentifierNode || dotCallFirstArgument is ThisPointerNode)
{
// Check if the lhs identifer is a class name
string lhsName = "";
int ci = Constants.kInvalidIndex;
if (dotCallFirstArgument is IdentifierNode)
{
lhsName = (dotCallFirstArgument as IdentifierNode).Name;
ci = compileStateTracker.ClassTable.IndexOf(lhsName);
classIndex = ci;
className = lhsName;
// As a class name can be used as property name, we need to
// check if this identifier is a property or a class name.
//
if (ci != Constants.kInvalidIndex && globalClassIndex != Constants.kInvalidIndex)
{
ProtoCore.DSASM.SymbolNode symbolnode;
bool isAccessbile = false;
bool hasAllocated = VerifyAllocation(lhsName, globalClassIndex, globalProcIndex, out symbolnode, out isAccessbile);
// Well, found a property whose name is class name. Now
// we need to check if the RHS function call is
// constructor or not.
if (hasAllocated && isAccessbile && symbolnode.functionIndex == ProtoCore.DSASM.Constants.kInvalidIndex)
{
var procnode = GetProcedureFromInstance(ci, dotCall.FunctionCall);
if (procnode != null && !procnode.isConstructor)
{
ci = Constants.kInvalidIndex;
lhsName = "";
}
}
}
}
if (ci != ProtoCore.DSASM.Constants.kInvalidIndex)
{
// It is a class name
dotCall.DotCall.FormalArguments[0] = new IntNode { value = ci.ToString() };
dotCallFirstArgument = dotCall.DotCall.FormalArguments[0];
inferedType.UID = dotCallType.UID = ci;
string rhsName = dotCall.FunctionCall.Function.Name;
procCallNode = GetProcedureFromInstance(ci, dotCall.FunctionCall, graphNode);
if (null != procCallNode)
{
isConstructor = procCallNode.isConstructor;
// It's a static call if its not a constructor
isStaticCall = !procCallNode.isConstructor;
// If this is a static call and the first method found was not static
// Look further
if (isStaticCall && !procCallNode.isStatic)
{
ProtoCore.DSASM.ProcedureNode staticProcCallNode = compileStateTracker.ClassTable.ClassNodes[ci].GetFirstStaticMemberFunction(procName);
if (null != staticProcCallNode)
{
procCallNode = staticProcCallNode;
}
}
isStaticCallAllowed = procCallNode.isStatic && isStaticCall;
}
else
{
ProtoCore.DSASM.ProcedureNode staticProcCallNode = compileStateTracker.ClassTable.ClassNodes[ci].GetFirstStaticMemberFunction(procName);
string functionName = dotCall.FunctionCall.Function.Name;
string property;
if (null != staticProcCallNode)
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kMethodHasInvalidArguments, functionName);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kCallingNonStaticMethodOnClass, message, compileStateTracker.CurrentDSFileName, dotCall.line, dotCall.col);
}
else if (CoreUtils.TryGetPropertyName(functionName, out property))
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kCallingNonStaticProperty, lhsName, property);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kCallingNonStaticMethodOnClass, message, compileStateTracker.CurrentDSFileName, dotCall.line, dotCall.col);
}
else
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kCallingNonStaticMethod, lhsName, functionName);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kCallingNonStaticMethodOnClass, message, compileStateTracker.CurrentDSFileName, dotCall.line, dotCall.col);
}
}
}
if (dotCall.DotCall.FormalArguments.Count == ProtoCore.DSASM.Constants.kDotCallArgCount)
{
if (dotCallFirstArgument is IdentifierNode)
{
ProtoCore.DSASM.SymbolNode symbolnode = null;
bool isAccessible = false;
bool isAllocated = VerifyAllocation((dotCallFirstArgument as IdentifierNode).Name, globalClassIndex, globalProcIndex, out symbolnode, out isAccessible);
if (isAllocated && symbolnode.datatype.UID != (int)PrimitiveType.kTypeVar)
{
inferedType.UID = symbolnode.datatype.UID;
if (ProtoCore.DSASM.Constants.kInvalidIndex != inferedType.UID)
{
procCallNode = GetProcedureFromInstance(symbolnode.datatype.UID, dotCall.FunctionCall);
}
if (null != procCallNode)
{
if (procCallNode.isConstructor)
{
if (subPass != ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
// A constructor cannot be called from an instance
string message = String.Format(ProtoCore.BuildData.WarningMessage.KCallingConstructorOnInstance, procName);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kCallingConstructorOnInstance, message, compileStateTracker.CurrentDSFileName, funcCall.line, funcCall.col);
}
isUnresolvedDot = true;
isUnresolvedMethod = true;
}
else
{
isAccessible =
procCallNode.access == ProtoCore.DSASM.AccessSpecifier.kPublic
|| (procCallNode.access == ProtoCore.DSASM.AccessSpecifier.kPrivate && procCallNode.classScope == globalClassIndex);
if (!isAccessible)
{
if (subPass != ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kMethodIsInaccessible, procName);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kAccessViolation, message, compileStateTracker.CurrentDSFileName, funcCall.line, funcCall.col);
}
}
if (null != procCallNode)
{
int dynamicRhsIndex = int.Parse((dotCall.DotCall.FormalArguments[1] as IntNode).value);
compileStateTracker.DynamicFunctionTable.functionTable[dynamicRhsIndex].classIndex = procCallNode.classScope;
compileStateTracker.DynamicFunctionTable.functionTable[dynamicRhsIndex].procedureIndex = procCallNode.procId;
compileStateTracker.DynamicFunctionTable.functionTable[dynamicRhsIndex].pc = procCallNode.pc;
}
}
}
}
else
{
isUnresolvedDot = true;
}
}
else if (dotCallFirstArgument is ThisPointerNode)
{
if (globalClassIndex != Constants.kInvalidIndex)
{
procCallNode = GetProcedureFromInstance(globalClassIndex, dotCall.FunctionCall);
if (null != procCallNode && procCallNode.isConstructor)
{
dotCall.DotCall.FormalArguments[0] = new IntNode { value = globalClassIndex.ToString() };
dotCallFirstArgument = dotCall.DotCall.FormalArguments[0];
inferedType.UID = dotCallType.UID = ci;
}
}
}
}
}
else if (funcCall.FormalArguments[0] is IntNode)
{
inferedType.UID = dotCallType.UID = int.Parse((funcCall.FormalArguments[0] as IntNode).value);
classIndex = inferedType.UID;
procCallNode = GetProcedureFromInstance(dotCallType.UID, dotCall.FunctionCall, graphNode);
if (null != procCallNode)
{
// It's a static call if its not a constructor
isConstructor = procCallNode.isConstructor;
isStaticCall = !procCallNode.isConstructor;
// If this is a static call and the first method found was not static
// Look further
if (isStaticCall && !procCallNode.isStatic)
{
ProtoCore.DSASM.ProcedureNode staticProcCallNode = compileStateTracker.ClassTable.ClassNodes[inferedType.UID].GetFirstStaticMemberFunction(procName);
if (null != staticProcCallNode)
{
procCallNode = staticProcCallNode;
}
}
isStaticCallAllowed = procCallNode.isStatic && isStaticCall;
className = compileStateTracker.ClassTable.ClassNodes[dotCallType.UID].name;
if (isStaticCall && !isStaticCallAllowed)
{
if (subPass != ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
string property;
className = compileStateTracker.ClassTable.ClassNodes[dotCallType.UID].name;
ProtoCore.DSASM.ProcedureNode staticProcCallNode = compileStateTracker.ClassTable.ClassNodes[inferedType.UID].GetFirstStaticMemberFunction(procName);
if (null != staticProcCallNode)
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kMethodHasInvalidArguments, procName);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kCallingNonStaticMethodOnClass, message, compileStateTracker.CurrentDSFileName, dotCall.line, dotCall.col);
}
else if (CoreUtils.TryGetPropertyName(procName, out property))
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kCallingNonStaticProperty, property, className);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kCallingNonStaticMethodOnClass, message, compileStateTracker.CurrentDSFileName, dotCall.line, dotCall.col);
}
else
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kCallingNonStaticMethod, procName, className);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kCallingNonStaticMethodOnClass, message, compileStateTracker.CurrentDSFileName, dotCall.line, dotCall.col);
}
}
isUnresolvedMethod = true;
}
else
{
inferedType = procCallNode.returntype;
}
}
}
// Its an accceptable method at this point
if (!isUnresolvedMethod)
{
int funtionArgCount = 0;
//foreach (AssociativeNode paramNode in funcCall.FormalArguments)
for (int n = 0; n < funcCall.FormalArguments.Count; ++n)
{
AssociativeNode paramNode = funcCall.FormalArguments[n];
ProtoCore.Type paramType = new ProtoCore.Type();
paramType.UID = (int)ProtoCore.PrimitiveType.kTypeVoid;
paramType.IsIndexable = false;
emitReplicationGuide = false;
// If it's a binary node then continue type check, otherwise disable type check and just take the type of paramNode itself
// f(1+2.0) -> type check enabled - param is typed as double
// f(2) -> type check disabled - param is typed as int
enforceTypeCheck = !(paramNode is BinaryExpressionNode);
// TODO Jun: Cleansify me
// What im doing is just taking the second parameter of the dot op (The method call)
// ...and adding it to the graph node dependencies
if (ProtoCore.DSASM.Constants.kDotArgIndexDynTableIndex == n)
{
if (subPass != ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
if (!isConstructor)
{
if (null != procCallNode)
{
if (graphNode.dependentList.Count > 0)
{
ProtoCore.AssociativeGraph.UpdateNodeRef nodeRef = new ProtoCore.AssociativeGraph.UpdateNodeRef();
ProtoCore.AssociativeGraph.UpdateNode updateNode = new ProtoCore.AssociativeGraph.UpdateNode();
ProtoCore.DSASM.ProcedureNode procNodeDummy = new ProtoCore.DSASM.ProcedureNode();
if (procCallNode.isAutoGenerated)
{
ProtoCore.DSASM.SymbolNode sym = new ProtoCore.DSASM.SymbolNode();
sym.name = procName.Remove(0, ProtoCore.DSASM.Constants.kSetterPrefix.Length);
updateNode.nodeType = ProtoCore.AssociativeGraph.UpdateNodeType.kSymbol;
updateNode.symbol = sym;
}
else
{
procNodeDummy.name = procName;
updateNode.nodeType = ProtoCore.AssociativeGraph.UpdateNodeType.kMethod;
updateNode.procNode = procNodeDummy;
}
graphNode.dependentList[0].updateNodeRefList[0].nodeList.Add(updateNode);
}
}
else
{
// comment Jun:
// This is dotarg whos first argument is also a dotarg
// dotarg(dorarg...)...)
if (graphNode.dependentList.Count > 0)
{
if (ProtoCore.Utils.CoreUtils.IsGetterSetter(procName))
{
ProtoCore.AssociativeGraph.UpdateNode updateNode = new ProtoCore.AssociativeGraph.UpdateNode();
ProtoCore.DSASM.SymbolNode sym = new ProtoCore.DSASM.SymbolNode();
sym.name = procName.Remove(0, ProtoCore.DSASM.Constants.kSetterPrefix.Length);
updateNode.nodeType = ProtoCore.AssociativeGraph.UpdateNodeType.kSymbol;
updateNode.symbol = sym;
graphNode.dependentList[0].updateNodeRefList[0].nodeList.Add(updateNode);
}
}
}
}
}
}
// Traversing the first arg (the LHS pointer/Static instanct/Constructor
if (ProtoCore.DSASM.Constants.kDotArgIndexPtr == n)
{
// Comment Jun:
// Allow guides only on 'this' pointers for non getter/setter methods
// No guides for 'this' pointers in constructors calls (There is no this pointer yet)
//
/*
class C
{
def f(a : int)
{
return = 10;
}
}
p = {C.C(), C.C()};
x = p<1>.f({1,2}<2>); // guides allowed on the pointer 'p'
class A
{
x : var[];
constructor A()
{
x = {1,2};
}
}
a = A.A();
b = A.A();
c = a<1>.x<2>; // guides not allowed on getter
*/
if (!ProtoCore.Utils.CoreUtils.IsGetterSetter(procName) && !isConstructor)
{
emitReplicationGuide = true;
}
DfsTraverse(paramNode, ref paramType, false, graphNode, subPass, bnode);
if (subPass != ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
if (isStaticCall && isStaticCallAllowed)
{
Validity.Assert(ProtoCore.DSASM.Constants.kInvalidIndex != classIndex);
Validity.Assert(string.Empty != className);
SymbolNode classSymbol = new SymbolNode();
classSymbol.name = className;
classSymbol.classScope = classIndex;
ProtoCore.AssociativeGraph.GraphNode dependentNode = new ProtoCore.AssociativeGraph.GraphNode();
dependentNode.PushSymbolReference(classSymbol, ProtoCore.AssociativeGraph.UpdateNodeType.kSymbol);
graphNode.PushDependent(dependentNode);
}
}
}
// Traversing the actual arguments passed into the function (not the dot function)
else if (ProtoCore.DSASM.Constants.kDotArgIndexArrayArgs == n)
{
int defaultAdded = 0;
// If its null this is the second call in a chained dot
if (null != procCallNode)
{
// Check how many args were passed in.... against what is expected
defaultAdded = procCallNode.argInfoList.Count - dotCall.FunctionCall.FormalArguments.Count;
}
// Enable graphnode dependencies if its a setter method
bool allowDependentState = null != graphNode ? graphNode.allowDependents : false;
if (ProtoCore.Utils.CoreUtils.IsSetter(procName))
{
// If the arguments are not temporaries
ProtoCore.AST.AssociativeAST.ExprListNode exprList = paramNode as ExprListNode;
Validity.Assert(1 == exprList.list.Count);
string varname = string.Empty;
if (exprList.list[0] is IdentifierNode)
{
varname = (exprList.list[0] as IdentifierNode).Name;
// Only allow the acutal function variables and SSA temp vars
// TODO Jun: determine what temp could be passed in that is autodegenerated and non-SSA
if (!ProtoCore.Utils.CoreUtils.IsAutoGeneratedVar(varname)
|| ProtoCore.Utils.CoreUtils.IsSSATemp(varname))
{
graphNode.allowDependents = true;
}
}
else
{
graphNode.allowDependents = true;
}
}
emitReplicationGuide = true;
if (defaultAdded > 0)
{
ProtoCore.AST.AssociativeAST.ExprListNode exprList = paramNode as ExprListNode;
if (subPass != AssociativeSubCompilePass.kUnboundIdentifier)
{
for (int i = 0; i < defaultAdded; i++)
{
exprList.list.Add(new DefaultArgNode());
}
}
DfsTraverse(paramNode, ref paramType, false, graphNode, subPass);
funtionArgCount = exprList.list.Count;
}
else
{
Validity.Assert(paramNode is ProtoCore.AST.AssociativeAST.ExprListNode);
ProtoCore.AST.AssociativeAST.ExprListNode exprList = paramNode as ProtoCore.AST.AssociativeAST.ExprListNode;
// Comment Jun: This is a getter/setter or a an auto-generated thisarg function...
// ...add the dynamic sv that will be resolved as a pointer at runtime
if (!isStaticCall && !isConstructor)
{
//if (null != procCallNode && ProtoCore.Utils.CoreUtils.IsGetterSetter(procCallNode.name) && AssociativeSubCompilePass.kNone == subPass)
// TODO Jun: pls get rid of subPass checking outside the core travesal
if (ProtoCore.DSASM.AssociativeSubCompilePass.kNone == subPass)
{
exprList.list.Insert(0, new DynamicNode());
}
}
if (exprList.list.Count > 0)
{
foreach (ProtoCore.AST.AssociativeAST.AssociativeNode exprListNode in exprList.list)
{
bool repGuideState = emitReplicationGuide;
if (subPass != ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
if (exprListNode is ProtoCore.AST.AssociativeAST.ExprListNode
|| exprListNode is ProtoCore.AST.AssociativeAST.GroupExpressionNode)
{
if (compileStateTracker.Options.TempReplicationGuideEmptyFlag)
{
// Emit the replication guide for the exprlist
List<ProtoCore.AST.AssociativeAST.AssociativeNode> repGuideList = GetReplicationGuides(exprListNode);
EmitReplicationGuides(repGuideList, true);
emitReplicationGuide = false;
// Pop off the guide if the current element was an array
if (null != repGuideList)
{
EmitInstrConsole(ProtoCore.DSASM.kw.popg);
EmitPopGuide();
}
}
}
}
else
{
emitReplicationGuide = false;
}
DfsTraverse(exprListNode, ref paramType, false, graphNode, subPass, bnode);
emitReplicationGuide = repGuideState;
}
if (subPass != ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
EmitInstrConsole(ProtoCore.DSASM.kw.alloca, exprList.list.Count.ToString());
EmitPopArray(exprList.list.Count);
if (exprList.ArrayDimensions != null)
{
int dimensions = DfsEmitArrayIndexHeap(exprList.ArrayDimensions, graphNode);
EmitInstrConsole(ProtoCore.DSASM.kw.pushindex, dimensions.ToString() + "[dim]");
EmitPushArrayIndex(dimensions);
}
}
}
else
{
if (exprList != null)
{
bool emitReplicationGuideState = emitReplicationGuide;
emitReplicationGuide = false;
DfsTraverse(paramNode, ref paramType, false, graphNode, subPass);
emitReplicationGuide = emitReplicationGuideState;
}
else
{
DfsTraverse(paramNode, ref paramType, false, graphNode, subPass);
}
}
funtionArgCount = exprList.list.Count;
}
emitReplicationGuide = false;
// Restore the state only if it is a setter method
if (ProtoCore.Utils.CoreUtils.IsSetter(procName))
{
graphNode.allowDependents = allowDependentState;
}
}
else if (ProtoCore.DSASM.Constants.kDotArgIndexArgCount == n)
{
ProtoCore.AST.AssociativeAST.IntNode argNumNode = new ProtoCore.AST.AssociativeAST.IntNode() { value = funtionArgCount.ToString() };
DfsTraverse(argNumNode, ref paramType, false, graphNode, subPass);
}
else
{
DfsTraverse(paramNode, ref paramType, false, graphNode, subPass);
}
emitReplicationGuide = false;
enforceTypeCheck = true;
arglist.Add(paramType);
}
}
if (subPass == ProtoCore.DSASM.AssociativeSubCompilePass.kUnboundIdentifier)
{
return null;
}
// Comment Jun: Append the lhs pointer as an argument to the overloaded function
if (!isConstructor && !isStaticCall)
{
Validity.Assert(dotCall.DotCall.FormalArguments[ProtoCore.DSASM.Constants.kDotArgIndexArrayArgs] is ExprListNode);
ExprListNode functionArgs = dotCall.DotCall.FormalArguments[ProtoCore.DSASM.Constants.kDotArgIndexArrayArgs] as ExprListNode;
functionArgs.list.Insert(0, dotCall.DotCall.FormalArguments[ProtoCore.DSASM.Constants.kDotArgIndexPtr]);
}
if (isUnresolvedMethod)
{
EmitNullNode(new NullNode(), ref inferedType);
return null;
}
procDotCallNode = compileStateTracker.GetFirstVisibleProcedure(ProtoCore.DSASM.Constants.kDotArgMethodName, arglist, codeBlock);
// From here on, handle the actual procedure call
int type = ProtoCore.DSASM.Constants.kInvalidIndex;
int refClassIndex = ProtoCore.DSASM.Constants.kInvalidIndex;
if (parentNode != null && parentNode is ProtoCore.AST.AssociativeAST.IdentifierListNode)
{
ProtoCore.AST.Node leftnode = (parentNode as ProtoCore.AST.AssociativeAST.IdentifierListNode).LeftNode;
if (leftnode != null && leftnode is ProtoCore.AST.AssociativeAST.IdentifierNode)
{
refClassIndex = compileStateTracker.ClassTable.IndexOf(leftnode.Name);
}
}
if (dotCallFirstArgument is FunctionCallNode ||
dotCallFirstArgument is FunctionDotCallNode ||
dotCallFirstArgument is ExprListNode)
{
inferedType.UID = arglist[0].UID;
}
// If lefttype is a valid class then check if calling a constructor
if ((int)ProtoCore.PrimitiveType.kInvalidType != inferedType.UID
&& (int)ProtoCore.PrimitiveType.kTypeVoid != inferedType.UID
&& procName != ProtoCore.DSASM.Constants.kFunctionPointerCall)
{
bool isStaticOrConstructor = refClassIndex != ProtoCore.DSASM.Constants.kInvalidIndex;
procCallNode = compileStateTracker.ClassTable.ClassNodes[inferedType.UID].GetFirstMemberFunction(procName);
}
// Try function pointer firstly
if ((procCallNode == null) && (procName != ProtoCore.DSASM.Constants.kFunctionPointerCall))
{
bool isAccessibleFp;
ProtoCore.DSASM.SymbolNode symbolnode = null;
bool isAllocated = VerifyAllocation(procName, globalClassIndex, globalProcIndex, out symbolnode, out isAccessibleFp);
if (isAllocated) // not checking the type against function pointer, as the type could be var
{
procName = ProtoCore.DSASM.Constants.kFunctionPointerCall;
// The graph node always depends on this function pointer
if (null != graphNode)
{
ProtoCore.AssociativeGraph.GraphNode dependentNode = new ProtoCore.AssociativeGraph.GraphNode();
dependentNode.PushSymbolReference(symbolnode);
graphNode.PushDependent(dependentNode);
}
}
}
// Always try global function firstly. Because we dont have syntax
// support for calling global function (say, ::foo()), if we try
// member function firstly, there is no way to call a global function
// For member function, we can use this.foo() to distinguish it from
// global function.
if ((procCallNode == null) && (procName != ProtoCore.DSASM.Constants.kFunctionPointerCall))
{
procCallNode = compileStateTracker.GetFirstVisibleProcedure(procName, arglist, codeBlock);
if (null != procCallNode)
{
type = ProtoCore.DSASM.Constants.kGlobalScope;
if (compileStateTracker.TypeSystem.IsHigherRank(procCallNode.returntype.UID, inferedType.UID))
{
inferedType = procCallNode.returntype;
}
}
}
// Try member functions in global class scope
if ((procCallNode == null) && (procName != ProtoCore.DSASM.Constants.kFunctionPointerCall) && (parentNode == null))
{
if (globalClassIndex != ProtoCore.DSASM.Constants.kInvalidIndex)
{
int realType;
bool isAccessible;
bool isStaticOrConstructor = refClassIndex != ProtoCore.DSASM.Constants.kInvalidIndex;
ProtoCore.DSASM.ProcedureNode memProcNode = compileStateTracker.ClassTable.ClassNodes[globalClassIndex].GetMemberFunction(procName, arglist, globalClassIndex, out isAccessible, out realType, isStaticOrConstructor);
if (memProcNode != null)
{
Debug.Assert(realType != ProtoCore.DSASM.Constants.kInvalidIndex);
procCallNode = memProcNode;
inferedType = procCallNode.returntype;
type = realType;
if (!isAccessible)
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kMethodIsInaccessible, procName);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kAccessViolation, message, compileStateTracker.CurrentDSFileName, funcCall.line, funcCall.col);
inferedType.UID = (int)PrimitiveType.kTypeNull;
EmitPushNull();
return procCallNode;
}
}
}
}
if (isUnresolvedDot)
{
// Get the dot call procedure
ProtoCore.DSASM.ProcedureNode procNode = procDotCallNode;
if (!isConstructor && !isStaticCall)
{
procNode = compileStateTracker.GetFirstVisibleProcedure(ProtoCore.DSASM.Constants.kDotMethodName, null, codeBlock);
}
if(CoreUtils.IsGetter(procName))
{
EmitFunctionCall(depth, type, arglist, procNode, funcCall, true);
}
else
EmitFunctionCall(depth, type, arglist, procNode, funcCall, false, bnode);
if (dotCallType.UID != (int)PrimitiveType.kTypeVar)
{
inferedType.UID = dotCallType.UID;
}
return procCallNode;
}
if (null != procCallNode)
{
if (procCallNode.isConstructor &&
(globalClassIndex != ProtoCore.DSASM.Constants.kInvalidIndex) &&
(globalProcIndex != ProtoCore.DSASM.Constants.kInvalidIndex) &&
(globalClassIndex == inferedType.UID))
{
ProtoCore.DSASM.ProcedureNode contextProcNode = compileStateTracker.ClassTable.ClassNodes[globalClassIndex].vtable.procList[globalProcIndex];
if (contextProcNode.isConstructor &&
string.Equals(contextProcNode.name, procCallNode.name) &&
contextProcNode.runtimeIndex == procCallNode.runtimeIndex)
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kCallingConstructorInConstructor, procName);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kCallingConstructorInConstructor, message, compileStateTracker.CurrentDSFileName, node.line, node.col);
inferedType.UID = (int)PrimitiveType.kTypeNull;
EmitPushNull();
return procCallNode;
}
}
inferedType = procCallNode.returntype;
//if call is replication call
if (procCallNode.isThisCallReplication)
{
inferedType.IsIndexable = true;
inferedType.rank++;
}
// Get the dot call procedure
ProtoCore.DSASM.ProcedureNode procNode = procDotCallNode;
if (!isConstructor && !isStaticCall)
{
procNode = compileStateTracker.GetFirstVisibleProcedure(ProtoCore.DSASM.Constants.kDotMethodName, null, codeBlock);
}
if (CoreUtils.IsSetter(procName))
{
EmitFunctionCall(depth, type, arglist, procNode, funcCall);
}
// Do not emit breakpoint at getters only - pratapa
else if (CoreUtils.IsGetter(procName))
{
EmitFunctionCall(depth, type, arglist, procNode, funcCall, true);
}
else
{
EmitFunctionCall(depth, type, arglist, procNode, funcCall, false, bnode);
}
if (dotCallType.UID != (int)PrimitiveType.kTypeVar)
{
inferedType.UID = dotCallType.UID;
}
if (isConstructor)
{
foreach (AssociativeNode paramNode in dotCall.FunctionCall.FormalArguments)
{
// Get the lhs symbol list
ProtoCore.Type ltype = new ProtoCore.Type();
ltype.UID = globalClassIndex;
ProtoCore.AssociativeGraph.UpdateNodeRef argNodeRef = new ProtoCore.AssociativeGraph.UpdateNodeRef();
DFSGetSymbolList(paramNode, ref ltype, argNodeRef);
if (null != graphNode)
{
graphNode.updatedArguments.Add(argNodeRef);
}
}
graphNode.firstProc = procCallNode;
}
return procCallNode;
}
else
{
// Function does not exist at this point but we try to reolve at runtime
if (depth <= 0 && procName != ProtoCore.DSASM.Constants.kFunctionPointerCall)
{
if (inferedType.UID != (int)PrimitiveType.kTypeVar)
{
if (!compileStateTracker.Options.SuppressFunctionResolutionWarning)
{
string property;
if (CoreUtils.TryGetPropertyName(procName, out property))
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kPropertyNotFound, property);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kPropertyNotFound, message, compileStateTracker.CurrentDSFileName, funcCall.line, funcCall.col);
}
else
{
string message = String.Format(ProtoCore.BuildData.WarningMessage.kMethodNotFound, procName);
buildStatus.LogWarning(ProtoCore.BuildData.WarningID.kFunctionNotFound, message, compileStateTracker.CurrentDSFileName, funcCall.line, funcCall.col);
}
}
inferedType.UID = (int)PrimitiveType.kTypeNull;
}
// Get the dot call procedure
ProtoCore.DSASM.ProcedureNode procNode = procDotCallNode;
if (!isConstructor && !isStaticCall)
{
procNode = compileStateTracker.GetFirstVisibleProcedure(ProtoCore.DSASM.Constants.kDotMethodName, null, codeBlock);
}
if (CoreUtils.IsGetter(procName))
{
EmitFunctionCall(depth, type, arglist, procNode, funcCall, true);
}
else
EmitFunctionCall(depth, type, arglist, procNode, funcCall, false, bnode);
if (dotCallType.UID != (int)PrimitiveType.kTypeVar)
{
inferedType.UID = dotCallType.UID;
}
}
else
{
if (procName == ProtoCore.DSASM.Constants.kFunctionPointerCall && depth == 0)
{
ProtoCore.DSASM.DynamicFunctionNode dynamicFunctionNode = new ProtoCore.DSASM.DynamicFunctionNode(procName, arglist, lefttype);
compileStateTracker.DynamicFunctionTable.functionTable.Add(dynamicFunctionNode);
var iNode = nodeBuilder.BuildIdentfier(funcCall.Function.Name);
EmitIdentifierNode(iNode, ref inferedType);
}
else
{
ProtoCore.DSASM.DynamicFunctionNode dynamicFunctionNode = new ProtoCore.DSASM.DynamicFunctionNode(funcCall.Function.Name, arglist, lefttype);
compileStateTracker.DynamicFunctionTable.functionTable.Add(dynamicFunctionNode);
}
// The function call
EmitInstrConsole(ProtoCore.DSASM.kw.callr, funcCall.Function.Name + "[dynamic]");
EmitDynamicCall(compileStateTracker.DynamicFunctionTable.functionTable.Count - 1, globalClassIndex, depth, funcCall.line, funcCall.col, funcCall.endLine, funcCall.endCol);
// The function return value
EmitInstrConsole(ProtoCore.DSASM.kw.push, ProtoCore.DSASM.kw.regRX);
ProtoCore.DSASM.StackValue opReturn = new ProtoCore.DSASM.StackValue();
opReturn.optype = ProtoCore.DSASM.AddressType.Register;
opReturn.opdata = (int)ProtoCore.DSASM.Registers.RX;
EmitPush(opReturn);
if (compileStateTracker.Options.TempReplicationGuideEmptyFlag && emitReplicationGuide)
{
int guides = EmitReplicationGuides(replicationGuide);
EmitInstrConsole(ProtoCore.DSASM.kw.pushindex, guides + "[guide]");
EmitPushReplicationGuide(guides);
}
//assign inferedType to var
inferedType.UID = (int)PrimitiveType.kTypeVar;
}
}
return procDotCallNode;
}
public IntNode(IntNode rhs) : base(rhs)
{
value = rhs.value;
}
private void EmitRangeExprNode(AssociativeNode node,
ref ProtoCore.Type inferedType,
GraphNode graphNode = null,
ProtoCore.CompilerDefinitions.Associative.SubCompilePass subPass = ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kNone)
{
RangeExprNode range = node as RangeExprNode;
// Do some static checking...
var fromNode = range.From;
var toNode = range.To;
var stepNode = range.Step;
var stepOp = range.StepOperator;
var hasAmountOperator = range.HasRangeAmountOperator;
bool isStepValid = true;
string warningMsg = string.Empty;
if ((fromNode is IntNode || fromNode is DoubleNode) &&
(toNode is IntNode || toNode is DoubleNode) &&
(stepNode == null || stepNode is IntNode || stepNode is DoubleNode))
{
double current = (fromNode is IntNode) ?
(fromNode as IntNode).Value : (fromNode as DoubleNode).Value;
double end = (toNode is IntNode) ?
(toNode as IntNode).Value : (toNode as DoubleNode).Value;
double step = 1;
if (stepNode != null)
{
step = (stepNode is IntNode) ?
(stepNode as IntNode).Value : (stepNode as DoubleNode).Value;
}
switch (stepOp)
{
case ProtoCore.DSASM.RangeStepOperator.StepSize:
if (!hasAmountOperator)
{
if (stepNode == null && end < current)
{
step = -1;
}
if (step == 0)
{
isStepValid = false;
warningMsg = ProtoCore.Properties.Resources.kRangeExpressionWithStepSizeZero;
}
else if ((end > current && step < 0) || (end < current && step > 0))
{
isStepValid = false;
warningMsg = ProtoCore.Properties.Resources.kRangeExpressionWithInvalidStepSize;
}
}
break;
case ProtoCore.DSASM.RangeStepOperator.Number:
if (hasAmountOperator)
{
isStepValid = false;
warningMsg = ProtoCore.Properties.Resources.kRangeExpressionWithStepSizeZero;
}
else
{
if (stepNode != null && stepNode is DoubleNode &&
subPass == ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kNone)
{
buildStatus.LogWarning(WarningID.kInvalidRangeExpression,
ProtoCore.Properties.Resources.kRangeExpressionWithNonIntegerStepNumber,
core.CurrentDSFileName,
stepNode.line,
stepNode.col,
graphNode);
}
else if (step <= 0)
{
isStepValid = false;
warningMsg = ProtoCore.Properties.Resources.kRangeExpressionWithNegativeStepNumber;
}
}
break;
case ProtoCore.DSASM.RangeStepOperator.ApproximateSize:
if (hasAmountOperator)
{
isStepValid = false;
warningMsg = ProtoCore.Properties.Resources.kRangeExpressionConflictOperator;
}
else if (step == 0)
{
isStepValid = false;
warningMsg = ProtoCore.Properties.Resources.kRangeExpressionWithStepSizeZero;
}
break;
default:
break;
}
}
if (!isStepValid && subPass == ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kNone)
{
buildStatus.LogWarning(WarningID.kInvalidRangeExpression,
warningMsg,
core.CurrentDSFileName,
stepNode.line,
stepNode.col,
graphNode);
EmitNullNode(new NullNode(), ref inferedType);
return;
}
// Replace with build-in RangeExpression() function. - Yu Ke
bool emitReplicationgGuideState = emitReplicationGuide;
emitReplicationGuide = false;
IntNode op = null;
switch (stepOp)
{
case RangeStepOperator.StepSize:
op = new IntNode(0);
break;
case RangeStepOperator.Number:
op = new IntNode(1);
break;
case RangeStepOperator.ApproximateSize:
op = new IntNode(2);
break;
default:
op = new IntNode(-1);
break;
}
var arguments = new List<AssociativeNode>
{
fromNode,
toNode,
stepNode ?? new NullNode(),
op,
AstFactory.BuildBooleanNode(stepNode != null),
AstFactory.BuildBooleanNode(hasAmountOperator),
};
var rangeExprFunc = AstFactory.BuildFunctionCall(Constants.kFunctionRangeExpression,
arguments);
EmitFunctionCallNode(rangeExprFunc, ref inferedType, false, graphNode, subPass);
emitReplicationGuide = emitReplicationgGuideState;
if (subPass != ProtoCore.CompilerDefinitions.Associative.SubCompilePass.kUnboundIdentifier)
{
if (range.ArrayDimensions != null)
{
int dim = DfsEmitArrayIndexHeap(range.ArrayDimensions, graphNode);
EmitInstrConsole(kw.pushindex, dim + "[dim]");
EmitPushArrayIndex(dim);
}
if (emitReplicationGuide)
{
EmitAtLevel(range.AtLevel);
EmitReplicationGuides(range.ReplicationGuides);
}
}
}
public void TestTypeSwitch()
{
object v = null;
object node = null;
DoubleNode doubleNode = new DoubleNode(1.2);
node = doubleNode;
TypeSwitch.Do(
node,
TypeSwitch.Case<IntNode>(n => v = n.Value),
TypeSwitch.Case<DoubleNode>(n => v = n.Value),
TypeSwitch.Case<BooleanNode>(n => v = n.Value),
TypeSwitch.Case<StringNode>(n => v = n.Value),
TypeSwitch.Default(() => v = null));
Assert.AreEqual(v, 1.2);
IntNode intNode = new IntNode(42);
node = intNode;
TypeSwitch.Do(
node,
TypeSwitch.Case<IntNode>(n => v = n.Value),
TypeSwitch.Case<DoubleNode>(n => v = n.Value),
TypeSwitch.Case<BooleanNode>(n => v = n.Value),
TypeSwitch.Case<StringNode>(n => v = n.Value),
TypeSwitch.Default(() => v = null));
Assert.AreEqual(v, 42);
StringNode sNode = new StringNode();
node = sNode;
TypeSwitch.Do(
node,
TypeSwitch.Case<IntNode>(n => v = n.Value),
TypeSwitch.Case<DoubleNode>(n => v = n.Value),
TypeSwitch.Case<BooleanNode>(n => v = n.Value),
TypeSwitch.Default(() => v = 24));
Assert.AreEqual(v, 24);
}
public static ProtoCore.AST.AssociativeAST.FunctionDotCallNode GenerateCallDotNode(ProtoCore.AST.AssociativeAST.AssociativeNode lhs,
ProtoCore.AST.AssociativeAST.FunctionCallNode rhsCall, Core core = null)
{
// The function name to call
string rhsName = rhsCall.Function.Name;
int argNum = rhsCall.FormalArguments.Count;
ProtoCore.AST.AssociativeAST.ExprListNode argList = new ProtoCore.AST.AssociativeAST.ExprListNode();
foreach (ProtoCore.AST.AssociativeAST.AssociativeNode arg in rhsCall.FormalArguments)
{
// The function arguments
argList.list.Add(arg);
}
FunctionCallNode funCallNode = new FunctionCallNode();
IdentifierNode funcName = new IdentifierNode { Value = Constants.kDotArgMethodName, Name = Constants.kDotArgMethodName };
funCallNode.Function = funcName;
funCallNode.Name = Constants.kDotArgMethodName;
NodeUtils.CopyNodeLocation(funCallNode, lhs);
int rhsIdx = ProtoCore.DSASM.Constants.kInvalidIndex;
string lhsName = string.Empty;
if (lhs is ProtoCore.AST.AssociativeAST.IdentifierNode)
{
lhsName = (lhs as ProtoCore.AST.AssociativeAST.IdentifierNode).Name;
if (lhsName == ProtoCore.DSDefinitions.Keyword.This)
{
lhs = new ProtoCore.AST.AssociativeAST.ThisPointerNode();
}
}
if (core != null)
{
DynamicFunction func;
if (core.DynamicFunctionTable.TryGetFunction(rhsName, 0, Constants.kInvalidIndex, out func))
{
rhsIdx = func.Index;
}
else
{
func = core.DynamicFunctionTable.AddNewFunction(rhsName, 0, Constants.kInvalidIndex);
rhsIdx = func.Index;
}
}
// The first param to the dot arg (the pointer or the class name)
funCallNode.FormalArguments.Add(lhs);
// The second param which is the dynamic table index of the function to call
var rhs = new IntNode(rhsIdx);
funCallNode.FormalArguments.Add(rhs);
// The array dimensions
ProtoCore.AST.AssociativeAST.ExprListNode arrayDimExperList = new ProtoCore.AST.AssociativeAST.ExprListNode();
int dimCount = 0;
if (rhsCall.Function is ProtoCore.AST.AssociativeAST.IdentifierNode)
{
// Number of dimensions
ProtoCore.AST.AssociativeAST.IdentifierNode fIdent = rhsCall.Function as ProtoCore.AST.AssociativeAST.IdentifierNode;
if (fIdent.ArrayDimensions != null)
{
arrayDimExperList = ProtoCore.Utils.CoreUtils.BuildArrayExprList(fIdent.ArrayDimensions);
dimCount = arrayDimExperList.list.Count;
}
else if (rhsCall.ArrayDimensions != null)
{
arrayDimExperList = ProtoCore.Utils.CoreUtils.BuildArrayExprList(rhsCall.ArrayDimensions);
dimCount = arrayDimExperList.list.Count;
}
else
{
arrayDimExperList = new ProtoCore.AST.AssociativeAST.ExprListNode();
}
}
funCallNode.FormalArguments.Add(arrayDimExperList);
// Number of dimensions
var dimNode = new IntNode(dimCount);
funCallNode.FormalArguments.Add(dimNode);
if (argNum >= 0)
{
funCallNode.FormalArguments.Add(argList);
funCallNode.FormalArguments.Add(new IntNode(argNum));
}
var funDotCallNode = new FunctionDotCallNode(rhsCall);
funDotCallNode.DotCall = funCallNode;
funDotCallNode.FunctionCall.Function = rhsCall.Function;
// Consider the case of "myClass.Foo(a, b)", we will have "DotCall" being
// equal to "myClass" (in terms of its starting line/column), and "rhsCall"
// matching with the location of "Foo(a, b)". For execution cursor to cover
// this whole statement, the final "DotCall" function call node should
// range from "lhs.col" to "rhs.col".
//
NodeUtils.SetNodeEndLocation(funDotCallNode.DotCall, rhsCall);
NodeUtils.CopyNodeLocation(funDotCallNode, funDotCallNode.DotCall);
return funDotCallNode;
}
void Associative_Level(out ProtoCore.AST.AssociativeAST.AssociativeNode node) {
node = null;
int sign = 1;
if (la.kind == 1) {
Get();
if(t.val[0] != 'L')
{
errors.SemErr(t.line, t.col, String.Format(Resources.kInvalidListLevelName, t.val));
}
var level = t.val.Remove(0, 1);
Int64 value;
if (Int64.TryParse(level, System.Globalization.NumberStyles.Number, System.Globalization.CultureInfo.InvariantCulture, out value))
{
node = new ProtoCore.AST.AssociativeAST.IntNode(-1*value);
}
else
{
errors.SemErr(t.line, t.col, String.Format(Resources.kInvalidListLevelName, t.val));
}
NodeUtils.SetNodeLocation(node, t);
} else if (la.kind == 2 || la.kind == 15) {
if (la.kind == 15) {
Get();
sign = -1;
}
Expect(2);
Int64 value;
if (Int64.TryParse(t.val, System.Globalization.NumberStyles.Number, System.Globalization.CultureInfo.InvariantCulture, out value))
{
node = new ProtoCore.AST.AssociativeAST.IntNode(sign*value);
}
else
{
errors.SemErr(t.line, t.col, String.Format(Resources.kInvalidListLevelName, t.val));
}
NodeUtils.SetNodeLocation(node, t);
} else SynErr(90);
}
