コード例 #1
0
 internal StaticVariablePoint(StaticVarDecl staticVarDecl, LValuePoint variable, VariableName variableName, ValuePoint initializer)
 {
     StaticVarDecl = staticVarDecl;
     _variable     = variable;
     _initializer  = initializer;
     _variableName = variableName;
 }
コード例 #2
0
 /// <summary>
 /// Initializes a new instance of the <see cref="IndirectFunctionCallPoint" /> class.
 /// </summary>
 /// <param name="functionCall">Indirect function call expression</param>
 /// <param name="name">Indirect name of call</param>
 /// <param name="thisObj">Program point with an object if the indirect subroutine is method</param>
 /// <param name="arguments">Program points with arguments of function call</param>
 internal IndirectFunctionCallPoint(IndirectFcnCall functionCall, ValuePoint name,
                                    ValuePoint thisObj, ValuePoint[] arguments)
     : base(thisObj, functionCall.CallSignature, arguments)
 {
     FunctionCall = functionCall;
     Name         = name;
 }
コード例 #3
0
 internal ForeachStmtPoint(ForeachStmt foreachStmt, ValuePoint enumeree, LValuePoint keyVar, LValuePoint valVar)
 {
     Foreach  = foreachStmt;
     KeyVar   = keyVar;
     ValVar   = valVar;
     Enumeree = enumeree;
 }
コード例 #4
0
 /// <summary>
 /// Initializes a new instance of the <see cref="IndirectStaticMethodCallPoint" /> class.
 /// </summary>
 /// <param name="staticMethodCall">Indirect static method call expression</param>
 /// <param name="name">Indirect name of call</param>
 /// <param name="arguments">Program points with arguments of static method call</param>\
 /// <param name="objectName">Name of called object</param>
 internal IndirectStaticMethodCallPoint(IndirectStMtdCall staticMethodCall, ValuePoint objectName, ValuePoint name,
                                        ValuePoint[] arguments)
     : base(objectName, staticMethodCall.CallSignature, arguments)
 {
     StaticMethodCall = staticMethodCall;
     Name             = name;
 }
コード例 #5
0
        /// <summary>
        /// Initializes a new instance of the <see cref="BinaryExPoint" /> class.
        /// </summary>
        /// <param name="expression">Conditional expression</param>
        /// <param name="condition">Condition determining whether true or false, or merge will be used</param>
        /// <param name="trueAssume">Assume point for true binary operand </param>
        /// <param name="falseAssume">Assume point for false binary operand </param>
        /// <param name="trueOperand">True operand</param>
        /// <param name="falseOperand">False operand</param>
        internal ConditionalExPoint(ConditionalEx expression, ValuePoint condition, AssumePoint trueAssume, AssumePoint falseAssume, ValuePoint trueOperand, ValuePoint falseOperand)
        {
            Expression  = expression;
            Condition   = condition;
            TrueAssume  = trueAssume;
            FalseAssume = falseAssume;

            TrueOperand  = trueOperand;
            FalseOperand = falseOperand;
        }
コード例 #6
0
        /// <summary>
        /// Initializes a new instance of the <see cref="IncDecExPoint" /> class.
        /// </summary>
        /// <param name="incDecEx">Post/pre increment or decrement expression</param>
        /// <param name="incrementedValue">Program point with increment or decrement expression</param>
        internal IncDecExPoint(IncDecEx incDecEx, ValuePoint incrementedValue)
        {
            IncDecEx         = incDecEx;
            IncrementedValue = incrementedValue;
            IncrementTarget  = incrementedValue as LValuePoint;

            if (IncrementTarget == null)
            {
                throw new NotSupportedException("Given incrementedValue doesn't support incrementation");
            }
        }
コード例 #7
0
        internal AssignOperationPoint(ValueAssignEx assign, LValuePoint lOperand, ValuePoint rOperand)
        {
            LOperand = lOperand;
            ROperand = rOperand;
            Assign   = assign;

            AssignTarget = lOperand as LValuePoint;
            if (AssignTarget == null)
            {
                throw new NotSupportedException("Given lOperand cannot be used ass assign target");
            }
        }
コード例 #8
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ExitExPoint" /> class.
 /// </summary>
 /// <param name="exitEx"><c>exit</c> expression</param>
 /// <param name="resultExpression">Program point with exit status</param>
 internal ExitExPoint(ExitEx exitEx, ValuePoint resultExpression)
 {
     Exit             = exitEx;
     ResultExpression = resultExpression;
 }
コード例 #9
0
 /// <summary>
 /// Initializes a new instance of the <see cref="InstanceOfExPoint" /> class.
 /// </summary>
 /// <param name="instanceOfEx"><c>instanceof</c> expression</param>
 /// <param name="expression">Program points with expression to be determined of inheritance</param>
 /// <param name="name">Program point with expression that represents type name</param>
 internal InstanceOfExPoint(InstanceOfEx instanceOfEx, ValuePoint expression, ValuePoint name)
 {
     Expression   = expression;
     Name         = name;
     InstanceOfEx = instanceOfEx;
 }
コード例 #10
0
 /// <summary>
 /// Initializes a new instance of the <see cref="NewExPoint" /> class.
 /// </summary>
 /// <param name="newEx"><c>new</c> expression</param>
 /// <param name="name">Program point with expression that represents type name</param>
 /// <param name="arguments">Program points with arguments of the object constructor</param>
 internal NewExPoint(NewEx newEx, ValuePoint name, ValuePoint[] arguments)
     : base(null, newEx.CallSignature, arguments)
 {
     Name  = name;
     NewEx = newEx;
 }
