Inheritance: System.CodeDom.CodeExpression
        internal BindingElementExtensionSectionGenerator(Type bindingElementType, Assembly userAssembly, CodeDomProvider provider)
        {
            this.bindingElementType = bindingElementType;
            this.userAssembly = userAssembly;
            this.provider = provider;

            string typePrefix = bindingElementType.Name.Substring(0, bindingElementType.Name.IndexOf(TypeNameConstants.BindingElement));
            this.generatedClassName = typePrefix + Constants.ElementSuffix;
            this.constantsClassName = bindingElementType.Name.Substring(0, bindingElementType.Name.IndexOf(TypeNameConstants.BindingElement)) + Constants.ConfigurationStrings;
            this.defaultValuesClassName = bindingElementType.Name.Substring(0, bindingElementType.Name.IndexOf(TypeNameConstants.BindingElement)) + Constants.Defaults;

            this.customBEVarInstance = Helpers.TurnFirstCharLower(bindingElementType.Name);
            customBEArgRef = new CodeArgumentReferenceExpression(customBEVarInstance);

            this.customBETypeRef = new CodeTypeReference(bindingElementType.Name);
            this.customBETypeOfRef = new CodeTypeOfExpression(customBETypeRef);
            this.customBENewVarAssignRef = new CodeVariableDeclarationStatement(
                                                customBETypeRef,
                                                customBEVarInstance,
                                                new CodeObjectCreateExpression(customBETypeRef));
            this.bindingElementMethodParamRef = new CodeParameterDeclarationExpression(
                                                    CodeDomHelperObjects.bindingElementTypeRef,
                                                    Constants.bindingElementParamName);

        }
Beispiel #2
0
 void EmitArgumentReference(CodeArgumentReferenceExpression Argument)
 {
     Depth++;
     Debug("Emitting argument reference");
     Generator.Emit(OpCodes.Ldarg, 0); // for now only used to refer to the sole object[] parameter
     Depth--;
 }
		public void DefaultConstructor ()
		{
			CodeArgumentReferenceExpression care = new CodeArgumentReferenceExpression ();
			Assert.AreEqual (string.Empty, care.ParameterName, "#1");
			care.ParameterName = "mono";
			Assert.AreEqual ("mono", care.ParameterName, "#2");
		}
		public void NullParameter ()
		{
			CodeArgumentReferenceExpression care = new CodeArgumentReferenceExpression ((string) null);
			Assert.AreEqual (string.Empty, care.ParameterName, "#1");
			care.ParameterName = null;
			Assert.AreEqual (string.Empty, care.ParameterName, "#2");
		}
 public TypescriptArgumentReferenceExpression(
     CodeArgumentReferenceExpression codeExpression, 
     CodeGeneratorOptions options)
 {
     _codeExpression = codeExpression;
     _options = options;
     System.Diagnostics.Debug.WriteLine("TypescriptArgumentReferenceExpression Created");
 }
Beispiel #6
0
        // Generate the CodeDom for our render method
        internal CodeMemberMethod GenerateRenderMemberMethod(string virtualPath)
        {
            Control container = Parent;

            string physicalPath = HostingEnvironment.MapPath(virtualPath);

            CodeMemberMethod renderMethod = new CodeMemberMethod();
            renderMethod.Name = RenderMethodName;
            renderMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "__srh"));

            // REVIEW: we need support for CodeArgumentReferenceExpression, as using a snippet is
            // not guanranteed to be language agnostic
            CodeExpression snippetRenderHelper = new CodeArgumentReferenceExpression("__srh");

            // Go through all the children to build the CodeDOM tree
            for (int controlIndex = 0; controlIndex < container.Controls.Count; controlIndex++) {
                Control c = container.Controls[controlIndex];

                if (!(c is SnippetControl || c is ExpressionSnippetControl)) {

                    // If it's a regular control, generate a call to render it based on its index

                    CodeExpression method = new CodeMethodInvokeExpression(snippetRenderHelper, "RenderControl",
                        new CodePrimitiveExpression(controlIndex));
                    renderMethod.Statements.Add(new CodeExpressionStatement(method));

                    continue;
                }

                BaseCodeControl codeControl = (BaseCodeControl)c;

                string code = codeControl.Code;
                CodeStatement stmt;

                if (codeControl is SnippetControl) {

                    // If it's a <% code %> block, just append the code as is

                    stmt = new CodeSnippetStatement(code);
                } else {

                    // If it's a <%= expr %> block, generate a call to render it

                    CodeExpression method = new CodeMethodInvokeExpression(snippetRenderHelper, "Render",
                        new CodeSnippetExpression(code));
                    stmt = new CodeExpressionStatement(method);
                }

                stmt.LinePragma = new CodeLinePragma(physicalPath, codeControl.Line);
                renderMethod.Statements.Add(stmt);
            }

            return renderMethod;
        }
Beispiel #7
0
      	public override void EmitApply (CodeMemberMethod apply, CodeArgumentReferenceExpression proj,
					CodeArgumentReferenceExpression declloc, 
					CodeArgumentReferenceExpression log, 
					CodeVariableReferenceExpression pb,
					CodeVariableReferenceExpression tb)
	{
	    apply.Statements.Add (new CodeCommentStatement ("Create provider for param " +
							    basisparam));

	    CodeMethodInvokeExpression mie = new CodeMethodInvokeExpression ();
	    mie.Method = new CodeMethodReferenceExpression (proj, "EnsureProvider");
	    mie.Parameters.Add (new CodeFieldReferenceExpression (CDH.This, basisparam));
	    mie.Parameters.Add (declloc);

	    apply.Statements.Add (new CodeAssignStatement (pb, mie));

	    // Tell the PB about our Structure arguments so it can
	    // use them to instantiate the objects we reference.
	    // FIXME: catch if the provider references a rule or template 
	    // that requires a structure we don't have.

	    //if (Structure != null) {
	    mie = new CodeMethodInvokeExpression ();
	    mie.Method = new CodeMethodReferenceExpression (pb, "AddContextStructure");
	    mie.Parameters.Add (CDH.This);
	    apply.Statements.Add (mie);

	    foreach (string param in Structure.Parameters) {
		if (Structure[param] != StructureParameterKind.Structure)
		    continue;
		
		mie = new CodeMethodInvokeExpression ();
		mie.Method = new CodeMethodReferenceExpression (pb, "AddContextStructure");
		mie.Parameters.Add (new CodeFieldReferenceExpression (CDH.This, param));
		apply.Statements.Add (mie);
	    }
	    //}

	    foreach (BGTargetBuilder iter in targs)
		iter.EmitApply (apply, pb, tb, log);

	    foreach (string key in lits.Keys) {
		CodeExpression val = CDH.ResultExpression (lits[key]);

		CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression ();
		cmie.Method = new CodeMethodReferenceExpression (pb, "DefineConstantTarget");
		cmie.Parameters.Add (new CodePrimitiveExpression (key));
		cmie.Parameters.Add (val);
		cmie.Parameters.Add (log);

		apply.Statements.Add (CDH.IfTrueReturnTrue (cmie));
	    }
	}
