public void AddStatement(DynaExpression Statement) { ccc.Statements.Add(Statement.Expression); }
/// <summary> /// Creates a new class constructor member within this AosDynaClass object. /// </summary> /// <param name="Arguements">An array of DynaArguement objects containing the incoming arguements for this class constructor.</param> /// <param name="Statements">An array of DynaStatement objects containing the expression statements contained within this class constructor.</param> /// <param name="Scope">A value of type MemberAttributes indicating the scope of this class constructor.</param> public void CreateConstructor(DynaArgument[] Arguments, DynaExpression[] Statements, System.CodeDom.MemberAttributes Scope) { DynaConstructor cc = new DynaConstructor(); cc.TypeMember.Attributes = Scope; foreach (DynaExpression stmt in Statements) cc.TypeMember.Statements.Add(stmt.Expression); AddConstructor(cc); }
/// <summary> /// Creates a new field member within this DynaClass object. /// </summary> /// <param name="Name">A string value containing the name of the new field.</param> /// <param name="ValueType">A Type class object indicating the data-type of the new field.</param> /// <param name="GetStatements">An array of DynaStatement objects containing the expression statements contained within the 'Set' portion of the field.</param> /// <param name="SetStatements">An array of DynaStatement objects containing the expression statements contained within the 'Get' portion of the field.</param> /// <param name="Scope">A value of type MemberAttributes indicating the scope of this field.</param> public void CreateProperty(string Name, Type ValueType, DynaExpression[] SetStatements, DynaExpression[] GetStatements, System.CodeDom.MemberAttributes Scope) { DynaProperty prop = new DynaProperty(Name, ValueType, Scope); foreach (DynaExpression stmt in SetStatements) prop.AddSetStatement(stmt); foreach (DynaExpression stmt in GetStatements) prop.AddGetStatement(stmt); this.AddProperty(prop); }
public DynaOperatorExpression(DynaExpression leftExpression, string rightVariable, CodeBinaryOperatorType Operation) : this(leftExpression.Expression, new CodeVariableReferenceExpression(rightVariable), Operation) { }
/// <summary> /// Sets the return value of this statement. /// </summary> /// <param name="ReturnExpression">A DynaStatement object whose result will be the return value.</param> public void SetReturnExpression(DynaExpression ReturnExpression) { this._ce = ReturnExpression.Expression; }
public DynaAssignmentStatement(string VarName, DynaExpression AssignValue) : this(VarName, AssignValue.Expression) { }
public DynaOperatorExpression(DynaExpression leftExpression, DynaExpression rightExpression, CodeBinaryOperatorType Operation) : this(leftExpression.Expression, rightExpression.Expression, Operation) { }
public DynaArrayIndexerExpression(string VariableName, DynaExpression IndexExpression) : this(VariableName, IndexExpression.Expression) { }
public DynaDeclarationStatement(string VariableName, Type DataType, DynaExpression InitExpression) : this(VariableName, DataType.FullName, InitExpression) { }
public DynaArrayCreateExpression(string DataType, DynaExpression[] ArrayInitializers) : this(DataType) { foreach (DynaExpression de in ArrayInitializers) cec.Add(de.Expression); }
public void SetArraySize(DynaExpression value) { this._size = value.Expression; }
public DynaArrayCreateExpression(Type DataType, DynaExpression[] ArrayInitializers) : this(DataType.FullName, ArrayInitializers) { }
public DynaArrayCreateExpression(string DataType, DynaExpression SizeExpression) : this(DataType) { this._size = SizeExpression.Expression; }
public DynaArrayCreateExpression(Type DataType, DynaExpression SizeExpression) : this(DataType.FullName, SizeExpression) { }
public DynaIterationStatement(DynaStatement InitValue, DynaExpression LoopCondition, DynaStatement ValueIncrement, DynaStatement[] LoopStatements) { switch (InitValue.GetType().Name.ToLower()) { case "dynaiterationstatement": this._initValue = (InitValue as DynaIterationStatement).Statement; break; case "dynaassignmentstatement": this._initValue = (InitValue as DynaAssignmentStatement).Statement; break; case "dynaconditionstatement": this._initValue = (InitValue as DynaConditionStatement).Statement; break; case "dynareturnstatement": this._initValue = (InitValue as DynaReturnStatement).Statement; break; case "dynadeclarationstatement": this._initValue = (InitValue as DynaDeclarationStatement).Statement; break; case "dynacommentstatement": this._initValue = (InitValue as DynaCommentStatement).Statement; break; } switch (LoopCondition.GetType().Name.ToLower()) { case "dynamethodexpression": this._testCondition = (LoopCondition as DynaMethodExpression).Expression; break; case "dynaarraycreateexpression": this._testCondition = (LoopCondition as DynaArrayCreateExpression).Expression; break; case "dynaarrayindexerexpression": this._testCondition = (LoopCondition as DynaArrayIndexerExpression).Expression; break; case "dynaoperatorexpression": this._testCondition = (LoopCondition as DynaOperatorExpression).Expression; break; } switch (ValueIncrement.GetType().Name.ToLower()) { case "dynaiterationstatement": this._valueInc = (ValueIncrement as DynaIterationStatement).Statement; break; case "dynaassignmentstatement": this._valueInc = (ValueIncrement as DynaAssignmentStatement).Statement; break; case "dynaconditionstatement": this._valueInc = (ValueIncrement as DynaConditionStatement).Statement; break; case "dynareturnstatement": this._valueInc = (ValueIncrement as DynaReturnStatement).Statement; break; case "dynadeclarationstatement": this._valueInc = (ValueIncrement as DynaDeclarationStatement).Statement; break; case "dynacommentstatement": this._valueInc = (ValueIncrement as DynaCommentStatement).Statement; break; } if (LoopStatements != null) { foreach (DynaStatement ds in LoopStatements) switch (ds.GetType().Name.ToLower()) { case "dynaiterationstatement": csc.Add((ds as DynaIterationStatement).Statement); break; case "dynaassignmentstatement": csc.Add((ds as DynaAssignmentStatement).Statement); break; case "dynaconditionstatement": csc.Add((ds as DynaConditionStatement).Statement); break; case "dynareturnstatement": csc.Add((ds as DynaReturnStatement).Statement); break; case "dynadeclarationstatement": csc.Add((ds as DynaDeclarationStatement).Statement); break; case "dynacommentstatement": csc.Add((ds as DynaCommentStatement).Statement); break; } } }
public void SetInitExpression(DynaExpression InitExpression) { this._init = InitExpression.Expression; }
public void SetLoopCondition(DynaExpression value) { switch (value.GetType().Name.ToLower()) { case "dynamethodexpression": this._testCondition = (value as DynaMethodExpression).Expression; break; case "dynaarraycreateexpression": this._testCondition = (value as DynaArrayCreateExpression).Expression; break; case "dynaarrayindexerexpression": this._testCondition = (value as DynaArrayIndexerExpression).Expression; break; case "dynaoperatorexpression": this._testCondition = (value as DynaOperatorExpression).Expression; break; } }
public DynaObjectCreateExpression(string ValueType, DynaExpression[] Parameters) : this(ValueType) { foreach (DynaExpression de in Parameters) cec.Add(de.Expression); }
public DynaConditionStatement(DynaExpression TestCondition) : this(TestCondition.Expression) { }
public DynaObjectCreateExpression(Type ValueType, DynaExpression[] Parameters) : this(ValueType.FullName, Parameters) { }
public DynaOperatorExpression(DynaExpression leftExpression, object rightExpression, CodeBinaryOperatorType Operation) : this(leftExpression.Expression, new CodePrimitiveExpression(rightExpression), Operation) { }
//*************************************************************************** // Public Methods // public void AddParameter(DynaExpression value) { cec.Add(value.Expression); }
public DynaReturnStatement(DynaExpression ReturnExpression) : this(ReturnExpression.Expression) { }
public DynaMethodExpression(string ExpressionNamespace, string MethodName, DynaExpression ExpressionArg) : this(ExpressionNamespace, MethodName, new DynaExpression[] { ExpressionArg }) { }
/// <summary> /// Creates a new method member within this DynaClass object. /// </summary> /// <param name="Name">A string value containing the name of the new method.</param> /// <param name="Arguements">An array of DynaArguement objects specifying the incoming arguements for the new methdod.</param> /// <param name="Statements">An array of DynaStatement objects specifying the expression statements contained within this method.</param> /// <param name="Scope">A value of type MemberAttributes indicating the scope of the new method.</param> public void CreateMethod(string Name, DynaArgument[] Arguements, DynaExpression[] Statements, System.CodeDom.MemberAttributes Scope) { DynaMethod dm = new DynaMethod(Name); dm.TypeMember.Attributes = Scope; foreach (DynaExpression stmt in Statements) dm.TypeMember.Statements.Add(stmt.Expression); AddMethod(dm); }
public DynaMethodExpression(string ExpressionNamespace, string MethodName, DynaExpression[] ExpressionArgs) { _methodName = MethodName; _nameSpace = ExpressionNamespace; if (ExpressionArgs != null && ExpressionArgs.Length > 0) { foreach (DynaExpression de in ExpressionArgs) switch (de.GetType().Name.ToLower()) { case "dynamethodexpression": cec.Add((de as DynaMethodExpression).Expression); break; case "dynaarraycreateexpression": cec.Add((de as DynaArrayCreateExpression).Expression); break; case "dynaarrayindexerexpression": cec.Add((de as DynaArrayIndexerExpression).Expression); break; case "dynaoperatorexpression": cec.Add((de as DynaOperatorExpression).Expression); break; } } }
/// <summary> /// Creates a new entry point member within this DynaClass object. /// When adding this class to an DynaCode object containing other classes, there should be only *one* (1) EntryPoint for the entire DynaCode object. /// </summary> /// <param name="Arguements">An array of DynaArguement objects containing the incoming arguements for the new entry point.</param></param> /// <param name="Statements">An array of DynaStatement objects containing the expression statements contained within the new entry point.</param></param> /// <param name="Scope">A value of type MemberAttributes indicating the scope of this class constructor.</param> public void CreateEntryPoint(DynaArgument[] Arguements, DynaExpression[] Statements, System.CodeDom.MemberAttributes Scope) { DynaEntryPoint ep = new DynaEntryPoint(); ep.TypeMember.Attributes = Scope; foreach (DynaExpression stmt in Statements) ep.TypeMember.Statements.Add(stmt.Expression); AddEntryPoint(ep); }
/// <summary> /// Adds an argument value to this method call. Be cautious, when adding values here, that they are added in the proper order. /// </summary> /// <param name="value">A DynaExpression object containing an expression whose result value will be passed to the method.</param> public void AddArgument(DynaExpression value) { switch (value.GetType().Name.ToLower()) { case "dynamethodexpression": cec.Add((value as DynaMethodExpression).Expression); break; case "dynaarraycreateexpression": cec.Add((value as DynaArrayCreateExpression).Expression); break; case "dynaarrayindexerexpression": cec.Add((value as DynaArrayIndexerExpression).Expression); break; case "dynaoperatorexpression": cec.Add((value as DynaOperatorExpression).Expression); break; } }
public void AddSetStatement(DynaExpression value) { csc2.Add(value.Statement); }
public DynaCatchClause(string ExVarName, string CatchType, DynaExpression[] Statements) : this(ExVarName, CatchType) { foreach (DynaExpression ds in Statements) ccc.Statements.Add(ds.Expression); }