コード例 #11
0
 internal StaticFieldPoint(DirectStFldUse field, ValuePoint typeName)
 {
     Field     = field;
     FieldName = new VariableIdentifier(field.PropertyName);
     Self      = typeName;
 }
コード例 #12
0
 internal JumpStmtPoint(ValuePoint expression, JumpStmt jmp)
 {
     Jump       = jmp;
     Expression = expression;
 }
コード例 #13
0
 internal VariablePoint(DirectVarUse variable, ValuePoint thisObj)
 {
     Variable     = variable;
     VariableName = new VariableIdentifier(Variable.VarName);
     ThisObj      = thisObj;
 }
コード例 #14
0
 /// <summary>
 /// Initializes a new instance of the <see cref="BinaryExPoint" /> class.
 /// </summary>
 /// <param name="expression">Binary expression</param>
 /// <param name="lOperand">Program point with left binary operand</param>
 /// <param name="rOperand">Program point with right binary operand</param>
 internal BinaryExPoint(BinaryEx expression, ValuePoint lOperand, ValuePoint rOperand)
 {
     Expression   = expression;
     LeftOperand  = lOperand;
     RightOperand = rOperand;
 }
コード例 #15
0
 /// <summary>
 /// Initializes a new instance of the <see cref="UnaryExPoint" /> class.
 /// </summary>
 /// <param name="expression">Unary expression</param>
 /// <param name="operand">Program point with unary operand</param>
 internal UnaryExPoint(UnaryEx expression, ValuePoint operand)
 {
     Expression = expression;
     Operand    = operand;
 }
コード例 #16
0
 internal ItemUsePoint(ItemUse itemUse, ValuePoint usedItem, ValuePoint index)
 {
     ItemUse  = itemUse;
     UsedItem = usedItem;
     Index    = index;
 }
コード例 #17
0
 internal AssignPoint(ValueAssignEx assign, LValuePoint lOperand, ValuePoint rOperand)
 {
     LOperand = lOperand;
     ROperand = rOperand;
     Assign   = assign;
 }
コード例 #18
0
 internal AssignListPoint(ListEx listElement, List <LValuePoint> lOperands, ValuePoint rOperand)
 {
     LOperands   = lOperands;
     ROperand    = rOperand;
     ListElement = listElement;
 }
コード例 #19
0
 internal RCallPoint(ValuePoint thisObj, CallSignature?callSignature, ValuePoint[] arguments)
 {
     CallSignature = callSignature;
     ThisObj       = thisObj;
     _arguments    = arguments;
 }
コード例 #20
0
 internal IndirectVariablePoint(IndirectVarUse variable, ValuePoint variableName, ValuePoint thisObj)
 {
     Variable     = variable;
     VariableName = variableName;
     ThisObj      = thisObj;
 }
コード例 #21
0
 /// <summary>
 /// Visits the L value program point.
 /// </summary>
 /// <param name="p">Visited point</param>
 public virtual void VisitLValue(ValuePoint p)
 {
     VisitValue(p);
 }
コード例 #22
0
 /// <summary>
 /// Initializes a new instance of the <see cref="FunctionCallPoint" /> class.
 /// </summary>
 /// <param name="functionCall">Function call expression</param>
 /// <param name="thisObj">Program point with an object if the subroutine is method</param>
 /// <param name="arguments">Program points with arguments of function call</param>
 internal FunctionCallPoint(DirectFcnCall functionCall, ValuePoint thisObj, ValuePoint[] arguments)
     : base(thisObj, functionCall.CallSignature, arguments)
 {
     FunctionCall = functionCall;
 }
コード例 #23
0
 internal IndirectStaticFieldPoint(IndirectStFldUse field, ValuePoint variable, ValuePoint typeName)
 {
     Field     = field;
     FieldName = variable;
     Self      = typeName;
 }
コード例 #24
0
 internal IndirectStaticFieldPoint(IndirectStFldUse field, ValuePoint variable)
 {
     Field     = field;
     FieldName = variable;
     Self      = null;
 }
コード例 #25
0
 internal ThrowStmtPoint(ThrowStmt throwStmt, ValuePoint throwedValue)
 {
     ThrowedValue = throwedValue;
     Throw        = throwStmt;
 }
コード例 #26
0
 internal StaticFieldPoint(DirectStFldUse field)
 {
     Field     = field;
     FieldName = new VariableIdentifier(field.PropertyName);
     Self      = null;
 }
コード例 #27
0
 /// <summary>
 /// Initializes a new instance of the <see cref="IncludingExPoint" /> class.
 /// </summary>
 /// <param name="include">Inclusion expression</param>
 /// <param name="includePath">Program point with path of remote file</param>
 internal IncludingExPoint(IncludingEx include, ValuePoint includePath)
     : base(null, null, new ValuePoint[] { includePath })
 {
     Include     = include;
     IncludePath = includePath;
 }
コード例 #28
0
 /// <summary>
 /// Initializes a new instance of the <see cref="EvalExPoint" /> class.
 /// </summary>
 /// <param name="eval">Eval expression</param>
 /// <param name="evalCode">Program point with source code for evaluation</param>
 internal EvalExPoint(EvalEx eval, ValuePoint evalCode)
     : base(null, null, new ValuePoint[] { evalCode })
 {
     Eval     = eval;
     EvalCode = evalCode;
 }
コード例 #29
0
 internal ConstantDeclPoint(ConstantDecl declaration, ValuePoint initializer)
 {
     Declaration = declaration;
     Initializer = initializer;
 }
コード例 #30
0
 internal ClassConstPoint(ClassConstUse x, ValuePoint thisObj)
 {
     _partial     = x;
     this.ThisObj = thisObj;
 }