Beispiel #8
0
		public CodeNamespace GenerateCode(XmlReader reader)
		{
			CodeTypeDeclaration templateType = new CodeTypeDeclaration(defaultTypeName);
			templateType.Attributes = MemberAttributes.Family;
			templateType.IsPartial = true;
			CodeNamespace templateNamespace = new CodeNamespace(defaultTargetNamespace);
			templateNamespace.Types.Add(templateType);
			AddCommonImports(templateNamespace);

			CodeMemberMethod renderMethod = new CodeMemberMethod();
			renderMethod.Name = "Render";
			renderMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
			renderMethod.Parameters.Add(new CodeParameterDeclarationExpression(
				typeof(XmlWriter), "writer"));

			CodeArgumentReferenceExpression writerExpression = new CodeArgumentReferenceExpression("writer");
			templateType.Members.Add(renderMethod);

			templateType.Members.Add(BuildConverter());

			while (reader.Read())
			{
				if (reader.NodeType == XmlNodeType.ProcessingInstruction)
				{
					ThrowIfUnknownInstruction(reader);

					if (typeInstructions.ContainsKey(reader.LocalName))
					{
						ITypeInstruction ti = typeInstructions[reader.LocalName];
						ti.Process(reader.Value, templateNamespace, templateType, renderMethod);
					}
					if (inlineInstructions.ContainsKey(reader.LocalName))
					{
						IInlineInstruction ii = inlineInstructions[reader.LocalName];
						CodeStatementCollection col = ii.Process(reader.Value);
						renderMethod.Statements.AddRange(col);
					}
				}
				else
				{
					renderMethod.Statements.AddRange(
						generationFunctions[reader.NodeType](reader, writerExpression));
				}
			}

			return templateNamespace;
		}
        public static void GenerateConstructor(CodeTypeDeclaration classDecl)
        {
            CodeConstructor constructorMember = new CodeConstructor() ;

            constructorMember.Attributes = MemberAttributes.Public;

            CodeParameterDeclarationExpression parameter = new CodeParameterDeclarationExpression(new CodeTypeReference("IContext"), "context");
            constructorMember.Parameters.Add(parameter);

            CodeThisReferenceExpression thisExp = new CodeThisReferenceExpression();
            CodeFieldReferenceExpression ctxFieldExp = new CodeFieldReferenceExpression(thisExp, "context");

            CodeArgumentReferenceExpression argExp = new CodeArgumentReferenceExpression("context");
            CodeAssignStatement assignStatement = new CodeAssignStatement(ctxFieldExp, argExp);
            constructorMember.Statements.Add(assignStatement);

            classDecl.Members.Add(constructorMember);
        }
Beispiel #10
0
		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());
		}
        public CodeStatement GenerateExecuteQueryBody(CodeMemberMethod method)
        {
            var dataAccessReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), DataAccessVariableName);
            var methodArgumentReferences = new CodeArgumentReferenceExpression[method.Parameters.Count];

            for (int i = 0; i < method.Parameters.Count; i++)
            {
                methodArgumentReferences[i] = new CodeArgumentReferenceExpression(method.Parameters[i].Name);
            }

            var invocationExpression = new CodeMethodInvokeExpression(dataAccessReference, ExecuteSqlQueryMethodName, methodArgumentReferences);

            if (method.ReturnType.BaseType != "System.Void")
            {
                return new CodeMethodReturnStatement(invocationExpression);
            }
            else
            {
                return new CodeExpressionStatement(invocationExpression);
            }
        }
