private void BuildAddContentPlaceHolderNames(CodeMemberMethod method, string placeHolderID) { CodePropertyReferenceExpression propertyExpr = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "ContentPlaceHolders"); CodeExpressionStatement stmt = new CodeExpressionStatement(); stmt.Expression = new CodeMethodInvokeExpression(propertyExpr, "Add", new CodePrimitiveExpression(placeHolderID.ToLower(CultureInfo.InvariantCulture))); method.Statements.Add(stmt); }
public static List<CodeStatement> GetCodeStatement(this RecordStep step,string dataClassParameter = null) { List<CodeStatement> codes = new List<CodeStatement>(); CodeStatement actionCode = null; switch (step.Action) { case BindingFlags.SetProperty: actionCode = getAssignDetailStatement(step, dataClassParameter); break; case BindingFlags.InvokeMethod: actionCode = getInvokeDetailStatement(step, dataClassParameter); break; default: break; } if (actionCode != null) codes.Add(actionCode); if(step.TakeScreenShot) { CodeExpressionStatement screenShotCode = new CodeExpressionStatement(); screenShotCode.Expression = new CodeMethodInvokeExpression( new CodeVariableReferenceExpression("SAPTestHelper.Current"), "TakeScreenShot", new CodePrimitiveExpression(step.StepId.ToString() + ".jpg")); codes.Add(screenShotCode); } return codes; }
private static CodeExpressionStatement getInvokeDetailStatement(RecordStep step, string dataClass) { CodeExpressionStatement statement = new CodeExpressionStatement(); CodeExpression[] paras; if (step.ActionParams != null) { paras = new CodeExpression[step.ActionParams.Count]; ///判断是否参数化函数代码 if(dataClass == null) { for (int i = 0; i < step.ActionParams.Count; i++) { paras[i] = new CodePrimitiveExpression(step.ActionParams[i].Value); } } else { for (int i = 0; i < step.ActionParams.Count; i++) { paras[i] = step.ActionParams[i].GetVariableReference(dataClass); } } } else { paras = new CodeExpression[0]; } CodeMethodInvokeExpression method = new CodeMethodInvokeExpression(step.CompInfo.FindMethod, step.ActionName, paras); statement.Expression = method; return statement; }
/// <summary> /// Generates code in the class area of the transformation class created by the T4 engine. /// </summary> /// <param name="arguments">The arguments for the directive.</param> protected override void Process(IDictionary<string, string> arguments) { // Don't generate the same code more then once if T4Toolbox.tt happens to be included multiple times if (this.directiveProcessed) { this.Warning("Multiple <#@ include file=\"T4Toolbox.tt\" #> directives were found in the template."); return; } this.References.Add(typeof(TransformationContext).Assembly.Location); // Add the following method call to the Initialize method of the generated text template. // T4Toolbox.TransformationContext.Initialize(this, this.GenerationEnvironment); var initialize = new CodeExpressionStatement( new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(typeof(TransformationContext).FullName), "Initialize", new CodeThisReferenceExpression(), new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "GenerationEnvironment"))); this.LanguageProvider.GenerateCodeFromStatement(initialize, this.PreInitializationCode, null); // Add the following method call to the Dispose(bool) method of the generated text template. // T4Toolbox.TransformationContext.Cleanup(); var cleanup = new CodeExpressionStatement( new CodeMethodInvokeExpression( new CodeTypeReferenceExpression(typeof(TransformationContext).FullName), "Cleanup")); this.LanguageProvider.GenerateCodeFromStatement(cleanup, this.DisposeCode, null); this.directiveProcessed = true; }
internal static void AddCallbackImplementation(CodeTypeDeclaration codeClass, string callbackName, string handlerName, string handlerArgs, bool methodHasOutParameters) { CodeFlags[] parameterFlags = new CodeFlags[1]; CodeMemberMethod method = AddMethod(codeClass, callbackName, parameterFlags, new string[] { typeof(object).FullName }, new string[] { "arg" }, typeof(void).FullName, null, (CodeFlags) 0); CodeEventReferenceExpression left = new CodeEventReferenceExpression(new CodeThisReferenceExpression(), handlerName); CodeBinaryOperatorExpression condition = new CodeBinaryOperatorExpression(left, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)); CodeStatement[] trueStatements = new CodeStatement[2]; trueStatements[0] = new CodeVariableDeclarationStatement(typeof(InvokeCompletedEventArgs), "invokeArgs", new CodeCastExpression(typeof(InvokeCompletedEventArgs), new CodeArgumentReferenceExpression("arg"))); CodeVariableReferenceExpression targetObject = new CodeVariableReferenceExpression("invokeArgs"); CodeObjectCreateExpression expression4 = new CodeObjectCreateExpression(); if (methodHasOutParameters) { expression4.CreateType = new CodeTypeReference(handlerArgs); expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "Results")); } else { expression4.CreateType = new CodeTypeReference(typeof(AsyncCompletedEventArgs)); } expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "Error")); expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "Cancelled")); expression4.Parameters.Add(new CodePropertyReferenceExpression(targetObject, "UserState")); trueStatements[1] = new CodeExpressionStatement(new CodeDelegateInvokeExpression(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), handlerName), new CodeExpression[] { new CodeThisReferenceExpression(), expression4 })); method.Statements.Add(new CodeConditionStatement(condition, trueStatements, new CodeStatement[0])); }
CodeMemberMethod CreateMethod() { CodeMemberMethod method = new CodeMemberMethod(); // BeginInit method call. CodeExpressionStatement statement = new CodeExpressionStatement(); CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression(); statement.Expression = methodInvoke; CodeMethodReferenceExpression methodRef = new CodeMethodReferenceExpression(); methodRef.MethodName = "BeginInit"; CodeCastExpression cast = new CodeCastExpression(); cast.TargetType = new CodeTypeReference(); cast.TargetType.BaseType = "System.ComponentModel.ISupportInitialize"; CodeFieldReferenceExpression fieldRef = new CodeFieldReferenceExpression(); fieldRef.FieldName = "pictureBox1"; fieldRef.TargetObject = new CodeThisReferenceExpression(); cast.Expression = fieldRef; methodRef.TargetObject = cast; methodInvoke.Method = methodRef; method.Statements.Add(statement); return method; }
private CodeStatement GenerateCallStatementC2J(GMethod method, CodeExpression invokeExpression) { CodeStatement call; if (method.IsConstructor || method.IsVoid) { call = new CodeExpressionStatement(invokeExpression); } else { if (method.ReturnType.IsPrimitive) { if (method.ReturnType.JVMSubst != null) { invokeExpression = new CodeCastExpression(method.ReturnType.CLRReference, invokeExpression); } call = new CodeMethodReturnStatement(invokeExpression); } else { CodeMethodInvokeExpression conversionExpression = CreateConversionExpressionJ2CParam(method.ReturnType, invokeExpression); call = new CodeMethodReturnStatement(conversionExpression); } } return call; }
public override object Serialize (IDesignerSerializationManager manager, object value) { if (value == null) throw new ArgumentNullException ("value"); if (manager == null) throw new ArgumentNullException ("manager"); if (!(value is Control)) throw new InvalidOperationException ("value is not a Control"); object serialized = base.Serialize (manager, value); CodeStatementCollection statements = serialized as CodeStatementCollection; if (statements != null) { // the root control is serialized to CodeExpression ICollection childControls = TypeDescriptor.GetProperties (value)["Controls"].GetValue (value) as ICollection; if (childControls.Count > 0) { CodeExpression componentRef = base.GetExpression (manager, value); CodeStatement statement = new CodeExpressionStatement ( new CodeMethodInvokeExpression (componentRef, "SuspendLayout")); statement.UserData["statement-order"] = "begin"; statements.Add (statement); statement = new CodeExpressionStatement ( new CodeMethodInvokeExpression (componentRef, "ResumeLayout", new CodeExpression[] { new CodePrimitiveExpression (false) })); statement.UserData["statement-order"] = "end"; statements.Add (statement); serialized = statements; } } return serialized; }
private void BuildAddContentPlaceHolderNames(CodeMemberMethod method, string placeHolderID) { CodePropertyReferenceExpression targetObject = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "ContentPlaceHolders"); CodeExpressionStatement statement = new CodeExpressionStatement { Expression = new CodeMethodInvokeExpression(targetObject, "Add", new CodeExpression[] { new CodePrimitiveExpression(placeHolderID.ToLower(CultureInfo.InvariantCulture)) }) }; method.Statements.Add(statement); }
public static void AddDisposalOfMember(CodeMemberMethod disposeMethod, string memberName) { CodeBinaryOperatorExpression isnull = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(memberName), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)); CodeExpressionStatement callDispose = new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeVariableReferenceExpression(memberName), "Dispose")); //add dispose code disposeMethod.Statements.Add(new CodeConditionStatement(isnull, callDispose)); }
public TypescriptExpressionStatement( IStatementFactory statementFactory, IExpressionFactory expressionFactory, CodeExpressionStatement statement, CodeGeneratorOptions options) { _statementFactory = statementFactory; _expressionFactory = expressionFactory; _statement = statement; _options = options; }
public static CodeExpressionStatement Clone(this CodeExpressionStatement statement) { if (statement == null) return null; CodeExpressionStatement s = new CodeExpressionStatement(); s.EndDirectives.AddRange(statement.EndDirectives); s.Expression = statement.Expression.Clone(); s.LinePragma = statement.LinePragma; s.StartDirectives.AddRange(statement.StartDirectives); s.UserData.AddRange(statement.UserData); return s; }
Type EmitExpressionStatement(CodeExpressionStatement Expression, bool ForceTypes) { Depth++; Debug("Emitting expression statement"); Type Generated = EmitExpression(Expression.Expression, ForceTypes); if (Generated != typeof(void)) Generator.Emit(OpCodes.Pop); Depth--; return Generated; }
public void GetKeywordFromCodeDom() { CodeStatement st = new CodeExpressionStatement(new CodeArgumentReferenceExpression("foo")); CodeExpression exp = new CodeArgumentReferenceExpression("foo"); CodeIterationStatement it = new CodeIterationStatement(st, exp, st); CodeConditionStatement cond = new CodeConditionStatement(exp); new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromStatement( it, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions()); new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromStatement( cond, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions()); new Microsoft.VisualBasic.VBCodeProvider().GenerateCodeFromStatement( it, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions()); new Microsoft.VisualBasic.VBCodeProvider().GenerateCodeFromStatement( cond, Console.Out, new System.CodeDom.Compiler.CodeGeneratorOptions()); }
internal static void CreatePropertySetStatements(CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeExpression target, string targetPropertyName, Type destinationType, CodeExpression value, CodeLinePragma linePragma) { bool flag = false; if (destinationType == null) { flag = true; } if (flag) { CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(); CodeExpressionStatement statement = new CodeExpressionStatement(expression) { LinePragma = linePragma }; expression.Method.TargetObject = new CodeCastExpression(typeof(IAttributeAccessor), target); expression.Method.MethodName = "SetAttribute"; expression.Parameters.Add(new CodePrimitiveExpression(targetPropertyName)); expression.Parameters.Add(GenerateConvertToString(value)); statements.Add(statement); } else if (destinationType.IsValueType) { CodeAssignStatement statement2 = new CodeAssignStatement(BuildPropertyReferenceExpression(target, targetPropertyName), new CodeCastExpression(destinationType, value)) { LinePragma = linePragma }; statements.Add(statement2); } else { CodeExpression expression2; if (destinationType == typeof(string)) { expression2 = GenerateConvertToString(value); } else { expression2 = new CodeCastExpression(destinationType, value); } CodeAssignStatement statement3 = new CodeAssignStatement(BuildPropertyReferenceExpression(target, targetPropertyName), expression2) { LinePragma = linePragma }; statements.Add(statement3); } }
private CodeStatement GetOutputWriteStatement(CodeExpression expr, bool encode) { // Call HttpUtility.HtmlEncode on the expression if needed if (encode) { expr = new CodeMethodInvokeExpression( new CodeMethodReferenceExpression( new CodeTypeReferenceExpression(typeof(HttpUtility)), "HtmlEncode"), expr); } CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression(); CodeExpressionStatement call = new CodeExpressionStatement(methodInvoke); methodInvoke.Method.TargetObject = new CodeArgumentReferenceExpression(renderMethodParameterName); methodInvoke.Method.MethodName = "Write"; methodInvoke.Parameters.Add(expr); return call; }
//Create main method private void CreateEntryPoint(List<string> statements) { //Create an object and assign the name as "Main" CodeEntryPointMethod mymain = new CodeEntryPointMethod(); mymain.Name = "Main"; //Mark the access modifier for the main method as Public and //static mymain.Attributes = MemberAttributes.Public | MemberAttributes.Static; //Change string to statements if(statements != null){ foreach (string item in statements) { if (item != null) { CodeSnippetExpression exp1 = new CodeSnippetExpression(@item); CodeExpressionStatement ces1 = new CodeExpressionStatement(exp1); mymain.Statements.Add(ces1); } } } myclass.Members.Add(mymain); }
private void AddOutputWriteStringStatement(CodeStatementCollection methodStatements, string s) { if (!this.UseResourceLiteralString(s)) { this.AddOutputWriteStatement(methodStatements, new CodePrimitiveExpression(s), null); } else { int num; int num2; bool flag; base._stringResourceBuilder.AddString(s, out num, out num2, out flag); CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(); CodeExpressionStatement statement = new CodeExpressionStatement(expression); expression.Method.TargetObject = new CodeThisReferenceExpression(); expression.Method.MethodName = "WriteUTF8ResourceString"; expression.Parameters.Add(new CodeArgumentReferenceExpression("__w")); expression.Parameters.Add(new CodePrimitiveExpression(num)); expression.Parameters.Add(new CodePrimitiveExpression(num2)); expression.Parameters.Add(new CodePrimitiveExpression(flag)); methodStatements.Add(statement); } }
public void CreateEntryPoint(ref CodeTypeDeclaration customClass) { //Create an object and assign the name as “Main” CodeEntryPointMethod main = new CodeEntryPointMethod(); main.Name = "Main"; //Mark the access modifier for the main method as Public and //static main.Attributes = MemberAttributes.Public | MemberAttributes.Static; //Provide defenition to the main method. //Create an object of the “Cmyclass” and invoke the method //by passing the required parameters. CodeSnippetExpression exp = new CodeSnippetExpression(CallingMethod(customClass)); //Create expression statements for the snippets CodeExpressionStatement ces = new CodeExpressionStatement(exp); //Add the expression statements to the main method. main.Statements.Add(ces); //Add the main method to the class customClass.Members.Add(main); }
CodeExpressionStatement[] ParseMultiExpression(string code) { var tokens = SplitTokens(code); #region Date/time int n = tokens.Count - 2; if (tokens.Count > 1 && ((string)tokens[n]).Length > 0 && ((string)tokens[n])[0] == Multicast) { string arg = ((string)tokens[n + 1]).ToUpperInvariant().Trim(); arg = arg.Length == 1 ? arg : arg.TrimEnd('S'); switch (arg) { case "S": case "SECOND": case "M": case "MINUTE": case "H": case "HOUR": case "D": case "DAY": return new[] { new CodeExpressionStatement(ParseDateExpression(code)) }; } } #endregion var result = ParseMultiExpression(tokens.ToArray()); var statements = new CodeExpressionStatement[result.Length]; for (int i = 0; i < result.Length; i++) statements[i] = new CodeExpressionStatement(result[i]); return statements; }
protected override void GenerateExpressionStatement(CodeExpressionStatement e) { Output.Write("[CodeExpressionStatement:"); base.GenerateExpression(e.Expression); Output.WriteLine("]"); }
/// <summary> /// Execute one expression as statement. /// </summary> public CodeExpressionStatement Add(CodeExpression expr) { CodeExpressionStatement st = new CodeExpressionStatement(expr); csc.Add(st); return st; }
/// <summary> /// 构造一个命名空间 /// </summary> /// <returns>code</returns> static CodeNamespace CreateMimsyNamespace() { // 定义命名空间 CodeNamespace mimsyNamespace = new CodeNamespace("Mimsy"); // 添加引用 mimsyNamespace.Imports.AddRange(new[] { new CodeNamespaceImport("System"), new CodeNamespaceImport("System.Text"), new CodeNamespaceImport("System.Collections") }); // 定义类 CodeTypeDeclaration jubjubClass = new CodeTypeDeclaration("Jubjub") { TypeAttributes = TypeAttributes.Public // NotPublic = internal, the internal type isn't visible to the dynamic binder }; // 定义成员字段 CodeMemberField wabeCountFld = new CodeMemberField(typeof(int), "_wabeCount") { Attributes = MemberAttributes.Private }; jubjubClass.Members.Add(wabeCountFld); // 附加字段到类 mimsyNamespace.Types.Add(jubjubClass); // 附加类到命名空间 // 定义实例构造函数 CodeConstructor jubjubCtor = new CodeConstructor { Attributes = MemberAttributes.Public }; // 定义参数 var para = new CodeParameterDeclarationExpression(typeof(int), "wabeCount"); jubjubCtor.Parameters.Add(para); // 附加参数到构造函数 // 添加 ArrayList 字段 var typerefArrayList = new CodeTypeReference("ArrayList"); CodeMemberField updatesFld = new CodeMemberField(typerefArrayList, "_updates"); jubjubClass.Members.Add(updatesFld); // 引用 _updates 字段 var refUpdatesFld = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_updates"); // 实例化 ArrayList var newArrayList = new CodeObjectCreateExpression(typerefArrayList); // 赋值 var assignUpdates = new CodeAssignStatement(refUpdatesFld, newArrayList); jubjubCtor.Statements.Add(assignUpdates); // 附加赋值语句到构造函数 // 引用 _wabeCount 字段 var refWabeCountFld = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "_wabeCount"); // 定义引用属性(用于赋值时进行判断) var refWabeCountProp = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "WabeCount"); // 定义引用参数 var refWabeCountArg = new CodeArgumentReferenceExpression("wabeCount"); // 定义赋值语句 var assignWabeCount = new CodeAssignStatement(refWabeCountProp, refWabeCountArg); jubjubCtor.Statements.Add(assignWabeCount); // 附加赋值语句到构造函数 jubjubClass.Members.Add(jubjubCtor); // 附加构造函数到类 // 定义成员属性 CodeMemberProperty wabeCountProp = new CodeMemberProperty() { Attributes = MemberAttributes.Public | MemberAttributes.Final, // Final == Nonvirtual Type = new CodeTypeReference(typeof(int)), Name = "WabeCount" }; // 为属性添加 get 语句 wabeCountProp.GetStatements.Add(new CodeMethodReturnStatement(refWabeCountFld)); // 为属性添加 set 语句 var suppliedPropertyValue = new CodePropertySetValueReferenceExpression(); // value var zero = new CodePrimitiveExpression(0); var suppliedPropValIsLessThanZero = new CodeBinaryOperatorExpression(suppliedPropertyValue, CodeBinaryOperatorType.LessThan, zero); // if/else 语句进行赋值判断, CodeDOM 不支持三元运算表达式 (value < 0) ? 0 : value; var testSuppliedPropValAndAssign = new CodeConditionStatement(suppliedPropValIsLessThanZero, new CodeStatement[] { new CodeAssignStatement(refWabeCountFld,zero) }, new CodeStatement[] { new CodeAssignStatement(refWabeCountFld,suppliedPropertyValue) }); wabeCountProp.SetStatements.Add(testSuppliedPropValAndAssign); wabeCountProp.SetStatements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(refUpdatesFld, "Add"), refWabeCountFld)); jubjubClass.Members.Add(wabeCountProp); // 附加属性到类 // 定义一个方法 CodeMemberMethod methGetWabeCountHistory = new CodeMemberMethod { Attributes = MemberAttributes.Public | MemberAttributes.Final, Name = "GetWabeCountHistory", ReturnType = new CodeTypeReference(typeof(string)) }; jubjubClass.Members.Add(methGetWabeCountHistory); // 附加方法到类 // 定义本地变量并实例化 methGetWabeCountHistory.Statements.Add(new CodeVariableDeclarationStatement("StringBuilder", "result")); var refResultVar = new CodeVariableReferenceExpression("result"); methGetWabeCountHistory.Statements.Add(new CodeAssignStatement(refResultVar, new CodeObjectCreateExpression("StringBuilder"))); // 定义本地变量 ndx methGetWabeCountHistory.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "ndx")); // 引用本地变量 ndx var refNdxVar = new CodeVariableReferenceExpression("ndx"); #region 创建 for 语句 // 赋值语句 ndx = 0 var initNdxVar = new CodeAssignStatement(refNdxVar, new CodePrimitiveExpression(0)); // 条件语句 ndx < this._updates.Count var testNdxWithUpdatesCount = new CodeBinaryOperatorExpression(refNdxVar, CodeBinaryOperatorType.LessThan, new CodePropertyReferenceExpression(refUpdatesFld, "Count")); // 自增语句 var incrementNdxVar = new CodeAssignStatement(refNdxVar, new CodeBinaryOperatorExpression(refNdxVar, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(1))); // 比较 if(ndx == 0) var compareNdxWithZero = new CodeBinaryOperatorExpression(refNdxVar, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(0)); // 方法调用 result.AppendFormat("{0}", this._updates[ndx]) var methAppendFormatInvoke = new CodeExpressionStatement( new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(refResultVar, "AppendFormat"), new CodePrimitiveExpression("{0}"), new CodeArrayIndexerExpression(refUpdatesFld, refNdxVar) ) ); // 方法调用 result.AppendFormat(", {0}", this._updates[ndx]) var methAppendFormtInvokeWithCommas = new CodeExpressionStatement( new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(refResultVar, "AppendFormat"), new CodePrimitiveExpression(", {0}"), new CodeArrayIndexerExpression(refUpdatesFld, refNdxVar) ) ); methGetWabeCountHistory.Statements.Add( new CodeIterationStatement(initNdxVar, testNdxWithUpdatesCount, incrementNdxVar, new CodeConditionStatement(compareNdxWithZero, new CodeStatement[] { methAppendFormatInvoke }, new CodeStatement[] { methAppendFormtInvokeWithCommas }))); #endregion // 定义返回值 methGetWabeCountHistory.Statements.Add( new CodeMethodReturnStatement( new CodeMethodInvokeExpression( new CodeMethodReferenceExpression(refResultVar, "ToString")))); return mimsyNamespace; }
private void GenerateAppEntryPoint() { if (ApplicationFile.Length > 0) { // [STAThread] // public static void Main () { // CodeMemberMethod cmmMain = GenerateEntryPointMethod(); if (cmmMain != null) { CodeVariableReferenceExpression cvreSplashScreen = null; if (!string.IsNullOrEmpty(_splashImage) && !HostInBrowser) { cvreSplashScreen = GenerateSplashScreenInstance(cmmMain); } // MyApplication app = new MyApplication(); // CodeVariableReferenceExpression cvreApp = GenerateAppInstance(cmmMain); if (_ccRoot.InitializeComponentFn != null) { // app.InitializeComponent(); // CodeMethodInvokeExpression cmieIT = new CodeMethodInvokeExpression(); cmieIT.Method = new CodeMethodReferenceExpression(cvreApp, INITIALIZE_COMPONENT); cmmMain.Statements.Add(new CodeExpressionStatement(cmieIT)); } if (!HostInBrowser) { // app.Run(); // CodeMethodReferenceExpression cmreRun = new CodeMethodReferenceExpression(cvreApp, "Run"); CodeMethodInvokeExpression cmieRun = new CodeMethodInvokeExpression(); cmieRun.Method = cmreRun; CodeStatement csRun = new CodeExpressionStatement(cmieRun); cmmMain.Statements.Add(csRun); } _ccRoot.CodeClass.Members.Add(cmmMain); } } }
private void GenerateInitializeComponent(bool isApp) { // public void InitializeComponent() // { // CodeMemberMethod cmmLC = _ccRoot.InitializeComponentFn; if (cmmLC == null) { cmmLC = _ccRoot.EnsureInitializeComponentFn; if (!isApp) { cmmLC.ImplementationTypes.Add(new CodeTypeReference(KnownTypes.Types[(int)KnownElements.IComponentConnector])); } } // if (_contentLoaded) // { // return; // } // CodeConditionStatement ccsCL = new CodeConditionStatement(); ccsCL.Condition = new CodeFieldReferenceExpression(null, CONTENT_LOADED); ccsCL.TrueStatements.Add(new CodeMethodReturnStatement()); if (!isApp) { cmmLC.Statements.Add(ccsCL); } else { cmmLC.Statements.Insert(0, ccsCL); } // _contentLoaded = true; // CodeAssignStatement casCL = new CodeAssignStatement(new CodeFieldReferenceExpression(null, CONTENT_LOADED), new CodePrimitiveExpression(true)); if (!isApp) { cmmLC.Statements.Add(casCL); } else { cmmLC.Statements.Insert(1, casCL); } // Generate canonicalized string as resource id. bool requestExtensionChange = false; string resourceID = ResourcesGenerator.GetResourceIdForResourceFile( SourceFileInfo.RelativeSourceFilePath + XAML, SourceFileInfo.OriginalFileLinkAlias, SourceFileInfo.OriginalFileLogicalName, TargetPath, Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar, requestExtensionChange); string uriPart = string.Empty; string version = String.IsNullOrEmpty(AssemblyVersion) ? String.Empty : COMPONENT_DELIMITER + VER + AssemblyVersion; string token = String.IsNullOrEmpty(AssemblyPublicKeyToken) ? String.Empty : COMPONENT_DELIMITER + AssemblyPublicKeyToken; uriPart = FORWARDSLASH + AssemblyName + version + token + COMPONENT_DELIMITER + COMPONENT + FORWARDSLASH + resourceID; // // Uri resourceLocator = new Uri(uriPart, UriKind.Relative); // string resVarname = RESOURCE_LOCATER; CodeFieldReferenceExpression cfreRelUri = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(System.UriKind)), "Relative"); CodeExpression[] uriParams = { new CodePrimitiveExpression(uriPart), cfreRelUri }; CodeObjectCreateExpression coceResourceLocator = new CodeObjectCreateExpression(typeof(System.Uri), uriParams); CodeVariableDeclarationStatement cvdsresLocator = new CodeVariableDeclarationStatement(typeof(System.Uri), resVarname, coceResourceLocator); cmmLC.Statements.Add(cvdsresLocator); // // System.Windows.Application.LoadComponent(this, resourceLocator); // CodeMethodReferenceExpression cmreLoadContent = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(KnownTypes.Types[(int)KnownElements.Application]), LOADCOMPONENT); CodeMethodInvokeExpression cmieLoadContent = new CodeMethodInvokeExpression(); cmieLoadContent.Method = cmreLoadContent; CodeVariableReferenceExpression cvreMemStm = new CodeVariableReferenceExpression(resVarname); cmieLoadContent.Parameters.Add(new CodeThisReferenceExpression()); cmieLoadContent.Parameters.Add(cvreMemStm); CodeExpressionStatement cesLC = new CodeExpressionStatement(cmieLoadContent); AddLinePragma(cesLC, 1); cmmLC.Statements.Add(cesLC); // private bool _contentLoaded; // CodeMemberField cmfCL = new CodeMemberField(); cmfCL.Name = CONTENT_LOADED; cmfCL.Attributes = MemberAttributes.Private; cmfCL.Type = new CodeTypeReference(typeof(bool)); _ccRoot.CodeClass.Members.Add(cmfCL); if (!isApp) { // Make sure that ICC.Connect is generated to avoid compilation errors EnsureHookupFn(); } }
private CodeStatement AddCLREvent(Type eventTarget, CodeContext cc, CodeExpression ce, MarkupEventInfo mei) { bool subClassed = _ccRoot.SubClass.Length > 0; CodeStatement csEvent = null; // param2: <FooEventHandler> CodeExpression cDelExp = GetEventDelegate(cc, mei.mi, mei.eventName, mei.eventHandler); if (mei.mi.DeclaringType.IsAssignableFrom(eventTarget)) { // _element.FooEvent += new FooEventHandlerDelegate(OnFoo); csEvent = new CodeAttachEventStatement(ce, mei.eventName, cDelExp); } else if (eventTarget == null || // for known attached events on unknown local tags KnownTypes.Types[(int)KnownElements.UIElement].IsAssignableFrom(eventTarget) || KnownTypes.Types[(int)KnownElements.ContentElement].IsAssignableFrom(eventTarget)) { // _element.AddHandler(FooEvent, new FooEventHandlerDelegate(OnFoo)); CodeFieldReferenceExpression cfreEvent = GetEvent(mei.mi, mei.eventName, mei.eventHandler); CodeMethodInvokeExpression cmieAddHandler = new CodeMethodInvokeExpression(ce, ADDHANDLER, cfreEvent, cDelExp); csEvent = new CodeExpressionStatement(cmieAddHandler); } else { string eventTargetName = eventTarget != null ? eventTarget.FullName : cc.LocalElementFullName; ThrowCompilerException(SRID.UnknownEventAttribute, mei.eventName, mei.eventHandler, eventTargetName); } // When x:SubClass is used, event handlers can be specified in a code-behind file, under this sub class. // But these handler methods need to be accessible from the intermediary generated sub class. So an empty // internal virtual method with the same signature as the handler method is generated in this intermediary // sub class (in the generated file): // // internal virtual void OnFooEvent(object sender, FooEventArgs ea) // { // } // // Since a delegate cannot take the address of a virtual function, a non-virtual helper function // with the same signature as the above function & which calls the above function is also generated: // // private void OnFooEventHelper(object sender, FooEventArgs ea) // { // OnFooEvent(sender, ea); // } // // All this is done only if x:Subclass is specified, since this means that this sub class would need to be // defined in a code-behind file. This also means that inline events (in <x:Code>) will not be supported. if (subClassed) { GenerateProtectedEventHandlerMethod(mei); } AddLinePragma(csEvent, mei.lineNumber); return csEvent; }
protected override void GenerateExpressionStatement (CodeExpressionStatement e) { }
internal override CodeStatement Clone() { CodeExpressionStatement newStatement = new CodeExpressionStatement(); newStatement.Expression = RuleExpressionWalker.Clone(exprStatement.Expression); return newStatement; }
private ExpressionStatement(CodeExpressionStatement exprStatement) { this.exprStatement = exprStatement; }
void Statements(List<CodeLine> lines) { for (int i = 0; i < lines.Count; i++) { #region Line string code = lines[i].Code; if (string.IsNullOrEmpty(code)) continue; line = lines[i].LineNumber; fileName = lines[i].FileName; #endregion #region Blocks var parent = blocks.Count > 0 ? blocks.Peek().Statements : main.Statements; string codeTrim = code.TrimStart(Spaces); int blocksCount = -1; if (codeTrim.Length > 0) { CodeBlock block; char sym = codeTrim[0]; bool skip = false; switch (sym) { case BlockOpen: if (blocks.Count == 0) { block = new CodeBlock(lines[i], Scope, new CodeStatementCollection(), CodeBlock.BlockKind.Dummy, blocks.Count == 0 ? null : blocks.Peek()); CloseTopSingleBlock(); blocks.Push(block); } block = blocks.Peek(); if (block.Type == CodeBlock.BlockType.Expect) block.Type = CodeBlock.BlockType.Within; skip = true; break; case BlockClose: if (blocks.Count == 0) throw new ParseException(ExUnexpected, lines[i]); CloseBlock(); skip = true; break; default: if (blocks.Count > 0 && blocks.Peek().Type == CodeBlock.BlockType.Expect) { blocksCount = blocks.Count; block = blocks.Peek(); block.Type = CodeBlock.BlockType.Within; block.Level = blocksCount; } break; } if (skip) { code = codeTrim.Substring(1); if (code.Length == 0) continue; lines[i].Code = code; } } codeTrim = null; #endregion #region Tokens var token = GetToken(code); try { switch (token) { case Token.Assign: var assign = ParseAssign(code); assign.LinePragma = lines[i]; parent.Add(assign); break; case Token.Command: var command = new CodeExpressionStatement(OptimiseExpression(ParseCommand(code))); if (command.Expression == null) continue; command.LinePragma = lines[i]; parent.Add(command); break; case Token.Label: var label = new CodeExpressionStatement(ParseLabel(lines[i])); label.LinePragma = lines[i]; parent.Add(label); break; case Token.Hotkey: var hotkey = ParseHotkey(lines, i); hotkey.LinePragma = lines[i]; parent.Add(hotkey); break; case Token.Flow: { var result = ParseFlow(lines, i); if (result != null) { for (int n = 0; n < result.Length; n++) result[n].LinePragma = lines[i]; parent.AddRange(result); } } break; case Token.Expression: { int n = i + 1; if (IsFunction(code, n < lines.Count ? lines[n].Code : string.Empty)) ParseFunction(lines[i]); else { var statements = ParseMultiExpression(code); for (n = 0; n < statements.Length; n++) { var expr = OptimiseLoneExpression(statements[n].Expression); if (expr == null) continue; else statements[n] = new CodeExpressionStatement(expr); statements[n].LinePragma = lines[n]; parent.Add(statements[n]); } } } break; case Token.Directive: ParseDirective(code); break; case Token.Unknown: default: throw new ParseException(ExUnexpected, lines[i]); } } #if !DEBUG catch (ParseException e) { throw new ParseException(e.Message, lines[i]); } #endif finally { } #endregion #region Blocks if (blocks.Count == blocksCount && blocks.Peek().IsSingle) CloseBlock(blocksCount, blocks.Count > blocksCount && blocksCount != -1); #endregion } #region Blocks CloseTopSingleBlocks(); CloseTopLabelBlock(); CloseTopSingleBlocks(); CloseSingleLoopBlocks(); if (blocks.Count > 0) throw new ParseException(ExUnclosedBlock, blocks.Peek().Line); #endregion }
protected override void GenerateExpressionStatement(System.CodeDom.CodeExpressionStatement e) { GenerateExpression(e.Expression); Output.WriteLine(";"); }