本文整理汇总了C#中ProtoCore.AST.AssociativeAST.IntNode类的典型用法代码示例。如果您正苦于以下问题：C# IntNode类的具体用法？C# IntNode怎么用？C# IntNode使用的例子？那么, 这里精选的类代码示例或许可以为您提供帮助。
IntNode类属于ProtoCore.AST.AssociativeAST命名空间，在下文中一共展示了IntNode类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: BuildOutputAst
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)
};
}示例2: BuildOutputAst
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
})
};
}示例3: BuildOutputAst
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))
};
}
}示例4: BuildOutputAst
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)
};
}示例5: GetStatementVariables01
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));
}示例6: Associative_Number
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);
}示例7: EmitLiteralNode
/// <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);
}示例8: TraverseDotCallArguments
//.........这里部分代码省略.........
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);
}
}
}示例9: EmitRangeExprNode
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)
{
//.........这里部分代码省略.........
示例10: CreateFunctionObject
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);
}示例11: Associative_Number
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);
}示例12: RangeExprNode
public RangeExprNode()
{
IntNode defaultStep = new IntNode();
defaultStep.value = "1";
StepNode = defaultStep;
}示例13: GenerateCallDotNode
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;
}示例14: EmitRangeExprNode
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;
//.........这里部分代码省略.........
示例15: IntNode
public IntNode(IntNode rhs) : base(rhs)
{
value = rhs.value;
}