Beispiel #12
0
        static CodeMemberMethod addDispose(CodeTypeDeclaration ctd, CodeMemberMethod m, CodeMemberField fContainer)
        {
            CodeArgumentReferenceExpression ar0;
            CodeConditionStatement ccs, ccs1;
            CodeFieldReferenceExpression fr;

            ar0 = new CodeArgumentReferenceExpression("disposing");

            ctd.Members.Add(m = new CodeMemberMethod());
            m.Name = "Dispose";
            m.Attributes = MemberAttributes.Override | MemberAttributes.Family;
            m.Parameters.Add(new CodeParameterDeclarationExpression(typeof(bool), ar0.ParameterName));

            fr = new CodeFieldReferenceExpression(null, fContainer.Name);
            ccs = new CodeConditionStatement(ar0, ccs1 = new CodeConditionStatement());
            ccs1.Condition = new CodeBinaryOperatorExpression(
                fr,
                CodeBinaryOperatorType.IdentityInequality,
                new CodePrimitiveExpression());
            ccs1.TrueStatements.Add(
                new CodeExpressionStatement(
                    new CodeMethodInvokeExpression(fr, "Dispose")));
            m.Statements.AddRange(
                new CodeStatement[] {
                    ccs,
                    new CodeExpressionStatement(
                        new CodeMethodInvokeExpression(
                            new CodeBaseReferenceExpression(),
                            "Dispose",ar0))
            });
            m.Comments.AddRange(
                new CodeCommentStatement[]{
                    new CodeCommentStatement("<summary>\n Clean up any resources being used.\n </summary>",true)
                }
                );
            return m;
        }
        internal void ConnectNameAndEvents(string elementName, ArrayList events, int connectionId)
        {
            CodeContext cc = (CodeContext)_codeContexts.Peek();
            bool isAllowedNameScope = cc.IsAllowedNameScope;

            if (_codeContexts.Count > 1 && KnownTypes.Types[(int)KnownElements.INameScope].IsAssignableFrom(cc.ElementType))
            {
                cc.IsAllowedNameScope = false;
            }

            if ((elementName == null || !isAllowedNameScope) && (events == null || events.Count == 0))
            {
                _typeArgsList = null;
                return;
            }

            EnsureHookupFn();

            CodeConditionStatement ccsConnector = null;

            if (SwitchStatementSupported())
            {
                // case 1:
                //
                CodeSnippetStatement cssCase = new CodeSnippetStatement(CASE_STATEMENT + connectionId + COLON);
                _ccRoot.HookupFn.Statements.Add(cssCase);
            }
            else
            {
                // if (connectionId == 1)
                //
                ccsConnector = new CodeConditionStatement();
                ccsConnector.Condition = new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression(CONNECTIONID),
                                                                          CodeBinaryOperatorType.ValueEquality,
                                                                          new CodePrimitiveExpression(connectionId));
            }


            // (System.Windows.Controls.Footype)target;
            CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET);
            CodeCastExpression cceTarget = new CodeCastExpression(cc.ElementTypeReference, careTarget);
            CodeExpression ceEvent = cceTarget;

            // Names in nested Name scopes not be hooked up via ICC.Connect() as no fields are generated in this case.
            if (elementName != null && isAllowedNameScope)
            {
                // this.fooId = (System.Windows.Controls.Footype)target;
                //
                ceEvent = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), elementName);
                CodeAssignStatement casName = new CodeAssignStatement(ceEvent, cceTarget);
                if (SwitchStatementSupported())
                {
                    _ccRoot.HookupFn.Statements.Add(casName);
                }
                else
                {
                    ccsConnector.TrueStatements.Add(casName);
                }
            }

            if (events != null)
            {
                foreach (MarkupEventInfo mei in events)
                {
                    CodeStatement csEvent = AddCLREvent(cc, ceEvent, mei);

                    if (SwitchStatementSupported())
                    {
                        _ccRoot.HookupFn.Statements.Add(csEvent);
                    }
                    else
                    {
                        ccsConnector.TrueStatements.Add(csEvent);
                    }
                }
            }

            // return;
            //
            if (SwitchStatementSupported())
            {
                _ccRoot.HookupFn.Statements.Add(new CodeMethodReturnStatement());
            }
            else
            {
                ccsConnector.TrueStatements.Add(new CodeMethodReturnStatement());
                _ccRoot.HookupFn.Statements.Add(ccsConnector);
            }

            _typeArgsList = null;
        }
        private void GenerateInternalTypeHelperImplementation()
        {
            if (!IsInternalAccessSupported ||
                !(HasInternals || HasLocalReference) ||
                _hasGeneratedInternalTypeHelper)
            {
                return;
            }

            _hasGeneratedInternalTypeHelper = true;

            // namespace XamlGeneratedNamespace
            // {
            //
            CodeNamespace cns = new CodeNamespace();
            cns.Name = XamlTypeMapper.GeneratedNamespace;

            //     [EditorBrowsable(EditorBrowsableState.Never)]
            //     public sealed class GeneratedInternalTypeHelper : InternalTypeHelper
            //     {
            //
            CodeTypeDeclaration ctdClass = new CodeTypeDeclaration();
            ctdClass.Name = XamlTypeMapper.GeneratedInternalTypeHelperClassName;
            ctdClass.BaseTypes.Add(new CodeTypeReference("System.Windows.Markup.InternalTypeHelper"));
            ctdClass.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
            AddDebuggerNonUserCodeAttribute(ctdClass);
            AddGeneratedCodeAttribute(ctdClass);
            AddEditorBrowsableAttribute(ctdClass);
            GenerateXmlComments(ctdClass, ctdClass.Name);

            //         protected override object CreateInstance(Type type, CultureInfo culture)
            //         {
            //             return Activator.CreateInstance(type,
            //                                             BindingFlags.Public |
            //                                             BindingFlags.NonPublic |
            //                                             BindingFlags.Instance |
            //                                             BindingFlags.CreateInstance,
            //                                             null,
            //                                             null,
            //                                             culture);
            //         }
            //
            CodeMemberMethod cmmCI = new CodeMemberMethod();
            cmmCI.Name = "CreateInstance";
            cmmCI.Attributes = MemberAttributes.Family | MemberAttributes.Override;
            cmmCI.ReturnType = new CodeTypeReference(typeof(Object));

            CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(Type), TYPE);
            CodeParameterDeclarationExpression param4 = new CodeParameterDeclarationExpression(typeof(CultureInfo), CULTURE);
            cmmCI.Parameters.Add(param1);
            cmmCI.Parameters.Add(param4);

            CodeMethodReferenceExpression cmreCI = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Activator)), "CreateInstance");
            CodeMethodInvokeExpression cmieCI = new CodeMethodInvokeExpression();
            cmieCI.Method = cmreCI;
            cmieCI.Parameters.Add(new CodeArgumentReferenceExpression(TYPE));
            CodeFieldReferenceExpression cfre1 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "Public");
            CodeFieldReferenceExpression cfre2 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "NonPublic");
            CodeFieldReferenceExpression cfre3 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "Instance");
            CodeFieldReferenceExpression cfre4 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "CreateInstance");
            CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(cfre1, CodeBinaryOperatorType.BitwiseOr, cfre2);
            CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(cfre3, CodeBinaryOperatorType.BitwiseOr, cfre4);
            CodeBinaryOperatorExpression cboeCI = new CodeBinaryOperatorExpression(cboe1, CodeBinaryOperatorType.BitwiseOr, cboe2);
            cmieCI.Parameters.Add(cboeCI);
            cmieCI.Parameters.Add(new CodePrimitiveExpression(null));
            cmieCI.Parameters.Add(new CodePrimitiveExpression(null));
            cmieCI.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE));

            cmmCI.Statements.Add(new CodeMethodReturnStatement(cmieCI));
            GenerateXmlComments(cmmCI, cmmCI.Name);
            ctdClass.Members.Add(cmmCI);

            //         protected override object GetPropertyValue(PropertyInfo propertyInfo, object target, CultureInfo culture)
            //         {
            //             return propertyInfo.GetValue(target, BindingFlags.Default, null, null, culture);
            //         }
            //
            CodeMemberMethod cmmGPV = new CodeMemberMethod();
            cmmGPV.Name = "GetPropertyValue";
            cmmGPV.Attributes = MemberAttributes.Family | MemberAttributes.Override;
            cmmGPV.ReturnType = new CodeTypeReference(typeof(Object));

            param1 = new CodeParameterDeclarationExpression(typeof(PropertyInfo), PROPINFO);
            CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(typeof(object), TARGET);
            cmmGPV.Parameters.Add(param1);
            cmmGPV.Parameters.Add(param2);
            cmmGPV.Parameters.Add(param4);

            CodeMethodReferenceExpression cmreGPV = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(PROPINFO), "GetValue");
            CodeMethodInvokeExpression cmieGPV = new CodeMethodInvokeExpression();
            cmieGPV.Method = cmreGPV;
            cmieGPV.Parameters.Add(new CodeArgumentReferenceExpression(TARGET));
            cmieGPV.Parameters.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), DEFAULT));
            cmieGPV.Parameters.Add(new CodePrimitiveExpression(null));
            cmieGPV.Parameters.Add(new CodePrimitiveExpression(null));
            cmieGPV.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE));

            cmmGPV.Statements.Add(new CodeMethodReturnStatement(cmieGPV));
            GenerateXmlComments(cmmGPV, cmmGPV.Name);
            ctdClass.Members.Add(cmmGPV);

            //         protected override void SetPropertyValue(PropertyInfo propertyInfo, object target, object value, CultureInfo culture)
            //         {
            //             propertyInfo.SetValue(target, value, BindingFlags.Default, null, null, culture);
            //         }
            //
            CodeMemberMethod cmmSPV = new CodeMemberMethod();
            cmmSPV.Name = "SetPropertyValue";
            cmmSPV.Attributes = MemberAttributes.Family | MemberAttributes.Override;

            CodeParameterDeclarationExpression param3 = new CodeParameterDeclarationExpression(typeof(object), VALUE);
            cmmSPV.Parameters.Add(param1);
            cmmSPV.Parameters.Add(param2);
            cmmSPV.Parameters.Add(param3);
            cmmSPV.Parameters.Add(param4);

            CodeMethodReferenceExpression cmreSPV = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(PROPINFO), "SetValue");
            CodeMethodInvokeExpression cmieSPV = new CodeMethodInvokeExpression();
            cmieSPV.Method = cmreSPV;
            cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(TARGET));
            cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(VALUE));
            cmieSPV.Parameters.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), DEFAULT));
            cmieSPV.Parameters.Add(new CodePrimitiveExpression(null));
            cmieSPV.Parameters.Add(new CodePrimitiveExpression(null));
            cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE));

            cmmSPV.Statements.Add(new CodeExpressionStatement(cmieSPV));
            GenerateXmlComments(cmmSPV, cmmSPV.Name);
            ctdClass.Members.Add(cmmSPV);

            //         protected override Delegate CreateDelegate(Type delegateType, object target, string handler)
            //         {
            //             return (Delegate)target.GetType().InvokeMember("_CreateDelegate",
            //                                                            BindingFlags.Instance |
            //                                                            BindingFlags.NonPublic |
            //                                                            BindingFlags.InvokeMethod,
            //                                                            null,
            //                                                            target,
            //                                                            new object[] { delegateType, handler });
            //         }
            //
            CodeMemberMethod cmmCD = new CodeMemberMethod();
            cmmCD.Name = "CreateDelegate";
            cmmCD.Attributes = MemberAttributes.Family | MemberAttributes.Override;
            cmmCD.ReturnType = new CodeTypeReference(typeof(Delegate));

            param1 = new CodeParameterDeclarationExpression(typeof(Type), DELEGATETYPE);
            param3 = new CodeParameterDeclarationExpression(typeof(string), HANDLERARG);
            cmmCD.Parameters.Add(param1);
            cmmCD.Parameters.Add(param2);
            cmmCD.Parameters.Add(param3);

            CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET);
            CodeMethodReferenceExpression cmreGetType = new CodeMethodReferenceExpression(careTarget, "GetType");
            CodeMethodInvokeExpression cmieGetType = new CodeMethodInvokeExpression();
            cmieGetType.Method = cmreGetType;

            CodeMethodReferenceExpression cmreCD = new CodeMethodReferenceExpression(cmieGetType, "InvokeMember");
            CodeMethodInvokeExpression cmieCD = new CodeMethodInvokeExpression();
            cmieCD.Method = cmreCD;
            cmieCD.Parameters.Add(new CodePrimitiveExpression(CREATEDELEGATEHELPER));

            CodeFieldReferenceExpression cfre5 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "InvokeMethod");
            CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(cfre2, CodeBinaryOperatorType.BitwiseOr, cfre3);
            CodeBinaryOperatorExpression cboeCD = new CodeBinaryOperatorExpression(cfre5, CodeBinaryOperatorType.BitwiseOr, cboe);
            cmieCD.Parameters.Add(cboeCD);

            cmieCD.Parameters.Add(new CodePrimitiveExpression(null));
            cmieCD.Parameters.Add(careTarget);

            CodeArrayCreateExpression caceCD = new CodeArrayCreateExpression(typeof(object));
            CodeArgumentReferenceExpression careDelType = new CodeArgumentReferenceExpression(DELEGATETYPE);
            CodeArgumentReferenceExpression careHandler = new CodeArgumentReferenceExpression(HANDLERARG);
            caceCD.Initializers.Add(careDelType);
            caceCD.Initializers.Add(careHandler);
            cmieCD.Parameters.Add(caceCD);
            cmieCD.Parameters.Add(new CodePrimitiveExpression(null));

            CodeCastExpression cceCD = new CodeCastExpression(typeof(Delegate), cmieCD);
            cmmCD.Statements.Add(new CodeMethodReturnStatement(cceCD));
            GenerateXmlComments(cmmCD, cmmCD.Name);
            ctdClass.Members.Add(cmmCD);

            //         protected override void AddEventHandler(EventInfo eventInfo, object target, Delegate handler);
            //         {
            //             eventInfo.AddEventHandler(target, handler);
            //         }
            //
            CodeMemberMethod cmmAEH = new CodeMemberMethod();
            cmmAEH.Name = "AddEventHandler";
            cmmAEH.Attributes = MemberAttributes.Family | MemberAttributes.Override;

            param1 = new CodeParameterDeclarationExpression(typeof(EventInfo), EVENTINFO);
            param3 = new CodeParameterDeclarationExpression(typeof(Delegate), HANDLERARG);
            cmmAEH.Parameters.Add(param1);
            cmmAEH.Parameters.Add(param2);
            cmmAEH.Parameters.Add(param3);

            CodeMethodReferenceExpression cmreAEH = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(EVENTINFO), "AddEventHandler");
            CodeMethodInvokeExpression cmieAEH = new CodeMethodInvokeExpression();
            cmieAEH.Method = cmreAEH;
            cmieAEH.Parameters.Add(new CodeArgumentReferenceExpression(TARGET));
            cmieAEH.Parameters.Add(new CodeArgumentReferenceExpression(HANDLERARG));

            cmmAEH.Statements.Add(new CodeExpressionStatement(cmieAEH));
            GenerateXmlComments(cmmAEH, cmmAEH.Name);
            ctdClass.Members.Add(cmmAEH);

            //     }
            //
            cns.Types.Add(ctdClass);

            // }
            //
            CodeCompileUnit ccu = new CodeCompileUnit();
            ccu.Namespaces.Add(cns);

            // For VB only we need to let the parser know about the RootNamespace value
            // in order to look for the XamlGeneratedNamespace.GeneratedInternalTypeHelper
            // type whose full type name would have been implicitly by the VB comopiler to
            // RootNS.XamlGeneratedNamespace.GeneratedInternalTypeHelper

            if (IsLanguageVB && !string.IsNullOrEmpty(DefaultNamespace))
            {
                // [assembly: RootNamespaceAttribute("RootNS")]
                CodeAttributeDeclaration cad = new CodeAttributeDeclaration(
                             "System.Windows.Markup.RootNamespaceAttribute",
                             new CodeAttributeArgument(new CodePrimitiveExpression(DefaultNamespace)));

                ccu.AssemblyCustomAttributes.Add(cad);
            }

            MemoryStream codeMemStream = new MemoryStream();

            // using Disposes the StreamWriter when it ends.  Disposing the StreamWriter
            // also closes the underlying MemoryStream.  Furthermore, don't add BOM here since
            // TaskFileService.WriteGeneratedCodeFile adds it.
            using (StreamWriter codeStreamWriter = new StreamWriter(codeMemStream, new UTF8Encoding(false)))
            {
                CodeGeneratorOptions o = new CodeGeneratorOptions();
                CodeDomProvider codeProvider = EnsureCodeProvider();
                codeProvider.GenerateCodeFromCompileUnit(ccu, codeStreamWriter, o);

                codeStreamWriter.Flush();
                TaskFileService.WriteGeneratedCodeFile(codeMemStream.ToArray(),
                    TargetPath + SharedStrings.GeneratedInternalTypeHelperFileName,
                    SharedStrings.GeneratedExtension, SharedStrings.IntellisenseGeneratedExtension,
                    LanguageSourceExtension);
            }
        }
		private CodeExpression[] ExportMessages (MessageDescriptionCollection messages, CodeMemberMethod method, bool return_args)
		{
			CodeExpression [] args = null;
			foreach (MessageDescription md in messages) {
				if (md.Direction == MessageDirection.Output) {
					if (md.Body.ReturnValue != null) {
						ExportDataContract (md.Body.ReturnValue);
						method.ReturnType = md.Body.ReturnValue.CodeTypeReference;
					}
					continue;
				}

				if (return_args)
					args = new CodeExpression [md.Body.Parts.Count];

				MessagePartDescriptionCollection parts = md.Body.Parts;
				for (int i = 0; i < parts.Count; i++) {
					ExportDataContract (parts [i]);

					method.Parameters.Add (
						new CodeParameterDeclarationExpression (
							parts [i].CodeTypeReference,
							parts [i].Name));

					if (return_args)
						args [i] = new CodeArgumentReferenceExpression (parts [i].Name);
				}
			}

			return args;
		}
