internal override ExpressionType EmitCs(EmitCodeContext codecontext) { // l = r VariableUse lValueVariable = (VariableUse)LValue; ExpressionType lType = codecontext.GetLocalVarType(Position, lValueVariable.VariableName); if (lType == null) { throw new GeneratorException(Position, lValueVariable.VariableName + " is not declared."); } if (lType.ListOf != null) { throw new GeneratorException(Position, "Unable to assign to a list."); } // TODO: lValue cannot be the method argument, unable to assign to the method argument, only adding to lists or modifying object properties. // arg1 = .. // error // arg1.prop1 = ... // ok // arg2[] = ... // ok codecontext.Write(lValueVariable.VariableName + " = "); ExpressionType rType = RValue.EmitCs(codecontext); if (!(lType.Equals(rType))) { throw new GeneratorException(Position, "Type mishmash."); } return(lType); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { ExpressionType retType; // is it an extraction method ? if ((retType = TryEmitExtractionMethodCall(codecontext)) != null) { return(retType); } // is it a class construction ? if ((retType = TryEmitClassConstruct(codecontext)) != null) { return(retType); } // emit .NET method call (in the same context class) if ((retType = TryEmitCsMethodCall(codecontext)) != null) { return(retType); } // throw new GeneratorException(Position, "Undeclared method or class " + MethodName); }
public EmitCodeContext NewScope() { EmitCodeContext code = new EmitCodeContext(this, this.Output); code.Level = this.Level + 1; return(code); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { codecontext.WriteLine("public partial class " + ClassName + " : ExtractionObjectBase"); codecontext.WriteLine("{"); EmitCsInnerClass(codecontext.NewScope()); codecontext.WriteLine("}"); return(ExpressionType.VoidType); }
/// <summary> /// /// </summary> /// <param name="codecontext"></param> /// <returns></returns> internal override ExpressionType EmitCs(EmitCodeContext codecontext) { codecontext.WriteLine("{"); codecontext.Level++; // push scope bool contextchanged = false; foreach (var x in DataContexts) { if (!contextchanged) { contextchanged = true; codecontext.Write(scopeLocalVarName + ".Push(" + scopeLocalVarName + ".context", codecontext.Level); } //.OpenContextDynamic(MethodName, new object[] { arg1, arg2, ... }) codecontext.Write(".OpenContextDynamic(\"" + x.MethodName + "\", new object[] {"); bool firstArg = true; foreach (var a in x.CallArguments) { if (!firstArg) { codecontext.Write(", "); } else { firstArg = false; } a.EmitCs(codecontext); } codecontext.Write("})"); } if (contextchanged) { codecontext.Write(", null);" + codecontext.Output.NewLine); } // emit statements foreach (var s in Statements) { s.EmitCs(codecontext); codecontext.Write(codecontext.Output.NewLine); } // pop scope if (contextchanged) { codecontext.WriteLine(scopeLocalVarName + ".Pop();"); } codecontext.Level--; codecontext.WriteLine("}"); return(ExpressionType.VoidType); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { ExpressionType valType = EmitValue(codecontext, "(-({0}))"); if (!valType.Equals(ExpressionType.IntType) && !valType.Equals(ExpressionType.DoubleType)) { throw new GeneratorException(Position, "Value must be of type int or double."); } return(ExpressionType.BoolType); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { if (ExpressionInside != null) { codecontext.Write(string.Empty, codecontext.Level); ExpressionInside.EmitCs(codecontext); codecontext.Write(";"); } return(ExpressionType.VoidType); }
/// <summary> /// Emit the C# method call, defined in the context class (codecontext.ContextName). /// </summary> /// <param name="codecontext"></param> /// <returns></returns> private ExpressionType TryEmitCsMethodCall(EmitCodeContext codecontext) { List <MethodDecl> matchingMethods = new List <MethodDecl>(); foreach (var decl in codecontext.Declarations.Methods) { if (decl.DeclMethodName == MethodName && decl.BodyCSharp != null) { if (decl.MethodArguments != null && decl.MethodArguments.Count != CallArguments.Count) { throw new GeneratorException(Position, "Invalid arguments count in method call " + MethodName); } matchingMethods.Add(decl); } } if (matchingMethods.Count > 1) { throw new GeneratorException(Position, "Ambiguous C# method call."); } if (matchingMethods.Count == 1) { MethodDecl decl = matchingMethods[0]; codecontext.Write(decl.GeneratedMethodName + "("); bool bFirst = true; if (CallArguments != null) { foreach (var x in CallArguments) { if (!bFirst) { codecontext.Write(", "); } else { bFirst = false; } x.EmitCs(codecontext); } } codecontext.Write(")"); return(decl.ReturnType); } return(null); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { ExpressionType opType = EmitBinaryExpr(codecontext, "-", null, null); // only int,double,string if (opType.TypeName != ExpressionType.KnownTypes.TDouble && opType.TypeName != ExpressionType.KnownTypes.TInt) { throw new GeneratorException(Position, "Type mishmash."); } return(opType); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { if (Body != null) { codecontext.WriteLine("// " + DeclMethodName); codecontext.WriteLine("private static void " + GeneratedMethodName + "(DataContext _datacontext, LocalVariables _parameters)"); codecontext.WriteLine("{"); EmitCodeContext bodycontext = codecontext.NewScope(); // declare parameters as local variables foreach (var x in MethodArguments) { // declare variable from _parameters argument // checks for declaration duplicity bodycontext.DeclareLocalVar( x.VariableType, x.VariableName, new CustomExpression(x.Position, x.VariableType, "(" + x.VariableType.CsArgumentTypeName + ")_parameters[\"" + x.VariableName + "\"]") ); } // declare special scope variable bodycontext.WriteLine("ScopesStack " + scopeLocalVarName + " = new ScopesStack(_datacontext, null);"); // emit method body Body.EmitCs(bodycontext); // codecontext.WriteLine("}" + codecontext.Output.NewLine); return(ExpressionType.VoidType); } else if (BodyCSharp != null) { codecontext.WriteLine("// " + DeclMethodName); codecontext.WriteLine("private static " + ReturnType.CsArgumentTypeName + " " + GeneratedMethodName + "(" + CsArgList + ")"); codecontext.WriteLine("{"); string[] lines = BodyCSharp.Split(new string[] { codecontext.Output.NewLine }, StringSplitOptions.None); foreach (var line in lines) { codecontext.WriteLine(line); } codecontext.WriteLine("}"); return(ReturnType); } return(ExpressionType.VoidType); }
/// <summary> /// Copz Code context with different output. /// </summary> /// <param name="codecontext"></param> /// <param name="output"></param> public EmitCodeContext(EmitCodeContext codecontext, StreamWriter output) { this.Output = output; this.Declarations = codecontext.Declarations; this.Level = codecontext.Level; this.NamespaceName = codecontext.NamespaceName; this.ContextName = codecontext.ContextName; foreach (var x in codecontext.DeclaredLocalVars) { DeclaredLocalVars[x.Key] = x.Value; } }
private ExpressionType TryEmitClassConstruct(EmitCodeContext codecontext) { foreach (var decl in codecontext.Declarations.Classes.Values) { if (decl.ClassName == MethodName) { // emit // (new XXX(){ a = val1, b = val2 }); codecontext.Write("(new " + MethodName + "(){ "); for (int arg = 0; arg < CallArguments.Count; ++arg) { ExpressionAssign ass = CallArguments[arg] as ExpressionAssign; VariableUse lvalue; if (ass == null || (lvalue = ass.LValue as VariableUse) == null) { throw new GeneratorException(Position, "Argument " + arg + ": class construct arguments must be in a form of 'PropertyName = Expression'"); } if (arg > 0) { codecontext.Write(", "); } ExpressionType propType = decl.ContainsProperty(lvalue.VariableName); if (propType == null) { throw new GeneratorException(Position, lvalue.VariableName + " is not a property of " + decl.ClassName); } codecontext.Write(lvalue.VariableName + " = "); ExpressionType propValueType = ass.RValue.EmitCs(codecontext); if (!propValueType.Equals(propType)) { throw new GeneratorException(Position, "Type mishmash, " + propType.ToString() + " and " + propValueType.ToString()); } } codecontext.Write(" })"); return(new ExpressionUserType(decl.ClassName)); } } return(null); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { codecontext.WriteLine("#region Public classes declaration"); foreach (var c in Classes) { c.Value.EmitCs(codecontext); } codecontext.WriteLine("#endregion" + codecontext.Output.NewLine); codecontext.WriteLine("#region Private extraction methods"); foreach (var m in Methods) { m.EmitCs(codecontext); } codecontext.WriteLine("#endregion" + codecontext.Output.NewLine); return(ExpressionType.VoidType); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { ExpressionType lValueType = codecontext.GetLocalVarType(Position, lvalue.VariableName); if (lValueType == null) { throw new GeneratorException(Position, lvalue.VariableName + " not declared."); } if (lValueType.ListOf == null) { throw new GeneratorException(Position, "Unable to add an element to a non-list variable."); } ExpressionType rValueType; if (!lvalue.VariableName.Contains(".")) { // add an element directly // lvalue.AddElement( rvalue ); codecontext.Write(lvalue.VariableName); codecontext.Write(".AddElement("); rValueType = rvalue.EmitCs(codecontext); codecontext.Write(")"); } else { // element cannot be added directly // must be created action that add the element when list is actually enumerated // TODO: throw warning, can cause memory leaks, adding elements one-by-one through the actions. codecontext.Write("AddElementAction(" + scopeLocalVarName + ".context, _parameters, \"" + lvalue.VariableName + "\", " + lvalue.VariableName + ", "); rValueType = rvalue.EmitCs(codecontext); codecontext.Write(")"); } if (!rValueType.Equals(lValueType.ListOf)) { throw new GeneratorException(Position, "Type mishmash, adding an element of type " + rValueType.ToString() + " to the list of " + lValueType.ListOf.ToString()); } return(lValueType.ListOf); }
/// <summary> /// Emit variable read. /// </summary> /// <param name="codecontext"></param> /// <returns></returns> internal override ExpressionType EmitCs(EmitCodeContext codecontext) { ExpressionType varType = codecontext.GetLocalVarType(Position, VariableName); if (varType != null) { // VariableName codecontext.Write(VariableName); return(varType); } else { if (VariableName.Contains(".")) { throw new GeneratorException(Position, "Undeclared variable " + VariableName); } // ((string)__l["VariableName"]) // dynamic var codecontext.Write("(" + scopeLocalVarName + "[\"" + VariableName + "\"].ToString())"); return(ExpressionType.StringType); } }
/// <summary> /// Emit the binary operation expression. /// </summary> /// <param name="codecontext">Code context.</param> /// <param name="binaryOperator">Binary operator.</param> /// <param name="expectedLType">Expected left type, or null.</param> /// <param name="expectedRType">Expected right type, or null.</param> internal ExpressionType EmitBinaryExpr(EmitCodeContext codecontext, string binaryOperator, ExpressionType expectedLType, ExpressionType expectedRType) { codecontext.Write("(("); ExpressionType lType = LValue.EmitCs(codecontext); codecontext.Write(")" + binaryOperator + "("); ExpressionType rType = RValue.EmitCs(codecontext); codecontext.Write("))"); if (!lType.Equals(rType)) { throw new GeneratorException(Position, "Type mishmash!"); } if ((expectedLType != null && !expectedLType.Equals(lType)) || (expectedRType != null && !expectedRType.Equals(rType))) { throw new GeneratorException(Position, "Type mishmash!"); } return(lType); }
/// <summary> /// Emit formatted value expression. /// </summary> /// <param name="codecontext"></param> /// <param name="format"></param> /// <returns>Value type.</returns> internal ExpressionType EmitValue(EmitCodeContext codecontext, string format) { if (Value == null) { throw new GeneratorException(Position, "Value cannot be null."); } // process the value on separated output MemoryStream valstr = new MemoryStream(); StreamWriter valoutput = new StreamWriter(valstr); EmitCodeContext valcontext = new EmitCodeContext(codecontext, valoutput); ExpressionType valType = Value.EmitCs(valcontext); valoutput.Flush(); // get value emitted expression valstr.Position = 0; codecontext.Write(string.Format(format, new StreamReader(valstr).ReadToEnd())); return(valType); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { ExpressionType condType, expr1Type, expr2Type; codecontext.Write("("); condType = ConditionExpr.EmitCs(codecontext); codecontext.Write(")?("); expr1Type = Expr1.EmitCs(codecontext); codecontext.Write("):("); expr2Type = Expr2.EmitCs(codecontext); codecontext.Write(")"); if (!condType.Equals(ExpressionType.BoolType)) { throw new GeneratorException(Position, "Condition must be of type bool."); } if (!expr1Type.Equals(expr2Type)) { throw new GeneratorException(Position, "Type mishmash, " + expr1Type.ToString() + " and " + expr2Type.ToString()); } return(expr1Type); }
/// <summary> /// Emit the C# source code. /// </summary> /// <param name="output">Output stream.</param> /// <param name="level">The level of code indent, default 0.</param> /// <param name="declaredVariables">List of variables declared in the current context and their type.</param> internal override ExpressionType EmitCs(EmitCodeContext codecontext) { codecontext.WriteLine("/*"); codecontext.WriteLine(" * Generated LinqToWeb context"); codecontext.WriteLine(" * " + DateTime.Now.ToString()); codecontext.WriteLine(" */"); codecontext.WriteLine(); codecontext.WriteLine("using System;"); codecontext.WriteLine("using System.Collections.Generic;"); codecontext.WriteLine("using System.Text;"); codecontext.WriteLine("using System.Diagnostics;"); codecontext.WriteLine("using linqtoweb.Core.datacontext;"); codecontext.WriteLine("using linqtoweb.Core.extraction;"); codecontext.WriteLine("using linqtoweb.Core.methods;"); codecontext.WriteLine("using linqtoweb.Core.storage;"); codecontext.WriteLine(); codecontext.WriteLine("namespace " + codecontext.NamespaceName); codecontext.WriteLine("{"); EmitCodeContext indentc = codecontext.NewScope(); indentc.WriteLine("public partial class " + codecontext.ContextName + " : ExtractionContext"); indentc.WriteLine("{"); Declarations.EmitCs(indentc.NewScope()); // emit initialize, emit vars (use arguments from main methods), constructors EmitCs_Init(indentc.NewScope()); indentc.WriteLine("}"); codecontext.WriteLine("}"); return(ExpressionType.VoidType); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { codecontext.DeclareLocalVar(VariableType, VariableName, InitialValue); return(ExpressionType.VoidType); }
/// <summary> /// Emit the C# source code. /// </summary> /// <param name="output">Output stream.</param> /// <param name="level">Code indent level.</param> internal virtual ExpressionType EmitCs(EmitCodeContext codecontext) { throw new NotImplementedException(); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { codecontext.Write(CsCode); return(ExprType); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { // process the value on separated output MemoryStream valstr = new MemoryStream(); StreamWriter valoutput = new StreamWriter(valstr); EmitCodeContext valcontext = new EmitCodeContext(codecontext, valoutput); ExpressionType valType = Value.EmitCs(valcontext); valoutput.Flush(); // get value emitted expression valstr.Position = 0; string valvalue = "(" + new StreamReader(valstr).ReadToEnd() + ")"; // check return types if (valType.Equals(NewType)) { codecontext.Write(valvalue); } else { string result = null; switch (valType.TypeName) { case ExpressionType.KnownTypes.TBool: switch (NewType.TypeName) { case ExpressionType.KnownTypes.TDouble: result = string.Format("{0}?(1.0):(0.0)", valvalue); break; case ExpressionType.KnownTypes.TInt: result = string.Format("{0}?(1):(0)", valvalue); break; case ExpressionType.KnownTypes.TString: result = string.Format("{0}?(\"true\"):(\"false\")", valvalue); break; } break; case ExpressionType.KnownTypes.TDateTime: switch (NewType.TypeName) { case ExpressionType.KnownTypes.TString: result = string.Format("{0}.ToString()", valvalue); break; } break; case ExpressionType.KnownTypes.TDouble: switch (NewType.TypeName) { case ExpressionType.KnownTypes.TBool: result = string.Format("{0}!=0.0", valvalue); break; case ExpressionType.KnownTypes.TInt: result = string.Format("(int){0}", valvalue); break; case ExpressionType.KnownTypes.TString: result = string.Format("{0}.ToString()", valvalue); break; } break; case ExpressionType.KnownTypes.TInt: switch (NewType.TypeName) { case ExpressionType.KnownTypes.TBool: result = string.Format("{0}!=0.0", valvalue); break; case ExpressionType.KnownTypes.TDouble: result = string.Format("(double){0}", valvalue); break; case ExpressionType.KnownTypes.TString: result = string.Format("{0}.ToString()", valvalue); break; } break; case ExpressionType.KnownTypes.TString: switch (NewType.TypeName) { case ExpressionType.KnownTypes.TBool: result = string.Format("({0}.ToLower()==\"true\")?true:false", valvalue); break; case ExpressionType.KnownTypes.TInt: result = string.Format("int.Parse{0}", valvalue); break; case ExpressionType.KnownTypes.TDouble: result = string.Format("double.Parse{0}", valvalue); break; case ExpressionType.KnownTypes.TDateTime: result = string.Format("DateTime.Parse{0}", valvalue); break; } break; default: if (NewType.TypeName == ExpressionType.KnownTypes.TString) { result = string.Format("{0}.ToString()", valvalue); // anything to string } break; } if (string.IsNullOrEmpty(result)) { throw new GeneratorException(Position, "Unable to explicitly type the expression from " + valType.ToString() + " to " + NewType.ToString() + "."); } codecontext.Write("(" + result + ")"); } // return(NewType); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { codecontext.Write(CsValue); return(ExpressionType.StringType); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { codecontext.Write(Value.ToString()); return(ExpressionType.IntType); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { EmitBinaryExpr(codecontext, ">=", null, null); return(ExpressionType.BoolType); }
private ExpressionType TryEmitExtractionMethodCall(EmitCodeContext codecontext) { List <MethodDecl> matchingMethods = new List <MethodDecl>(); foreach (var decl in codecontext.Declarations.Methods) { if (decl.DeclMethodName == MethodName && decl.Body != null) { if (decl.IsMainMethod) { throw new GeneratorException(Position, "main method cannot be called!"); } if (decl.MethodArguments.Count != CallArguments.Count) { throw new GeneratorException(Position, "Invalid arguments count in method call " + MethodName); } matchingMethods.Add(decl); } } if (matchingMethods.Count > 0) { codecontext.Write("ActionItem.AddAction( new ActionItem.ExtractionMethod[]{"); bool bFirstMethod = true; foreach (var decl in matchingMethods) { if (bFirstMethod) { bFirstMethod = false; } else { codecontext.Write(", "); } codecontext.Write(decl.GeneratedMethodName); } codecontext.Write("}, " + scopeLocalVarName + ".context, new LocalVariables() {" + codecontext.Output.NewLine); codecontext.Level++; MethodDecl somedecl = matchingMethods[0]; string cannotAddActionDict = null; for (int arg = 0; arg < CallArguments.Count; ++arg) { if (arg > 0) { codecontext.Write("," + codecontext.Output.NewLine); } codecontext.Write("{\"" + somedecl.MethodArguments[arg].VariableName + "\", ", codecontext.Level); ExpressionType t = CallArguments[arg].EmitCs(codecontext); codecontext.Write("}"); if (!t.Equals(somedecl.MethodArguments[arg].VariableType)) { throw new GeneratorException(Position, "Type mishmash."); } // check if the argument is able to add new action VariableUse varuse; if ((varuse = CallArguments[arg] as VariableUse) != null) { if (cannotAddActionDict != null) { cannotAddActionDict += ","; } cannotAddActionDict += "{\"" + somedecl.MethodArguments[arg].VariableName + "\",_parameters.CannotAddActionForVariable(\"" + varuse.VariableName + "\")}"; } } codecontext.Write(" }.SetCannotAddAction(new Dictionary<string,bool>(){" + cannotAddActionDict + "}))"); codecontext.Level--; return(ExpressionType.VoidType); } else { return(null); } }
private void EmitCsInnerClass(EmitCodeContext codecontext) { // List <string> propsInit = new List <string>(); // properties codecontext.WriteLine("#region Properties"); foreach (var x in ClassProperties) { if (x.VariableName.StartsWith("_")) { throw new GeneratorException(Position, "Class property cannot start with _. It is reserved system name."); } // comment codecontext.WriteLine("// " + x.ToString()); if (x.VariableType.IsExtractionObject) { codecontext.WriteLine("public readonly " + x.VariableType.CsPropertyTypeName + " " + x.VariableName + ";"); propsInit.Add(x.VariableName + " = " + x.VariableType.CsPropertyInitValue + ";"); } else { string privatePropName = "_" + x.VariableName; // extracting on request (public property) // public property string format = "public " + x.VariableType.CsPropertyTypeName + " " + x.VariableName + "{get{while(" + privatePropName + "==" + x.VariableType.CsPropertyDefaultValue + "){if (!DoNextAction<object>(null))throw new NotExtractedDataException(\"" + x.VariableName + " cannot reach any data.\");} return " + privatePropName + ";}set{" + privatePropName + "=value;}}"; codecontext.WriteLine(format); // private property value string decl = "private " + x.VariableType.CsPropertyTypeName + " " + privatePropName; codecontext.WriteLine(decl + " = " + x.VariableType.CsPropertyDefaultValue + ";"); } codecontext.WriteLine(""); } codecontext.WriteLine("#endregion"); // ctor codecontext.WriteLine("#region Constructors"); // no-param ctor codecontext.WriteLine("public " + ClassName + "():this(null){}"); // ctor with parent given codecontext.WriteLine("public " + ClassName + "(ExtractionObjectBase parent):base(parent)"); codecontext.WriteLine("{"); codecontext.Level++; foreach (string strline in propsInit) { codecontext.WriteLine(strline); } codecontext.Level--; codecontext.WriteLine("}"); // codecontext.WriteLine("#endregion"); }
internal override ExpressionType EmitCs(EmitCodeContext codecontext) { codecontext.Write(Value ? "true" : "false"); return(ExpressionType.BoolType); }
internal void EmitCs_Init(EmitCodeContext codecontext) { Dictionary <string, ExpressionType> contextVars = new Dictionary <string, ExpressionType>(); List <MethodDecl> mainMethods = new List <MethodDecl>(); // collect global vars, extraction arguments foreach (var m in codecontext.Declarations.Methods) { if (m.IsMainMethod) { mainMethods.Add(m); foreach (var arg in m.MethodArguments) { ExpressionType vartype; if (contextVars.TryGetValue(arg.VariableName, out vartype)) { if (vartype != arg.VariableType) { throw new GeneratorException(Position, "Two context variables with different type defined."); } } else { contextVars[arg.VariableName] = arg.VariableType; } } } } // emit properties codecontext.WriteLine("#region Public extracted data"); foreach (var v in contextVars) { codecontext.WriteLine("// " + v.Value.ToString() + " " + v.Key); if (v.Value.IsExtractionObject) { // emit prop codecontext.WriteLine("public readonly " + v.Value.CsPropertyTypeName + " " + v.Key + " = " + v.Value.CsPropertyRootInitValue + ";"); } /*else * { * // emit context parameter * codecontext.WriteLine("private readonly " + v.Value.CsArgumentTypeName + " " + v.Key + ";"); * }*/ } codecontext.WriteLine("#endregion" + codecontext.Output.NewLine); // // context arguments, initialization // string ctorArgs = null; string argsPass = null; foreach (var x in contextVars) { if (!x.Value.IsExtractionObject) { // argument if (ctorArgs != null) { ctorArgs += ", "; } if (argsPass != null) { argsPass += ", "; } ctorArgs = ctorArgs + x.Value.CsArgumentTypeName + " " + x.Key; argsPass = argsPass + x.Key; } } // emit initializing actions codecontext.WriteLine("#region Context construct"); codecontext.WriteLine("private void InitActionsToDo(" + ctorArgs + ")"); codecontext.WriteLine("{"); codecontext.Level++; foreach (var m in mainMethods) { codecontext.WriteLine("ActionItem.AddAction(" + m.GeneratedMethodName + ", InitialDataContext, new LocalVariables(){"); codecontext.Level++; bool bfirstarg = true; foreach (var arg in m.MethodArguments) { if (bfirstarg) { bfirstarg = false; } else { codecontext.Write("," + codecontext.Output.NewLine); } codecontext.Write("{\"" + arg.VariableName + "\", " + arg.VariableName + "}", codecontext.Level); } codecontext.Write("});" + codecontext.Output.NewLine); codecontext.Level--; } codecontext.Level--; codecontext.WriteLine("}"); // emit ctors codecontext.WriteLine("#region Constructors"); codecontext.WriteLine("public " + codecontext.ContextName + "(" + ctorArgs + "):base(){InitActionsToDo(" + argsPass + ");}"); codecontext.WriteLine("public " + codecontext.ContextName + "(" + ((ctorArgs == null) ? "" : (ctorArgs + ", ")) + "StorageBase cache):base(cache){InitActionsToDo(" + argsPass + ");}"); codecontext.WriteLine("#endregion"); codecontext.WriteLine("#endregion" + codecontext.Output.NewLine); }