Beispiel #16
0
 protected override void GenerateArgumentReferenceExpression(CodeArgumentReferenceExpression e)
 {
     this.OutputIdentifier(e.ParameterName);
 }
Beispiel #17
0
		protected override void GenerateArgumentReferenceExpression (CodeArgumentReferenceExpression e)
		{
		}
		protected override void AddStatementsToInitMethod (CodeMemberMethod method)
		{
#if NET_2_0
			AddStatementsFromDirective (method);
			ILocation directiveLocation = pageParser.DirectiveLocation;

			CodeArgumentReferenceExpression ctrlVar = new CodeArgumentReferenceExpression("__ctrl");
			if (pageParser.Title != null)
				method.Statements.Add (AddLinePragma (CreatePropertyAssign (ctrlVar, "Title", pageParser.Title), directiveLocation));

			if (pageParser.MasterPageFile != null)
				method.Statements.Add (AddLinePragma (CreatePropertyAssign (ctrlVar, "MasterPageFile", pageParser.MasterPageFile), directiveLocation));

			if (pageParser.Theme != null)
				method.Statements.Add (AddLinePragma (CreatePropertyAssign (ctrlVar, "Theme", pageParser.Theme), directiveLocation));

			if (pageParser.StyleSheetTheme != null)
				method.Statements.Add (AddLinePragma (CreatePropertyAssign (ctrlVar, "StyleSheetTheme", pageParser.StyleSheetTheme), directiveLocation));

			if (pageParser.Async != false)
				method.Statements.Add (AddLinePragma (CreatePropertyAssign (ctrlVar, "AsyncMode", pageParser.Async), directiveLocation));

			if (pageParser.AsyncTimeout != -1)
				method.Statements.Add (AddLinePragma (CreatePropertyAssign (ctrlVar, "AsyncTimeout",
											    TimeSpan.FromSeconds (pageParser.AsyncTimeout)), directiveLocation));

			CodeMethodInvokeExpression expr = new CodeMethodInvokeExpression (thisRef, "InitializeCulture");
			method.Statements.Add (AddLinePragma (new CodeExpressionStatement (expr), directiveLocation));
#endif
		}
		private void CreateVertexInputMethods()
		{
			AsmListing asmVS = this.source.GetAsmTechnique(this.techniqueName, this.platform).VertexShader;

			//create the GetVertexInputCount() and GetVertexInput() methods

			CodeMemberMethod count = new CodeMemberMethod();
			count.Name = "GetVertexInputCountImpl";
			count.Attributes = MemberAttributes.Family | MemberAttributes.Override;
			count.ReturnType = new CodeTypeReference(typeof(int));

			Comment(count, "Returns the number of vertex inputs used by this shader");
			count.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(asmVS.InputCount)));
			classDom.Members.Add(count);

			//inputs are stored in a static array

			//create it...

			int[] arrayValues = new int[asmVS.InputCount * 2];
			for (int i = 0; i < asmVS.InputCount; i++)
			{
				arrayValues[i] = (int)asmVS.GetInput(i).Usage;
				arrayValues[i + asmVS.InputCount] = (int)asmVS.GetInput(i).Index;
			}

			this.vsInputField = new CodeMemberField(typeof(int[]), "vin");
			this.vsInputField.Attributes = MemberAttributes.Private | MemberAttributes.Static | MemberAttributes.Final;
			this.vsInputField.InitExpression = ShaderBytes.ToArray(arrayValues, this.directives);

			CodeFieldReferenceExpression vsInputRef = new CodeFieldReferenceExpression(ShaderClassEx, vsInputField.Name);

			//protected internal abstract void GetVertexInput(int index, out VertexElementUsage elementUsage, out int elementIndex);

			CodeMemberMethod getInput = new CodeMemberMethod();
			getInput.Name = "GetVertexInputImpl";
			getInput.Attributes = MemberAttributes.Family | MemberAttributes.Override;

			CodeParameterDeclarationExpression indexParam = new CodeParameterDeclarationExpression(typeof(int),"i");
			getInput.Parameters.Add(indexParam);

			CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(VertexElementUsage), "usage");
			param.Direction = FieldDirection.Out;
			getInput.Parameters.Add(param);

			param = new CodeParameterDeclarationExpression(typeof(int), "index");
			param.Direction = FieldDirection.Out;
			getInput.Parameters.Add(param);

			CodeArgumentReferenceExpression indexRef = new CodeArgumentReferenceExpression(indexParam.Name);

			//the element index is stored at 'i + asmVS.InputCount'
			CodeExpression indexArray = new CodeArrayIndexerExpression(vsInputRef,
				new CodeBinaryOperatorExpression(indexRef, CodeBinaryOperatorType.Add, new CodePrimitiveExpression(asmVS.InputCount)));

			//and the usage must be cast
			CodeExpression usageCast = new CodeCastExpression(typeof(VertexElementUsage), new CodeArrayIndexerExpression(vsInputRef,indexRef));

			getInput.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("usage"), usageCast));
			getInput.Statements.Add(new CodeAssignStatement(new CodeArgumentReferenceExpression("index"), indexArray));

			Comment(getInput, "Returns a vertex input used by this shader");

			classDom.Members.Add(getInput);
		}
		//implement the code generation methods

		private void SetupMembers(string name)
		{
			shaderTypeRef = new CodeTypeReference(name);
			gdIndexRef = new CodeFieldReferenceExpression(ShaderClassEx, "gd");

			shaderSystemDecl = new CodeParameterDeclarationExpression(typeof(ShaderSystemBase), "state");
			shaderSystemRef = new CodeArgumentReferenceExpression("state");

			graphicsIDInit = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "gdInit");

			validateDeviceId = new CodeConditionStatement(new CodeBinaryOperatorExpression(GraphicsDeviceUID, CodeBinaryOperatorType.IdentityInequality, new CodePropertyReferenceExpression(ShaderSystemRef, "DeviceUniqueIndex")),
				new CodeExpressionStatement(new CodeMethodInvokeExpression(graphicsIDInit, shaderSystemRef)));

			validateDeviceIdAndWarmShader = new CodeConditionStatement(new CodeBinaryOperatorExpression(GraphicsDeviceUID, CodeBinaryOperatorType.IdentityInequality, new CodePropertyReferenceExpression(ShaderSystemRef, "DeviceUniqueIndex")),
				new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "WarmShader", shaderSystemRef)));

			bindInstanceChange = new CodeVariableReferenceExpression("ic");
			//bindTypeChange = new CodeVariableReferenceExpression("tc");
			extensionModeChange = new CodeVariableReferenceExpression("ec");
			shaderExtensionMode = new CodeVariableReferenceExpression("ext");

			shaderExtensionIsBlending = new CodeBinaryOperatorExpression(shaderExtensionMode, CodeBinaryOperatorType.IdentityEquality, new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(ShaderExtension)), "Blending"));
			shaderExtensionIsInstancing = new CodeBinaryOperatorExpression(shaderExtensionMode, CodeBinaryOperatorType.IdentityEquality, new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(ShaderExtension)), "Instancing"));
	
			effectRef = new CodeFieldReferenceExpression(ShaderClassEx, "fx");
			effectBytesRef = new CodeFieldReferenceExpression(ShaderClassEx, "fxb");

			vsRegRef = new CodeFieldReferenceExpression(Instance, "vreg");
			psRegRef = new CodeFieldReferenceExpression(Instance, "preg");

			vsRegChangeRef = new CodeFieldReferenceExpression(Instance, "vreg_change");
			psRegChangeRef = new CodeFieldReferenceExpression(Instance, "preg_change");

			vsBlendRegRef = new CodeFieldReferenceExpression(Instance, "vbreg");
			vsInstancingRegRef = new CodeFieldReferenceExpression(Instance, "vireg");

			vsBlendRegChangeRef = new CodeFieldReferenceExpression(Instance, "vbreg_change");
			vsInstancingRegChangeRef = new CodeFieldReferenceExpression(Instance, "vireg_change");

			vsBooleanRegRef = new CodeFieldReferenceExpression(Instance, "vreg_bool");
			psBooleanRegRef = new CodeFieldReferenceExpression(Instance, "preg_bool");

			vsBooleanRegChangeRef = new CodeFieldReferenceExpression(Instance, "vreg_bool_change");
			psBooleanRegChangeRef = new CodeFieldReferenceExpression(Instance, "preg_bool_change");

			setAttribIdRef = new CodeArgumentReferenceExpression("id");
			setAttribValueRef = new CodeArgumentReferenceExpression("value");
		}
Beispiel #21
0
		protected override void GenerateArgumentReferenceExpression (CodeArgumentReferenceExpression expression)
		{
			Output.Write (CreateEscapedIdentifier (expression.ParameterName));
		}
Beispiel #22
0
 protected override void GenerateArgumentReferenceExpression(System.CodeDom.CodeArgumentReferenceExpression e)
 {
     throw new Exception("The method or operation is not implemented.");
 }
Beispiel #23
0
        private static void AddConstructorWithCopiedParameters(CodeTypeDeclaration codeType, Type implementationType, CodeFieldReferenceExpression omObjectFieldReference, ConstructorInfo constructorInfo)
        {
            CodeConstructor constructor = new CodeConstructor();
            constructor.Attributes = MemberAttributes.Public;

            ParameterInfo[] parameters = constructorInfo.GetParameters();
            CodeExpression[] codeArgumentReferences = new CodeExpression[parameters.Length];
            for (int i = 0; i < parameters.Length; i++)
            {
                bool isOmTypeArg = false;

                string paramType = parameters[i].ParameterType.FullName;
                if (OMtoPSClassMappings.ContainsKey(paramType))
                {
                    paramType = OMtoPSClassMappings[paramType];
                    isOmTypeArg = true;
                }

                string paramName = parameters[i].Name;
                string passedInArg;

                // Create the proper parameter for optional
                if (parameters[i].IsOptional)
                {
                    paramName = paramType.Contains("System")
                        ? string.Format("{0} = null", parameters[i].Name)
                        : string.Format("{0} = default({1})", parameters[i].Name, paramType);
                }

                // Need to do a null check for calling an omObject from a PS wrapper class
                if (isOmTypeArg && parameters[i].IsOptional)
                {
                    CodeVariableDeclarationStatement omObjectDeclaration = new CodeVariableDeclarationStatement(
                        parameters[i].ParameterType,
                        string.Format("{0}{1}", parameters[i].Name, "OmObject"),
                        new CodePrimitiveExpression(null));

                    constructor.Statements.Add(omObjectDeclaration);

                    CodeArgumentReferenceExpression omObjectArgumentReference = new CodeArgumentReferenceExpression(parameters[i].Name);
                    CodeAssignStatement omObjectAssignStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(string.Format("{0}{1}", parameters[i].Name, "OmObject")), new CodeVariableReferenceExpression(string.Format("{0}.{1}", parameters[i].Name, OmObject)));
                    CodeBinaryOperatorExpression nullCheck = new CodeBinaryOperatorExpression(omObjectArgumentReference, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));

                    // if the parameter is not null, use the omObject of the PS Wrapper class
                    constructor.Statements.Add(new CodeConditionStatement(nullCheck, omObjectAssignStatement));

                    passedInArg = string.Format("{0}{1}", parameters[i].Name, "OmObject");
                }
                else if (isOmTypeArg)
                {
                    passedInArg = string.Format("{0}.{1}", parameters[i].Name, OmObject);
                }
                else
                {
                    passedInArg = parameters[i].Name;
                }

                codeArgumentReferences[i] = new CodeArgumentReferenceExpression(passedInArg);
                constructor.Parameters.Add(new CodeParameterDeclarationExpression(paramType, paramName));
            }

            CodeObjectCreateExpression createExpression = new CodeObjectCreateExpression(implementationType, codeArgumentReferences);
            constructor.Statements.Add(new CodeAssignStatement(omObjectFieldReference, createExpression));
            codeType.Members.Add(constructor);
        }
Beispiel #24
0
        private static CodeMemberMethod AddSetPropertiesMethod(this IMessage message, SetPropertiesType setType = SetPropertiesType.Constructor)
        {
            var type = new CodeTypeReference(message.Name.PascalCased());

            var method = new CodeMemberMethod
            {
                Name = "WithProperties",
                ReturnType = type,
                Attributes = MemberAttributes.Public
            };

            var parameters = new List<CodeExpression>();

            var properties = new List<MessageProperty>(message.Interfaces.SelectMany(i => i.Properties))
                .Union(message.Properties).Distinct(MessageProperty.NameComparer);

            var messageProperties = properties as MessageProperty[] ?? properties.ToArray();
            foreach (var property in messageProperties.OrderBy(x => x.Optional))
            {
                var camelCased = property.Name.CamelCased();
                var pascalCased = property.Name.PascalCased();

                if (pascalCased == Globals.EventGenerationDateProperty)
                    continue;

                var typeName = property.Type.SafeTypeName();

                method.Parameters.Add(new CodeParameterDeclarationExpression(typeName,
                    $"{camelCased} = default({typeName})"));

                var variableName = $"local{pascalCased}";
                var argumentReference = new CodeArgumentReferenceExpression(camelCased);
                var variable = new CodeVariableDeclarationStatement(typeName, variableName, argumentReference);

                method.Statements.Add(variable);

                var ifDefaultValue = new CodeBinaryOperatorExpression(argumentReference,
                    CodeBinaryOperatorType.ValueEquality,
                    new CodeDefaultValueExpression(new CodeTypeReference(typeName)));
                var variableReference = new CodeVariableReferenceExpression(variableName);

                parameters.Add(variableReference);

                var condition = new CodeConditionStatement(ifDefaultValue,
                    new CodeAssignStatement(variableReference,
                        new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), pascalCased)));

                method.Statements.Add(condition);
            }

            if (setType == SetPropertiesType.Constructor)
            {
                var create = new CodeObjectCreateExpression(type, parameters.ToArray());
                method.Statements.Add(new CodeMethodReturnStatement(create));
            }
            else
            {
                var name = $"_{Guid.NewGuid():n}";
                var instance = new CodeVariableDeclarationStatement(type, name, new CodeObjectCreateExpression(type));
                var instanceReference = new CodeVariableReferenceExpression(name);

                method.Statements.Add(instance);

                foreach (var property in messageProperties.OrderBy(x => x.Optional))
                {
                    var propertyReference = new CodePropertyReferenceExpression(instanceReference, property.Name.PascalCased());
                    method.Statements.Add(new CodeAssignStatement(propertyReference,
                        new CodeArgumentReferenceExpression($"local{property.Name.PascalCased()}")));
                }

                method.Statements.Add(new CodeMethodReturnStatement(instanceReference));

            }
            return method;
        }
        internal void ConnectStyleEvent(XamlClrEventNode xamlClrEventNode)
        {
            CodeConditionStatement ccsConnector = null;

            // validate the event handler name per C# grammar for identifiers
            ValidateEventHandlerName(xamlClrEventNode.EventName, xamlClrEventNode.Value);

            EnsureStyleConnector();

            if (!xamlClrEventNode.IsSameScope)
            {
                int connectionId = xamlClrEventNode.ConnectionId;
                if (SwitchStatementSupported())
                {
                    // break any previous case staements as we are starting a new connection scope.
                    if (_ccRoot.StyleConnectorFn.Statements.Count > 1)
                    {
                        CodeSnippetStatement cssBreak = new CodeSnippetStatement(BREAK_STATEMENT);
                        _ccRoot.StyleConnectorFn.Statements.Add(cssBreak);
                    }

                    // case 1:
                    //
                    CodeSnippetStatement cssCase = new CodeSnippetStatement(CASE_STATEMENT + connectionId + COLON);
                    _ccRoot.StyleConnectorFn.Statements.Add(cssCase);
                }
                else
                {
                    // if (connectionId == 1)
                    //
                    ccsConnector = new CodeConditionStatement();
                    ccsConnector.Condition = new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression(CONNECTIONID),
                                                                              CodeBinaryOperatorType.ValueEquality,
                                                                              new CodePrimitiveExpression(connectionId));
                }
            }
            else if (!SwitchStatementSupported())
            {
                // if in the same scope then use the if statement that was last generated
                // at the start of the scope
                Debug.Assert(_ccRoot.StyleConnectorFn.Statements.Count > 0);
                ccsConnector = _ccRoot.StyleConnectorFn.Statements[_ccRoot.StyleConnectorFn.Statements.Count - 1] as CodeConditionStatement;
                Debug.Assert(ccsConnector != null);
            }

            CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET);

            if (xamlClrEventNode.IsStyleSetterEvent)
            {
                // EventSetter declaration only once to avoid warning!
                if (!_hasEmittedEventSetterDeclaration)
                {
                    _hasEmittedEventSetterDeclaration = true;
                    
                    // EventSetter eventSetter;
                    //
                    CodeVariableDeclarationStatement cvdsES = new CodeVariableDeclarationStatement(KnownTypes.Types[(int)KnownElements.EventSetter], EVENTSETTER);
                    _ccRoot.StyleConnectorFn.Statements.Insert(0, cvdsES);
                }


                // eventSetter = new EventSetter();
                //
                CodeExpression[] esParams = {};
                CodeVariableReferenceExpression cvreES = new CodeVariableReferenceExpression(EVENTSETTER);
                CodeAssignStatement casES = new CodeAssignStatement(cvreES,
                                                                    new CodeObjectCreateExpression(KnownTypes.Types[(int)KnownElements.EventSetter],
                                                                                                   esParams));

                // eventSetter.Event = Button.ClickEvent;
                //
                CodePropertyReferenceExpression cpreEvent = new CodePropertyReferenceExpression(cvreES, EVENT);
                CodeAssignStatement casEvent = new CodeAssignStatement(cpreEvent,
                                                                       GetEvent(xamlClrEventNode.EventMember,
                                                                                xamlClrEventNode.EventName,
                                                                                xamlClrEventNode.Value));

                // eventSetter.Handler = new RoutedEventHandler(OnClick);
                //
                CodePropertyReferenceExpression cpreHandler = new CodePropertyReferenceExpression(cvreES, HANDLER);
                CodeAssignStatement casHandler = new CodeAssignStatement(cpreHandler,
                                                                         GetEventDelegate(null,
                                                                                          xamlClrEventNode.EventMember,
                                                                                          xamlClrEventNode.EventName,
                                                                                          xamlClrEventNode.Value));

                AddLinePragma(casHandler, xamlClrEventNode.LineNumber);

                // ((Style)target).Setters.Add(eventSetter);
                //
                CodeCastExpression cceTarget = new CodeCastExpression(KnownTypes.Types[(int)KnownElements.Style], careTarget);
                CodePropertyReferenceExpression cpreSetters = new CodePropertyReferenceExpression(cceTarget, SETTERS);
                CodeMethodInvokeExpression cmieAdd = new CodeMethodInvokeExpression(cpreSetters, ADD, cvreES);

                if (SwitchStatementSupported())
                {
                    _ccRoot.StyleConnectorFn.Statements.Add(casES);
                    _ccRoot.StyleConnectorFn.Statements.Add(casEvent);
                    _ccRoot.StyleConnectorFn.Statements.Add(casHandler);
                    _ccRoot.StyleConnectorFn.Statements.Add(new CodeExpressionStatement(cmieAdd));
                }
                else
                {
                    ccsConnector.TrueStatements.Add(casES);
                    ccsConnector.TrueStatements.Add(casEvent);
                    ccsConnector.TrueStatements.Add(casHandler);
                    ccsConnector.TrueStatements.Add(new CodeExpressionStatement(cmieAdd));
                    // Only add if statement at start of new scope
                    if (!xamlClrEventNode.IsSameScope)
                    {
                        _ccRoot.StyleConnectorFn.Statements.Add(ccsConnector);
                    }
                }
            }
            else
            {

                //
                // ((Foo)target).Bar += new BarEventHandler(OnBar);
                //
                // *or*
                //
                // ((Foo)target).AddHandler( Baz.BarEvent, new BarEventHandler(OnBar));
                //

                CodeCastExpression cceTarget;
                Type eventTarget;


                // Create the markup event information

                MarkupEventInfo mei = new MarkupEventInfo( xamlClrEventNode.Value,          // Event handler string
                                                           xamlClrEventNode.EventName,      // Event name string
                                                           xamlClrEventNode.EventMember,    // MemberInfo
                                                           xamlClrEventNode.LineNumber);    // LineNumber


                // Get the type that defines the event (e.g. typeof(Button) for Button.Clicked or typeof(Mouse) for Mouse.MouseMove)

                eventTarget = xamlClrEventNode.ListenerType;


                // Create the type cast expression "(Foo)target"

                cceTarget = new CodeCastExpression( eventTarget, careTarget);


                // Create the whole code statement (either in += form or in AddHandler form)

                CodeStatement csAddCLREvent = AddCLREvent( eventTarget, null, cceTarget, mei );

                if (SwitchStatementSupported())
                {
                    _ccRoot.StyleConnectorFn.Statements.Add( csAddCLREvent );
                }
                else
                {
                    ccsConnector.TrueStatements.Add( csAddCLREvent );

                    // Only add if statement at start of new scope
                    if (!xamlClrEventNode.IsSameScope)
                    {
                        _ccRoot.StyleConnectorFn.Statements.Add(ccsConnector);
                    }
                }
            }
        }
        /// <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;
        }
		static void GenerateProjectActionsCode (CodeNamespace cns, GenerationOptions options, params ProjectBackend[] projects)
		{
			bool multiProject = projects.Length > 1;
			
			CodeTypeDeclaration type = new CodeTypeDeclaration ("ActionGroups");
			type.Attributes = MemberAttributes.Private;
			type.TypeAttributes = TypeAttributes.NestedAssembly;
			cns.Types.Add (type);

			// Generate the global action group getter
			
			CodeMemberMethod met = new CodeMemberMethod ();
			met.Name = "GetActionGroup";
			type.Members.Add (met);
			met.Parameters.Add (new CodeParameterDeclarationExpression (typeof(Type), "type"));
			if (multiProject)
				met.Parameters.Add (new CodeParameterDeclarationExpression (typeof(string), "file"));
			met.ReturnType = new CodeTypeReference (typeof(Gtk.ActionGroup));
			met.Attributes = MemberAttributes.Public | MemberAttributes.Static;

			CodeMethodInvokeExpression call = new CodeMethodInvokeExpression (
					new CodeMethodReferenceExpression (
						new CodeTypeReferenceExpression (new CodeTypeReference (cns.Name + ".ActionGroups")),
						"GetActionGroup"
					),
					new CodePropertyReferenceExpression (
						new CodeArgumentReferenceExpression ("type"),
						"FullName"
					)
			);
			if (multiProject)
				call.Parameters.Add (new CodeArgumentReferenceExpression ("file"));
				
			met.Statements.Add (new CodeMethodReturnStatement (call));

			// Generate the global action group getter (overload)
			
			met = new CodeMemberMethod ();
			met.Name = "GetActionGroup";
			type.Members.Add (met);
			met.Parameters.Add (new CodeParameterDeclarationExpression (typeof(string), "name"));
			if (multiProject)
				met.Parameters.Add (new CodeParameterDeclarationExpression (typeof(string), "file"));
			met.ReturnType = new CodeTypeReference (typeof(Gtk.ActionGroup));
			met.Attributes = MemberAttributes.Public | MemberAttributes.Static;
			
			CodeArgumentReferenceExpression cfile = new CodeArgumentReferenceExpression ("file");
			CodeArgumentReferenceExpression cid = new CodeArgumentReferenceExpression ("name");
			
			CodeStatementCollection projectCol = met.Statements;
			int n=1;
			
			foreach (ProjectBackend gp in projects) {
			
				CodeStatementCollection widgetCol;
				
				if (multiProject) {
					CodeConditionStatement pcond = new CodeConditionStatement ();
					pcond.Condition = new CodeBinaryOperatorExpression (
						cfile, 
						CodeBinaryOperatorType.IdentityEquality,
						new CodePrimitiveExpression (gp.Id)
					);
					projectCol.Add (pcond);
					
					widgetCol = pcond.TrueStatements;
					projectCol = pcond.FalseStatements;
				} else {
					widgetCol = projectCol;
				}
				
				foreach (Wrapper.ActionGroup grp in gp.ActionGroups) {
					string fname = "group" + (n++);
					CodeMemberField grpField = new CodeMemberField (new CodeTypeReference (typeof(Gtk.ActionGroup), CodeTypeReferenceOptions.GlobalReference), fname);
					grpField.Attributes |= MemberAttributes.Static;
					type.Members.Add (grpField);
					CodeFieldReferenceExpression grpVar = new CodeFieldReferenceExpression (
						new CodeTypeReferenceExpression (new CodeTypeReference (cns.Name + ".ActionGroups", CodeTypeReferenceOptions.GlobalReference)),
						fname
					);
					
					CodeConditionStatement pcond = new CodeConditionStatement ();
					pcond.Condition = new CodeBinaryOperatorExpression (
						cid, 
						CodeBinaryOperatorType.IdentityEquality,
						new CodePrimitiveExpression (grp.Name)
					);
					widgetCol.Add (pcond);
					
					// If the group has not yet been created, create it
					CodeConditionStatement pcondGrp = new CodeConditionStatement ();
					pcondGrp.Condition = new CodeBinaryOperatorExpression (
						grpVar, 
						CodeBinaryOperatorType.IdentityEquality,
						new CodePrimitiveExpression (null)
					);
					
					pcondGrp.TrueStatements.Add (
						new CodeAssignStatement (
							grpVar,
							new CodeObjectCreateExpression (grp.Name)
						)
					);
					
					pcond.TrueStatements.Add (pcondGrp);
					pcond.TrueStatements.Add (new CodeMethodReturnStatement (grpVar));
					
					widgetCol = pcond.FalseStatements;
				}
				widgetCol.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (null)));
			}
			if (met.Statements.Count == 0)
				met.Statements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (null)));
		}
Beispiel #28
0
        private static void GenerateConstructors(Type t, CodeTypeDeclaration codeType)
        {
            CodeFieldReferenceExpression omObjectFieldReference = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), OmObject);

            ConstructorInfo[] constructors = t.GetConstructors();
            ConstructorInfo publicParameterless = null;
            ConstructorInfo publicSystemParams = null;
            ConstructorInfo publicEnumParams = null;
            List<ConstructorInfo> publicGeneralParams = new List<ConstructorInfo>();
            foreach (ConstructorInfo con in constructors.Where(c => c.IsPublic || c.IsStatic))
            {
                ParameterInfo[] parameters = con.GetParameters();
                if (parameters == null || parameters.Length == 0)
                {
                    publicParameterless = con;
                }
                else if (con.IsStatic)
                {
                }
                else
                {
                    publicGeneralParams.Add(con);
                }
            }

            if (publicParameterless != null)
            {
                CodeConstructor constructor = new CodeConstructor();
                constructor.Attributes = MemberAttributes.Public;
                CodeObjectCreateExpression createExpression = new CodeObjectCreateExpression(t);
                constructor.Statements.Add(new CodeAssignStatement(omObjectFieldReference, createExpression));
                codeType.Members.Add(constructor);
            }

            foreach (ConstructorInfo c in publicGeneralParams)
            {
                AddConstructorWithCopiedParameters(codeType, t, omObjectFieldReference, c);
            }

            // Default internal constructor that accepts the OM object to wrap
            CodeConstructor defaultConstructor = new CodeConstructor();
            defaultConstructor.Attributes = MemberAttributes.Assembly;
            CodeParameterDeclarationExpression omObjectParameter = new CodeParameterDeclarationExpression(t, OmObject);
            defaultConstructor.Parameters.Add(omObjectParameter);
            CodeArgumentReferenceExpression omObjectArgumentReference = new CodeArgumentReferenceExpression(OmObject);
            CodeObjectCreateExpression createException = new CodeObjectCreateExpression(typeof(ArgumentNullException), new CodePrimitiveExpression(OmObject));
            CodeThrowExceptionStatement throwException = new CodeThrowExceptionStatement(createException);
            CodeBinaryOperatorExpression nullCheck = new CodeBinaryOperatorExpression(omObjectArgumentReference, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null));

            // if the parameter is null, throw an exception
            defaultConstructor.Statements.Add(new CodeConditionStatement(nullCheck, throwException));

            defaultConstructor.Statements.Add(new CodeAssignStatement(omObjectFieldReference, omObjectArgumentReference));
            codeType.Members.Add(defaultConstructor);
        }
Beispiel #29
0
			// CodeExpression
				
			public void Visit (CodeArgumentReferenceExpression o)
			{
				g.GenerateArgumentReferenceExpression (o);
			}
		protected override void GenerateArgumentReferenceExpression(CodeArgumentReferenceExpression e)
		{
			Output.Write("[CodeArgumentReferenceExpression: {0}]", e.ToString());
		}
Beispiel #31
0
		/*
		 * Code Generation methods
		 */
		protected abstract void GenerateArgumentReferenceExpression (CodeArgumentReferenceExpression e);