Пример #1
0
 static CodeExpression EncodeValue(object val)
 {
     if (val is int || val is long || val is uint || val is ulong || val is byte || val is sbyte || val is short || val is ushort || val is bool || val is string || val is char || val is float || val is double)
     {
         return(new CodePrimitiveExpression(val));
     }
     else if (val is Type)
     {
         return(new CodeTypeOfExpression((Type)val));
     }
     else if (val is Enum)
     {
         TypeCode typeCode = Convert.GetTypeCode(val);
         object   o;
         if (typeCode == TypeCode.UInt64)
         {
             o = UInt64.Parse(((Enum)val).ToString("D"));
         }
         else
         {
             o = Int64.Parse(((Enum)val).ToString("D"));
         }
         return(new CodeCastExpression(new CodeTypeReference(val.GetType()), new CodePrimitiveExpression(o)));
     }
     else if (val is null)
     {
         return(new CodePrimitiveExpression(null));
     }
     else if (val is Array)
     {
         var arr      = (IEnumerable)val;
         var arr_expr = new CodeArrayCreateExpression(new CodeTypeReference(val.GetType()), new CodeExpression [] {});
         foreach (var v in arr)
         {
             arr_expr.Initializers.Add(EncodeValue(v));
         }
         return(arr_expr);
     }
     else
     {
         throw new Exception("Unable to emit inline data: " + val.GetType() + " " + val);
     }
 }
Пример #2
0
        internal override CodeExpression BuildInvokeAsync(string messageName, CodeArrayCreateExpression paramsArray, CodeExpression delegateField, CodeExpression userStateVar)
        {
            HttpOperationBinding httpOper = OperationBinding.Extensions.Find(typeof(HttpOperationBinding)) as HttpOperationBinding;

            CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();

            CodeExpression               thisURlExp        = new CodeFieldReferenceExpression(ethis, "Url");
            CodePrimitiveExpression      metUrl            = new CodePrimitiveExpression(httpOper.Location);
            CodeBinaryOperatorExpression expMethodLocation = new CodeBinaryOperatorExpression(thisURlExp, CodeBinaryOperatorType.Add, metUrl);

            CodeMethodInvokeExpression inv2 = new CodeMethodInvokeExpression(ethis, "InvokeAsync");

            inv2.Parameters.Add(new CodePrimitiveExpression(messageName));
            inv2.Parameters.Add(expMethodLocation);
            inv2.Parameters.Add(paramsArray);
            inv2.Parameters.Add(delegateField);
            inv2.Parameters.Add(userStateVar);
            return(inv2);
        }
        CodeMemberField CreateIntArrayField(CodeTypeDeclaration parentType, string name, int count, params int[] values)
        {
            string          mappedName = GetResourceName(parentType.Name, name, map);
            CodeMemberField f          = (CodeMemberField)parentType.Members.OfType <CodeTypeMember> ().FirstOrDefault(x => string.Compare(x.Name, mappedName, StringComparison.Ordinal) == 0);

            if (f != null)
            {
                return(f);
            }
            f = new CodeMemberField(typeof(int []), name)
            {
                // pity I can't make the member readonly...
                Attributes = MemberAttributes.Static | MemberAttributes.Public,
            };
            CodeArrayCreateExpression c = (CodeArrayCreateExpression)f.InitExpression;

            if (c == null)
            {
                f.InitExpression = c = new CodeArrayCreateExpression(typeof(int []));
            }
            var sb = new StringBuilder();

            for (int i = 0; i < count; i++)
            {
                int value = -1;
                if (i < values.Length)
                {
                    value = values[i];
                }
                c.Initializers.Add(new CodePrimitiveExpression(value));
                sb.Append($"0x{value.ToString ("X")}");
                if (i < count - 1)
                {
                    sb.Append(",");
                }
            }
            if (values.Length > 0)
            {
                f.Comments.Add(new CodeCommentStatement($"aapt resource value: {{ {sb} }}"));
            }
            parentType.Members.Add(f);
            return(f);
        }
        private void GenerateArrayCreateExpression(CodeArrayCreateExpression e)
        {
            output.Write("new ");

            CodeExpressionCollection init = e.Initializers;

            if (init.Count > 0)
            {
                OutputType(e.CreateType);
                if (e.CreateType.ArrayRank == 0)
                {
                    // Unfortunately, many clients are already calling this without array
                    // types. This will allow new clients to correctly use the array type and
                    // not break existing clients. For VNext, stop doing this.
                    output.Write("[]");
                }
                output.WriteLine(" {");
                Indent++;
                OutputExpressionList(init, true);
                Indent--;
                output.Write("}");
            }
            else
            {
                output.Write(GetBaseTypeOutput(e.CreateType));
                output.Write("[");
                if (e.SizeExpression != null)
                {
                    GenerateExpression(e.SizeExpression);
                }
                else
                {
                    output.Write(e.Size);
                }
                output.Write("]");
                CodeTypeReference arrayElementType = e.CreateType.ArrayElementType;
                while (arrayElementType != null)
                {
                    output.Write("[]");
                    arrayElementType = arrayElementType.ArrayElementType;
                }
            }
        }
Пример #5
0
        private static void GenerateActionSetsHelpers(string actionSetsClassFileName)
        {
            CodeCompileUnit compileUnit = new CodeCompileUnit();

            CodeTypeDeclaration inputClass = CreatePartialInputClass(compileUnit);


            CodeMemberMethod startPreInitActionSetsMethod =
                CreateStaticMethod(inputClass, startPreInitActionSetsMethodName, false);

            CodeArrayCreateExpression actionSetsArray =
                new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_ActionSet)));

            for (int actionSetIndex = 0; actionSetIndex < SteamVR_Input.actionFile.action_sets.Count; actionSetIndex++)
            {
                SteamVR_Input_ActionFile_ActionSet actionSet = SteamVR_Input.actionFile.action_sets[actionSetIndex];

                string shortName = GetValidIdentifier(actionSet.shortName);

                string codeFriendlyInstanceName = shortName;

                string setTypeName = GetSetClassName(actionSet);

                CodeMemberField actionSetField = CreateFieldAndPropertyWrapper(inputClass, shortName, setTypeName);

                AddAssignActionSetStatement(startPreInitActionSetsMethod, inputClass.Name, actionSetField.Name,
                                            actionSet.name, setTypeName);

                actionSetsArray.Initializers.Add(
                    new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name),
                                                     codeFriendlyInstanceName));
            }

            AddAssignStatement(startPreInitActionSetsMethod, SteamVR_Input_Generator_Names.actionSetsFieldName,
                               actionSetsArray);

            // Build the output file name.
            string fullSourceFilePath = GetSourceFilePath(actionSetsClassFileName);

            CreateFile(fullSourceFilePath, compileUnit);
        }
Пример #6
0
        private void GetParams(List <SPInfos> spi, CodeMemberMethod cmmGetLenght, out CodeVariableDeclarationStatement names, out CodeVariableDeclarationStatement values)
        {
            CodeTypeReference strary = new CodeTypeReference(new CodeTypeReference(typeof(string)), 1);
            CodeTypeReference objary = new CodeTypeReference(new CodeTypeReference(typeof(object)), 1);

            names  = new CodeVariableDeclarationStatement(strary, "names");
            values = new CodeVariableDeclarationStatement(objary, "values");
            CodeArrayCreateExpression acnames  = new CodeArrayCreateExpression(strary);
            CodeArrayCreateExpression acvalues = new CodeArrayCreateExpression(objary);

            foreach (var item in spi)
            {
                item.sp_paramname = item.sp_paramname.Replace("@", "");
                CodeParameterDeclarationExpression cmf = new CodeParameterDeclarationExpression(Keel.DB.Common.NowDataBase.PasteType(item.sp_pmdatatype), item.sp_paramname);
                cmmGetLenght.Parameters.Add(cmf);
                acnames.Initializers.Add(new CodePrimitiveExpression(item.sp_paramname));
                acvalues.Initializers.Add(new CodeVariableReferenceExpression(cmf.Name));
            }
            names.InitExpression  = acnames;
            values.InitExpression = acvalues;
        }
        public override void Generate(object codeObject, Entity entity)
        {
            base.Generate(codeObject, entity);

            var attribute = (CodeAttributeDeclaration)codeObject;
            var docType   = (DocumentType)entity;
            var info      = (DocumentTypeInfo)docType.Info;

            AddAttributeArgumentIfValue(attribute, "DefaultTemplate", info.DefaultTemplate);

            var allowedTemplates =
                info.AllowedTemplates
                .NonNullOrWhiteSpace()
                .AsPrimitiveExpressions();
            var arrayCreateExpression = new CodeArrayCreateExpression("String", allowedTemplates);

            if (allowedTemplates.Any())
            {
                AddAttributeArgument(attribute, "AllowedTemplates", arrayCreateExpression);
            }
        }
        private void BuildLinkedStyleSheetMember()
        {
            CodeMemberField field = new CodeMemberField(typeof(string[]), "__linkedStyleSheets");

            if ((this._themeParser.CssFileList != null) && (this._themeParser.CssFileList.Count > 0))
            {
                CodeExpression[] initializers = new CodeExpression[this._themeParser.CssFileList.Count];
                int num = 0;
                foreach (string str in this._themeParser.CssFileList)
                {
                    initializers[num++] = new CodePrimitiveExpression(str);
                }
                CodeArrayCreateExpression expression = new CodeArrayCreateExpression(typeof(string), initializers);
                field.InitExpression = expression;
            }
            else
            {
                field.InitExpression = new CodePrimitiveExpression(null);
            }
            base._sourceDataClass.Members.Add(field);
        }
        // <Snippet2>
        public CodeCompileUnit CreateGraph()
        {
            // Create a compile unit to contain a CodeDOM graph
            CodeCompileUnit cu = new CodeCompileUnit();

            // Create a namespace named "TestSpace"
            CodeNamespace cn = new CodeNamespace("TestSpace");

            // Create a new type named "TestClass"
            CodeTypeDeclaration cd = new CodeTypeDeclaration("TestClass");

            // Create a new entry point method
            CodeEntryPointMethod cm = new CodeEntryPointMethod();

            // <Snippet1>
            // Create an initialization expression for a new array of type Int32 with 10 indices
            CodeArrayCreateExpression ca1 = new CodeArrayCreateExpression("System.Int32", 10);

            // Declare an array of type Int32, using the CodeArrayCreateExpression ca1 as the initialization expression
            CodeVariableDeclarationStatement cv1 = new CodeVariableDeclarationStatement("System.Int32[]", "x", ca1);

            // A C# code generator produces the following source code for the preceeding example code:

            // int[] x = new int[10];
            // </Snippet1>

            // Add the variable declaration and initialization statement to the entry point method
            cm.Statements.Add(cv1);

            // Add the entry point method to the "TestClass" type
            cd.Members.Add(cm);

            // Add the "TestClass" type to the namespace
            cn.Types.Add(cd);

            // Add the "TestSpace" namespace to the compile unit
            cu.Namespaces.Add(cn);

            return(cu);
        }
Пример #10
0
        public override System.CodeDom.CodeExpression ExportCode(IMethodCompile method)
        {
            MathNode.Trace("{0}.ExportCode", this.GetType().Name);
            List <CodeExpression> args = new List <CodeExpression>();

            Arguements(method, args);
            System.Text.StringBuilder sb = new StringBuilder();
            for (int i = 0; i < args.Count; i++)
            {
                sb.Append("{");
                sb.Append(i.ToString());
                sb.Append("}");
            }
            CodeExpression[] codes = new CodeExpression[args.Count];
            args.CopyTo(codes);
            CodeArrayCreateExpression arr = new CodeArrayCreateExpression(typeof(object), codes);

            return(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(string)), "Format"),
                                                  new CodeExpression[] { new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(System.Globalization.CultureInfo)), "InvariantCulture"),
                                                                         new CodePrimitiveExpression(sb.ToString()),
                                                                         arr }));
        }
        public override bool CreateBlockCodeStatements(BloxBlockEd bdi, CodeStatementCollection statements)
        {
            CodeExpression codeExpression = null;

            if (bdi.paramBlocks[1] == null)
            {
                codeExpression = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "bloxContainer");
            }
            else
            {
                CodeExpression codeExpression2 = BloxScriptGenerator.CreateBlockCodeExpression(bdi.paramBlocks[1], null);
                if (codeExpression2 == null)
                {
                    return(false);
                }
                codeExpression = new CodeFieldReferenceExpression(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(BloxUtil)), "GetComponent", new CodeTypeReference(typeof(BloxContainer))), codeExpression2), "bloxContainer");
            }
            CodeExpression[] array = new CodeExpression[(bdi.paramBlocks.Length > 3) ? 3 : 2];
            array[0] = BloxScriptGenerator.CreateBlockCodeExpression(bdi.paramBlocks[0], typeof(string));
            if (array[0] == null)
            {
                Debug.LogError("Event name missing.");
                return(false);
            }
            array[1] = (BloxScriptGenerator.CreateBlockCodeExpression(bdi.paramBlocks[2], typeof(float)) ?? new CodePrimitiveExpression(0f));
            if (bdi.paramBlocks.Length > 3)
            {
                CodeExpression[] array2 = new CodeExpression[bdi.paramBlocks.Length - 3];
                for (int i = 3; i < bdi.paramBlocks.Length; i++)
                {
                    CodeExpression codeExpression3 = BloxScriptGenerator.CreateBlockCodeExpression(bdi.paramBlocks[i], null) ?? new CodePrimitiveExpression(null);
                    array2[i - 3] = new CodeObjectCreateExpression(typeof(BloxEventArg), new CodePrimitiveExpression("param" + (i - 3)), codeExpression3);
                }
                array[2] = new CodeArrayCreateExpression(typeof(BloxEventArg), array2);
            }
            statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(codeExpression, "TriggerEvent", array)));
            return(true);
        }
Пример #12
0
        static bool WriteCodeArrayCreateExpression(CodeArrayCreateExpression arrayCreateExpression, TextWriter w, CodeGeneratorOptions o)
        {
            if (arrayCreateExpression == null)
            {
                return(false);
            }

            w.Write("[");
            WriteCodeExpressionCollection(arrayCreateExpression.Initializers, w, o);
            w.Write("]");
            //TS does not care about other properties of CodeArrayCreateExpression
            if (arrayCreateExpression.Size > 0)
            {
                Trace.TraceWarning("CodeArrayCreateExpression in TypeScript does not care about Size.");
            }

            if (arrayCreateExpression.SizeExpression != null)
            {
                Trace.TraceWarning("CodeArrayCreateExpression in TypeScript does not care about SizeExpression.");
            }

            return(true);
        }
Пример #13
0
        /// <summary>
        /// Generates the code to add a new UserField.
        /// <para>This code is added in your AddOn_Db class inheriting from B1Db.</para>
        /// </summary>
        /// <returns>CodeExpression containing the UserField information.</returns>
        public CodeExpression GenerateCtor()
        {
            /*
             * new B1DbColumn(table,name,description,type,subtype,size,validValues,defaultValue);
             */

            int i = 0;

            CodeExpression[] validValuesArray = new CodeExpression[ValidValues.Length];
            foreach (B1DbValidValue vval in ValidValues)
            {
                validValuesArray[i++] = new CodeObjectCreateExpression(
                    "B1WizardBase.B1DbValidValue",
                    new CodeExpression[2] {
                    new CodePrimitiveExpression(vval.Val),
                    new CodePrimitiveExpression(vval.Description)
                });
            }
            CodeArrayCreateExpression createValidValuesArray = new CodeArrayCreateExpression(
                "B1WizardBase.B1DbValidValue", validValuesArray);

            return(new CodeObjectCreateExpression(
                       "B1DbColumn",
                       new CodeExpression[9] {
                new CodePrimitiveExpression(Table),
                new CodePrimitiveExpression(Name),
                new CodePrimitiveExpression(Description),
                new CodeFieldReferenceExpression(
                    new CodeTypeReferenceExpression("BoFieldTypes"), Type.ToString()),
                new CodeFieldReferenceExpression(
                    new CodeTypeReferenceExpression("BoFldSubTypes"), SubType.ToString()),
                new CodePrimitiveExpression(Size),
                new CodePrimitiveExpression(IsNullable),
                createValidValuesArray,
                new CodePrimitiveExpression(DefaultValue)
            }));
        }
        private void AddFindByMethods(CodeTypeDeclaration dataTableClass)
        {
            DataTable dataTable = this.designTable.DataTable;

            for (int i = 0; i < dataTable.Constraints.Count; i++)
            {
                if ((dataTable.Constraints[i] is UniqueConstraint) && ((UniqueConstraint)dataTable.Constraints[i]).IsPrimaryKey)
                {
                    DataColumn[] columns   = ((UniqueConstraint)dataTable.Constraints[i]).Columns;
                    string       inVarName = "FindBy";
                    bool         flag      = true;
                    for (int j = 0; j < columns.Length; j++)
                    {
                        inVarName = inVarName + this.codeGenerator.TableHandler.Tables[columns[j].Table.TableName].DesignColumns[columns[j].ColumnName].GeneratorColumnPropNameInRow;
                        if (columns[j].ColumnMapping != MappingType.Hidden)
                        {
                            flag = false;
                        }
                    }
                    if (!flag)
                    {
                        CodeMemberMethod method = CodeGenHelper.MethodDecl(CodeGenHelper.Type(this.rowClassName), NameHandler.FixIdName(inVarName), MemberAttributes.Public | MemberAttributes.Final);
                        for (int k = 0; k < columns.Length; k++)
                        {
                            method.Parameters.Add(CodeGenHelper.ParameterDecl(CodeGenHelper.Type(columns[k].DataType), this.codeGenerator.TableHandler.Tables[columns[k].Table.TableName].DesignColumns[columns[k].ColumnName].GeneratorColumnPropNameInRow));
                        }
                        CodeArrayCreateExpression par = new CodeArrayCreateExpression(typeof(object), columns.Length);
                        for (int m = 0; m < columns.Length; m++)
                        {
                            par.Initializers.Add(CodeGenHelper.Argument(this.codeGenerator.TableHandler.Tables[columns[m].Table.TableName].DesignColumns[columns[m].ColumnName].GeneratorColumnPropNameInRow));
                        }
                        method.Statements.Add(CodeGenHelper.Return(CodeGenHelper.Cast(CodeGenHelper.Type(this.rowClassName), CodeGenHelper.MethodCall(CodeGenHelper.Property(CodeGenHelper.This(), "Rows"), "Find", par))));
                        dataTableClass.Members.Add(method);
                    }
                }
            }
        }
Пример #15
0
        internal override bool Match(CodeExpression expression, CodeExpression comperand)
        {
            CodeArrayCreateExpression expression2 = (CodeArrayCreateExpression)expression;
            CodeArrayCreateExpression expression3 = comperand as CodeArrayCreateExpression;

            if (((expression3 == null) || (expression2.Size != expression3.Size)) || !TypeReferenceExpression.MatchType(expression2.CreateType, expression3.CreateType))
            {
                return(false);
            }
            if (expression2.SizeExpression != null)
            {
                if (expression3.SizeExpression == null)
                {
                    return(false);
                }
                if (!RuleExpressionWalker.Match(expression2.SizeExpression, expression3.SizeExpression))
                {
                    return(false);
                }
            }
            else if (expression3.SizeExpression != null)
            {
                return(false);
            }
            if (expression2.Initializers.Count != expression3.Initializers.Count)
            {
                return(false);
            }
            for (int i = 0; i < expression2.Initializers.Count; i++)
            {
                if (!RuleExpressionWalker.Match(expression2.Initializers[i], expression3.Initializers[i]))
                {
                    return(false);
                }
            }
            return(true);
        }
Пример #16
0
        void EmitArray(CodeArrayCreateExpression array)
        {
            writer.Write(Parser.ArrayOpen);

            bool first = true;

            depth++;
            foreach (CodeExpression expr in array.Initializers)
            {
                if (first)
                {
                    first = false;
                }
                else
                {
                    writer.Write(Parser.DefaultMulticast);
                    writer.Write(Parser.SingleSpace);
                }
                EmitExpression(expr);
            }
            depth--;

            writer.Write(Parser.ArrayClose);
        }
        private static void UpdatePipeline(CodeCompileUnit code, string[] requestHandlers)
        {
            var containsStop = requestHandlers.Contains("AMAZON.StopIntent".Safe());
            var array        = new CodeArrayCreateExpression(new CodeTypeReference("IAlexaRequestHandler<APLSkillRequest>[]"));

            foreach (var requestHandler in requestHandlers.OrderBy(rh => rh.Length))
            {
                array.Initializers.Add(new CodeObjectCreateExpression(requestHandler.Safe()));
            }

            if (!containsStop)
            {
                array.Initializers.Add(new CodeObjectCreateExpression("AMAZON.StopIntent".Safe()));
            }

            array.Initializers.Add(new CodeObjectCreateExpression("AMAZON.FallbackIntent".Safe()));
            var pipeline = new CodeObjectCreateExpression(new CodeTypeReference("AlexaRequestPipeline<APLSkillRequest>"), array);


            var constructor = code.FirstType().Members.OfType <CodeTypeConstructor>().First();

            constructor.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("_pipeline"),
                                                               pipeline));
        }
Пример #18
0
        CodeTypeDeclaration GenerateVersions()
        {
            var dictionaryType = new CodeTypeDeclaration("Dictionary")
            {
                Attributes = MemberAttributes.Public,
                IsPartial  = true
            };

            var versionCollectionMember = new CodeMemberField("VersionCollection", "_versions")
            {
                Attributes =
                    MemberAttributes.Private | MemberAttributes.Static,
                InitExpression =
                    new CodeObjectCreateExpression("VersionCollection")
            };

            dictionaryType.Members.Add(versionCollectionMember);

            var versionsProperty = new CodeMemberProperty
            {
                Attributes    = MemberAttributes.Public | MemberAttributes.Static,
                Name          = "Versions",
                Type          = new CodeTypeReference("VersionCollection"),
                GetStatements =
                {
                    new CodeMethodReturnStatement
                    {
                        Expression =
                            new CodeVariableReferenceExpression(
                                "_versions")
                    }
                }
            };

            dictionaryType.Members.Add(versionsProperty);

            var versionsType = new CodeTypeDeclaration("VersionCollection")
            {
                Attributes = MemberAttributes.Public,
                IsPartial  = true
            };

            versionsType.BaseTypes.Add(new CodeTypeReference("IEnumerable<Version>"));

            string last = null;

            foreach (Fix.Repository.Version version in Repository.Versions)
            {
                string versionClass = version.BeginString.Replace('.', '_');
                var    versionField = new CodeMemberField
                {
                    Attributes = MemberAttributes.Public,
                    Name       = versionClass,
                    Type       = new CodeTypeReference("Version")
                };
                versionsType.Members.Add(versionField);
                if (!versionField.Name.StartsWith("FIXT_"))
                {
                    last = versionField.Name;
                }
            }

            if (!string.IsNullOrEmpty(last))
            {
                var defaultField = new CodeMemberField
                {
                    Attributes = MemberAttributes.Public,
                    Name       = "Default",
                    Type       = new CodeTypeReference("Version")
                };
                versionsType.Members.Add(defaultField);
            }

            var constructor = new CodeConstructor
            {
                Attributes = MemberAttributes.Public
            };

            var versionsCreate = new CodeArrayCreateExpression("Version");

            foreach (Fix.Repository.Version version in Repository.Versions)
            {
                string versionClass = version.BeginString.Replace('.', '_');

                var assign = new CodeAssignStatement(new CodeVariableReferenceExpression(versionClass),
                                                     new CodeObjectCreateExpression("Version",
                                                                                    new CodePrimitiveExpression(version.BeginString),
                                                                                    new CodeVariableReferenceExpression("Fix.Dictionary." + versionClass + ".Messages"),
                                                                                    new CodeVariableReferenceExpression("Fix.Dictionary." + versionClass + ".Fields")));

                constructor.Statements.Add(assign);



                versionsCreate.Initializers.Add(new CodeVariableReferenceExpression(versionClass));
            }

            var defaultAssign = new CodeAssignStatement(new CodeVariableReferenceExpression("Default"),
                                                        new CodeVariableReferenceExpression(last));

            constructor.Statements.Add(defaultAssign);

            var versionsAssign = new CodeAssignStatement(new CodeVariableReferenceExpression("_versions"), versionsCreate);

            constructor.Statements.Add(versionsAssign);

            versionsType.Members.Add(constructor);

            dictionaryType.Members.Add(versionsType);

            var fieldsProperty = new CodeMemberProperty
            {
                Attributes    = MemberAttributes.Public | MemberAttributes.Static,
                Name          = "Fields",
                Type          = new CodeTypeReference(last + "." + last + "FieldCollection"),
                GetStatements =
                {
                    new CodeMethodReturnStatement
                    {
                        Expression = new CodeVariableReferenceExpression(last + ".Fields")
                    }
                }
            };

            dictionaryType.Members.Add(fieldsProperty);

            var messagesProperty = new CodeMemberProperty
            {
                Attributes    = MemberAttributes.Public | MemberAttributes.Static,
                Name          = "Messages",
                Type          = new CodeTypeReference(last + "." + last + "MessageCollection"),
                GetStatements =
                {
                    new CodeMethodReturnStatement
                    {
                        Expression = new CodeVariableReferenceExpression(last + ".Messages")
                    }
                }
            };

            dictionaryType.Members.Add(messagesProperty);

            var dataTypesProperty = new CodeMemberProperty
            {
                Attributes    = MemberAttributes.Public | MemberAttributes.Static,
                Name          = "DataTypes",
                Type          = new CodeTypeReference(last + "." + last + "DataTypeCollection"),
                GetStatements =
                {
                    new CodeMethodReturnStatement
                    {
                        Expression = new CodeVariableReferenceExpression(last + ".DataTypes")
                    }
                }
            };

            dictionaryType.Members.Add(dataTypesProperty);

            return(dictionaryType);
        }
Пример #19
0
 protected virtual void Visit(CodeArrayCreateExpression expr)
 {
 }
Пример #20
0
 protected override void GenerateArrayCreateExpression(CodeArrayCreateExpression e)
 {
     Output.Write("arrayCreate");
 }
Пример #21
0
        void GenerateEventBasedAsyncSupport(CodeTypeDeclaration type, OperationDescription od, CodeNamespace cns)
        {
            var  method      = FindByName(type, od.Name) ?? FindByName(type, "Begin" + od.Name);
            var  endMethod   = method.Name == od.Name ? null : FindByName(type, "End" + od.Name);
            bool methodAsync = method.Name.StartsWith("Begin", StringComparison.Ordinal);
            var  resultType  = endMethod != null ? endMethod.ReturnType : method.ReturnType;

            var thisExpr        = new CodeThisReferenceExpression();
            var baseExpr        = new CodeBaseReferenceExpression();
            var nullExpr        = new CodePrimitiveExpression(null);
            var asyncResultType = new CodeTypeReference(typeof(IAsyncResult));

            // OnBeginXxx() implementation
            var cm = new CodeMemberMethod()
            {
                Name       = "OnBegin" + od.Name,
                Attributes = MemberAttributes.Private | MemberAttributes.Final,
                ReturnType = asyncResultType
            };

            type.Members.Add(cm);

            AddMethodParam(cm, typeof(object []), "args");
            AddMethodParam(cm, typeof(AsyncCallback), "asyncCallback");
            AddMethodParam(cm, typeof(object), "userState");

            var call = new CodeMethodInvokeExpression(
                thisExpr,
                "Begin" + od.Name);

            for (int idx = 0; idx < method.Parameters.Count - (methodAsync ? 2 : 0); idx++)
            {
                var p = method.Parameters [idx];
                cm.Statements.Add(new CodeVariableDeclarationStatement(p.Type, p.Name, new CodeCastExpression(p.Type, new CodeArrayIndexerExpression(new CodeArgumentReferenceExpression("args"), new CodePrimitiveExpression(idx)))));
                call.Parameters.Add(new CodeVariableReferenceExpression(p.Name));
            }
            call.Parameters.Add(new CodeArgumentReferenceExpression("asyncCallback"));
            call.Parameters.Add(new CodeArgumentReferenceExpression("userState"));
            cm.Statements.Add(new CodeMethodReturnStatement(call));

            // OnEndXxx() implementation
            cm = new CodeMemberMethod()
            {
                Name       = "OnEnd" + od.Name,
                Attributes = MemberAttributes.Private | MemberAttributes.Final,
                ReturnType = new CodeTypeReference(typeof(object []))
            };
            type.Members.Add(cm);

            AddMethodParam(cm, typeof(IAsyncResult), "result");

            var outArgRefs = new List <CodeVariableReferenceExpression> ();

            for (int idx = 0; idx < method.Parameters.Count; idx++)
            {
                var p = method.Parameters [idx];
                if (p.Direction != FieldDirection.In)
                {
                    cm.Statements.Add(new CodeVariableDeclarationStatement(p.Type, p.Name));
                    outArgRefs.Add(new CodeVariableReferenceExpression(p.Name));                       // FIXME: should this work? They need "out" or "ref" modifiers.
                }
            }

            call = new CodeMethodInvokeExpression(
                thisExpr,
                "End" + od.Name,
                new CodeArgumentReferenceExpression("result"));
            call.Parameters.AddRange(outArgRefs.Cast <CodeExpression> ().ToArray());              // questionable

            var retCreate = new CodeArrayCreateExpression(typeof(object));

            if (resultType.BaseType == "System.Void")
            {
                cm.Statements.Add(call);
            }
            else
            {
                cm.Statements.Add(new CodeVariableDeclarationStatement(typeof(object), "__ret", call));
                retCreate.Initializers.Add(new CodeVariableReferenceExpression("__ret"));
            }
            foreach (var outArgRef in outArgRefs)
            {
                retCreate.Initializers.Add(new CodeVariableReferenceExpression(outArgRef.VariableName));
            }

            cm.Statements.Add(new CodeMethodReturnStatement(retCreate));

            // OnXxxCompleted() implementation
            cm = new CodeMemberMethod()
            {
                Name       = "On" + od.Name + "Completed",
                Attributes = MemberAttributes.Private | MemberAttributes.Final
            };
            type.Members.Add(cm);

            AddMethodParam(cm, typeof(object), "state");

            string argsname        = identifiers.AddUnique(od.Name + "CompletedEventArgs", null);
            var    iaargs          = new CodeTypeReference("InvokeAsyncCompletedEventArgs");  // avoid messy System.Type instance for generic nested type :|
            var    iaref           = new CodeVariableReferenceExpression("args");
            var    methodEventArgs = new CodeObjectCreateExpression(new CodeTypeReference(argsname),
                                                                    new CodePropertyReferenceExpression(iaref, "Results"),
                                                                    new CodePropertyReferenceExpression(iaref, "Error"),
                                                                    new CodePropertyReferenceExpression(iaref, "Cancelled"),
                                                                    new CodePropertyReferenceExpression(iaref, "UserState"));

            cm.Statements.Add(new CodeConditionStatement(
                                  new CodeBinaryOperatorExpression(
                                      new CodeEventReferenceExpression(thisExpr, od.Name + "Completed"), CodeBinaryOperatorType.IdentityInequality, nullExpr),
                                  new CodeVariableDeclarationStatement(iaargs, "args", new CodeCastExpression(iaargs, new CodeArgumentReferenceExpression("state"))),
                                  new CodeExpressionStatement(new CodeMethodInvokeExpression(thisExpr, od.Name + "Completed", thisExpr, methodEventArgs))));

            // delegate fields
            type.Members.Add(new CodeMemberField(new CodeTypeReference("BeginOperationDelegate"), "onBegin" + od.Name + "Delegate"));
            type.Members.Add(new CodeMemberField(new CodeTypeReference("EndOperationDelegate"), "onEnd" + od.Name + "Delegate"));
            type.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(SendOrPostCallback)), "on" + od.Name + "CompletedDelegate"));

            // XxxCompletedEventArgs class
            var argsType = new CodeTypeDeclaration(argsname);

            argsType.BaseTypes.Add(new CodeTypeReference(typeof(AsyncCompletedEventArgs)));
            cns.Types.Add(argsType);

            var argsCtor = new CodeConstructor()
            {
                Attributes = MemberAttributes.Public | MemberAttributes.Final
            };

            argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object []), "results"));
            argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(Exception), "error"));
            argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(bool), "cancelled"));
            argsCtor.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
            argsCtor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("error"));
            argsCtor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("cancelled"));
            argsCtor.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression("userState"));
            var resultsField = new CodeFieldReferenceExpression(thisExpr, "results");

            argsCtor.Statements.Add(new CodeAssignStatement(resultsField, new CodeArgumentReferenceExpression("results")));
            argsType.Members.Add(argsCtor);

            argsType.Members.Add(new CodeMemberField(typeof(object []), "results"));

            if (resultType.BaseType != "System.Void")
            {
                var resultProp = new CodeMemberProperty {
                    Name       = "Result",
                    Type       = resultType,
                    Attributes = MemberAttributes.Public | MemberAttributes.Final
                };
                resultProp.GetStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(resultProp.Type, new CodeArrayIndexerExpression(resultsField, new CodePrimitiveExpression(0)))));
                argsType.Members.Add(resultProp);
            }

            // event field
            var handlerType = new CodeTypeReference(typeof(EventHandler <>));

            handlerType.TypeArguments.Add(new CodeTypeReference(argsType.Name));
            type.Members.Add(new CodeMemberEvent()
            {
                Name       = od.Name + "Completed",
                Type       = handlerType,
                Attributes = MemberAttributes.Public | MemberAttributes.Final
            });

            // XxxAsync() implementations
            bool hasAsync = false;

            foreach (int __x in Enumerable.Range(0, 2))
            {
                cm = new CodeMemberMethod();
                type.Members.Add(cm);
                cm.Name       = od.Name + "Async";
                cm.Attributes = MemberAttributes.Public
                                | MemberAttributes.Final;

                var inArgs = new List <CodeParameterDeclarationExpression> ();

                for (int idx = 0; idx < method.Parameters.Count - (methodAsync ? 2 : 0); idx++)
                {
                    var pd = method.Parameters [idx];
                    inArgs.Add(pd);
                    cm.Parameters.Add(pd);
                }

                // First one is overload without asyncState arg.
                if (!hasAsync)
                {
                    call = new CodeMethodInvokeExpression(thisExpr, cm.Name, inArgs.ConvertAll <CodeExpression> (decl => new CodeArgumentReferenceExpression(decl.Name)).ToArray());
                    call.Parameters.Add(nullExpr);
                    cm.Statements.Add(new CodeExpressionStatement(call));
                    hasAsync = true;
                    continue;
                }

                // Second one is the primary one.

                cm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));

                // if (onBeginBarOperDelegate == null) onBeginBarOperDelegate = new BeginOperationDelegate (OnBeginBarOper);
                // if (onEndBarOperDelegate == null) onEndBarOperDelegate = new EndOperationDelegate (OnEndBarOper);
                // if (onBarOperCompletedDelegate == null) onBarOperCompletedDelegate = new BeginOperationDelegate (OnBarOperCompleted);
                var beginOperDelegateRef     = new CodeFieldReferenceExpression(thisExpr, "onBegin" + od.Name + "Delegate");
                var endOperDelegateRef       = new CodeFieldReferenceExpression(thisExpr, "onEnd" + od.Name + "Delegate");
                var operCompletedDelegateRef = new CodeFieldReferenceExpression(thisExpr, "on" + od.Name + "CompletedDelegate");

                var ifstmt = new CodeConditionStatement(
                    new CodeBinaryOperatorExpression(beginOperDelegateRef, CodeBinaryOperatorType.IdentityEquality, nullExpr),
                    new CodeAssignStatement(beginOperDelegateRef, new CodeDelegateCreateExpression(new CodeTypeReference("BeginOperationDelegate"), thisExpr, "OnBegin" + od.Name)));
                cm.Statements.Add(ifstmt);
                ifstmt = new CodeConditionStatement(
                    new CodeBinaryOperatorExpression(endOperDelegateRef, CodeBinaryOperatorType.IdentityEquality, nullExpr),
                    new CodeAssignStatement(endOperDelegateRef, new CodeDelegateCreateExpression(new CodeTypeReference("EndOperationDelegate"), thisExpr, "OnEnd" + od.Name)));
                cm.Statements.Add(ifstmt);
                ifstmt = new CodeConditionStatement(
                    new CodeBinaryOperatorExpression(operCompletedDelegateRef, CodeBinaryOperatorType.IdentityEquality, nullExpr),
                    new CodeAssignStatement(operCompletedDelegateRef, new CodeDelegateCreateExpression(new CodeTypeReference(typeof(SendOrPostCallback)), thisExpr, "On" + od.Name + "Completed")));
                cm.Statements.Add(ifstmt);

                // InvokeAsync (onBeginBarOperDelegate, inValues, onEndBarOperDelegate, onBarOperCompletedDelegate, userState);

                inArgs.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));

                var args = new List <CodeExpression> ();
                args.Add(beginOperDelegateRef);
                args.Add(new CodeArrayCreateExpression(typeof(object), inArgs.ConvertAll <CodeExpression> (decl => new CodeArgumentReferenceExpression(decl.Name)).ToArray()));
                args.Add(endOperDelegateRef);
                args.Add(new CodeFieldReferenceExpression(thisExpr, "on" + od.Name + "CompletedDelegate"));
                args.Add(new CodeArgumentReferenceExpression("userState"));
                call = new CodeMethodInvokeExpression(baseExpr, "InvokeAsync", args.ToArray());
                cm.Statements.Add(new CodeExpressionStatement(call));
            }
        }
Пример #22
0
        CodeExpression ParseExpression(List <object> parts)
        {
            RemoveExcessParentheses(parts);

            #region Scanner

start:
            bool rescan = false;

            for (int i = 0; i < parts.Count; i++)
            {
                if (parts[i] is string)
                {
                    var    part = (string)parts[i];
                    object result;

                    #region Parentheses
                    if (part[0] == ParenOpen)
                    {
                        int n     = i + 1;
                        var paren = Dissect(parts, n, Set(parts, i));
                        parts.RemoveAt(n);
                        n -= 2;

                        bool call = n > -1 && parts[n] is CodeExpression && !(parts[n] is CodePrimitiveExpression);

                        if (call && parts[n] is CodeMethodInvokeExpression && ((CodeMethodInvokeExpression)parts[n]).Parameters[0] is CodeFieldReferenceExpression)
                        {
                            call = false;
                        }

                        if (call)
                        {
                            var invoke = (CodeMethodInvokeExpression)InternalMethods.Invoke;

                            invoke.Parameters.Add((CodeExpression)parts[n]);

                            if (paren.Count != 0)
                            {
                                var passed = ParseMultiExpression(paren.ToArray());
                                invoke.Parameters.AddRange(passed);
                            }


                            parts[i] = invoke;
                            parts.RemoveAt(n);
                        }
                        else
                        {
                            if (paren.Count == 0)
                            {
                                parts.RemoveAt(i);
                            }
                            else
                            {
                                parts[i] = ParseExpression(paren);
                            }
                        }
                    }
                    else if (part[0] == ParenClose)
                    {
                        rescan = true;
                    }
                    #endregion
                    #region Strings
                    else if (part.Length > 1 && part[0] == StringBound && part[part.Length - 1] == StringBound)
                    {
                        parts[i] = new CodePrimitiveExpression(EscapedString(part.Substring(1, part.Length - 2), false));
                    }
                    #endregion
                    #region Numerics
                    else if (IsPrimativeObject(part, out result))
                    {
                        parts[i] = new CodePrimitiveExpression(result);
                    }
                    #endregion
                    #region Variables
                    else if (IsIdentifier(part, true) && !IsKeyword(part))
                    {
                        var low = part.ToLowerInvariant();

                        if (libProperties.ContainsKey(low))
                        {
                            parts[i] = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(bcl), libProperties[low]);
                        }
                        else
                        {
                            parts[i] = VarIdOrConstant(part);
                        }
                    }
                    #endregion
                    #region JSON
                    else if (part.Length == 1 && part[0] == BlockOpen)
                    {
                        int n     = i + 1;
                        var paren = Dissect(parts, n, Set(parts, i));

                        var invoke = (CodeMethodInvokeExpression)InternalMethods.Dictionary;
                        CodePrimitiveExpression[] keys;
                        CodeExpression[]          values;
                        ParseObject(paren, out keys, out values);
                        invoke.Parameters.Add(new CodeArrayCreateExpression(typeof(string), keys));
                        invoke.Parameters.Add(new CodeArrayCreateExpression(typeof(object), values));

                        parts[i] = invoke;
                        parts.RemoveAt(n);
                        i--;
                    }
                    else if (part.Length == 1 && part[0] == ArrayOpen)
                    {
                        int n     = i + 1;
                        var paren = Dissect(parts, n, Set(parts, i));
                        parts.RemoveAt(n);

                        if (i > 0 && parts[i - 1] is CodeExpression)
                        {
                            var invoke = (CodeMethodInvokeExpression)InternalMethods.Index;
                            n = i - 1;
                            invoke.Parameters.Add((CodeExpression)parts[n]);

                            var index = ParseMultiExpression(paren.ToArray());
                            if (index.Length > 1)
                            {
                                throw new ParseException("Cannot have multipart expression in index.");
                            }
                            else if (index.Length == 0)
                            {
                                var extend = (CodeMethodInvokeExpression)InternalMethods.ExtendArray;
                                var sub    = new List <object>(1);
                                sub.Add(parts[n]);
                                extend.Parameters.Add(ParseExpression(sub));
                                invoke = extend;
                            }
                            else
                            {
                                invoke.Parameters.Add(index[0]);
                            }

                            parts[i] = invoke;
                            parts.RemoveAt(n);
                            i--;
                        }
                        else
                        {
                            var array = new CodeArrayCreateExpression(typeof(object[]), ParseMultiExpression(paren.ToArray()));
                            parts[i] = array;
                        }
                    }
                    #endregion
                    #region Invokes
                    else if (part.Length > 1 && part[part.Length - 1] == ParenOpen)
                    {
                        string name    = part.Substring(0, part.Length - 1);
                        bool   dynamic = false;

                        if (!IsIdentifier(name))
                        {
                            if (IsDynamicReference(name))
                            {
                                dynamic = true;
                            }
                            else
                            {
                                throw new ParseException("Invalid function name");
                            }
                        }
                        else
                        {
                            CheckPersistent(name);
                        }

                        int n     = i + 1;
                        var paren = Dissect(parts, n, Set(parts, i));
                        parts.RemoveAt(n);

                        CodeMethodInvokeExpression invoke;

                        if (dynamic)
                        {
                            invoke = (CodeMethodInvokeExpression)InternalMethods.FunctionCall;
                            invoke.Parameters.Add(VarIdExpand(name));
                        }
                        else
                        {
                            invoke = LocalMethodInvoke(name);
                        }

                        if (paren.Count != 0)
                        {
                            var passed = ParseMultiExpression(paren.ToArray());
                            invoke.Parameters.AddRange(passed);
                        }

                        parts[i] = invoke;
                        invokes.Add(invoke);
                    }
                    #endregion
                    #region Assignments
                    else if (IsAssignOp(part) || IsImplicitAssignment(parts, i))
                    {
                        int n = i - 1;

                        if (i > 0 && IsJsonObject(parts[n]))
                        {
                        }
                        else if (n < 0 || !IsVarReference(parts[n]))
                        {
                            if (LaxExpressions)
                            {
                                if (parts[n] is CodePrimitiveExpression && ((CodePrimitiveExpression)parts[n]).Value is decimal)
                                {
                                    parts[n] = VarId(((decimal)((CodePrimitiveExpression)parts[n]).Value).ToString());
                                }
                            }
                            else
                            {
                                throw new ParseException("Can only assign to a variable");
                            }
                        }

                        // (x += y) => (x = x + y)
                        parts[i] = CodeBinaryOperatorType.Assign;
                        if (part[0] != AssignPre && part.Length != 1)
                        {
                            parts.Insert(++i, ParenOpen.ToString());
                            parts.Insert(++i, parts[i - 3]);
                            if (part.Length > 1)
                            {
                                parts.Insert(++i, OperatorFromString(part.Substring(0, part.Length - 1)));
                                parts.Insert(++i, ParenOpen.ToString());
                                parts.Add(ParenClose.ToString());
                            }
                            parts.Add(ParenClose.ToString());
                        }
                    }
                    #endregion
                    #region Multiple statements
                    else if (part.Length == 1 && part[0] == Multicast)
                    {
                        if (!LaxExpressions)
                        {
                            throw new ParseException("Nested multipart expression not allowed.");
                        }

                        // implement as: + Dummy(expr..)

                        int z = i + 1, l = parts.Count - z;
                        var sub = new List <object>(l);

                        for (; z < parts.Count; z++)
                        {
                            sub.Add(parts[z]);
                        }

                        parts.RemoveRange(i, parts.Count - i);

                        var invoke = (CodeMethodInvokeExpression)InternalMethods.OperateZero;
                        invoke.Parameters.Add(ParseExpression(sub));

                        parts.Add(Script.Operator.Add);
                        parts.Add(invoke);
                    }
                    #endregion
                    #region Binary operators
                    else
                    {
                        var ops = OperatorFromString(part);

                        #region Increment/decrement
                        if (ops == Script.Operator.Increment || ops == Script.Operator.Decrement)
                        {
                            int z = -1, x = i - 1, y = i + 1;
                            int d = ops == Script.Operator.Increment ? 1 : -1;
                            CodeMethodInvokeExpression shadow = null;

                            // UNDONE: use generic approach to ++/-- for all types of operands?
                            if (x > -1 && parts[x] is CodeMethodInvokeExpression)
                            {
                                var sub = new List <object>(5);
                                sub.Add(parts[x]);
                                sub.Add(CodeBinaryOperatorType.Assign);
                                sub.Add(parts[x]);
                                sub.Add(Script.Operator.Add);
                                sub.Add(d);

                                parts.RemoveAt(i);
                                parts[x] = ParseExpression(sub);
                                i        = x;
                                continue;
                            }

                            #region Compounding increment/decrement operators

                            if (LaxExpressions)
                            {
                                while (y < parts.Count)
                                {
                                    Script.Operator nextOps = Script.Operator.ValueEquality;

                                    if (parts[y] is Script.Operator)
                                    {
                                        nextOps = (Script.Operator)parts[y];
                                    }
                                    else if (parts[y] is string)
                                    {
                                        try { nextOps = OperatorFromString((string)parts[y]); }
                                        catch { break; }
                                    }
                                    else
                                    {
                                        break;
                                    }

                                    if (nextOps == Script.Operator.Increment)
                                    {
                                        d++;
                                    }
                                    else if (nextOps == Script.Operator.Decrement)
                                    {
                                        d--;
                                    }
                                    else
                                    {
                                        break;
                                    }

                                    parts.RemoveAt(y);
                                }
                            }

                            #endregion

                            if (x > -1 && (IsVarReference(parts[x]) || parts[x] is CodePropertyReferenceExpression))
                            {
                                z = x;
                            }

                            if (y < parts.Count && parts[y] is string && !IsOperator((string)parts[y]))
                            {
                                if (z != -1)
                                {
                                    if (LaxExpressions)
                                    {
                                        parts.Insert(y, Script.Operator.Concat);
                                        z = x;
                                    }
                                    else
                                    {
                                        throw new ParseException("Cannot use both prefix and postfix operators on the same variable");
                                    }
                                }

                                if (z == -1)
                                {
                                    z = y;
                                }

                                if (LaxExpressions)
                                {
                                    if (parts[z] is string && ((string)parts[z]).Length == 1 && ((string)parts[z])[0] == ParenOpen)
                                    {
                                        var zx = new[] { z + 1, z + 2 };
                                        if (zx[1] < parts.Count &&
                                            parts[zx[1]] is string && ((string)parts[zx[1]]).Length == 1 && ((string)parts[zx[1]])[0] == ParenClose &&
                                            (parts[zx[0]] is string && IsDynamicReference((string)parts[zx[0]]) || IsVarReference(parts[zx[0]])))
                                        {
                                            parts.RemoveAt(zx[1]);
                                            parts.RemoveAt(z);
                                        }
                                        else
                                        {
                                            parts.RemoveAt(i);
                                            i--;
                                            continue;
                                        }
                                    }
                                }
                            }

                            if (z == -1)
                            {
                                if (LaxExpressions)
                                {
                                    if ((x > 0 && (parts[x] is CodeBinaryOperatorExpression || parts[x] is CodeMethodInvokeExpression || parts[x] is CodePrimitiveExpression)) ||
                                        (y < parts.Count && (parts[y] is string && !IsOperator(parts[y] as string) || parts[y] is Script.Operator)))
                                    {
                                        parts.RemoveAt(i);
                                        i--;
                                        continue;
                                    }
                                }
                                else
                                {
                                    throw new ParseException("Neither left or right hand side of operator is a variable");
                                }
                            }

                            if (parts[z] is string && ((string)parts[z]).Length > 0 && ((string)parts[z])[0] == StringBound)
                            {
                                parts.RemoveAt(Math.Max(i, z));
                                parts.RemoveAt(Math.Min(i, z));
                                continue;
                            }

                            if (LaxExpressions)
                            {
                                int w = z + (z == x ? 2 : 1);
                                if (w < parts.Count && (parts[w] is string && IsAssignOp((string)parts[w]) || IsVarAssignment(parts[w])))
                                {
                                    int l   = parts.Count - w;
                                    var sub = new List <object>(l + 1);

                                    sub.Add(parts[z]);
                                    for (int wx = w; wx < parts.Count; wx++)
                                    {
                                        sub.Add(parts[wx]);
                                    }

                                    shadow = (CodeMethodInvokeExpression)InternalMethods.OperateZero;
                                    shadow.Parameters.Add(ParseExpression(sub));

                                    parts.RemoveRange(w, l);
                                }
                            }

                            var list = new List <object>(9);
                            list.Add(parts[z]);
                            list.Add(new string(new[] { Add, Equal }));
                            list.Add(new CodePrimitiveExpression(d));
                            if (shadow != null)
                            {
                                list.Add(Script.Operator.Add);
                                list.Add(shadow);
                            }
                            if (z < i) // postfix, so adjust
                            {
                                list.Insert(0, ParenOpen.ToString());
                                list.Add(ParenClose.ToString());
                                list.Add(d > 0 ? Script.Operator.Minus : Script.Operator.Add);
                                list.Add(new CodePrimitiveExpression(d));
                            }

                            x        = Math.Min(i, z);
                            y        = Math.Max(i, z);
                            parts[x] = ParseExpression(list);
                            parts.RemoveAt(y);
                            i = x;
                        }
                        #endregion
                        else
                        {
                            #region Dereference
                            if (part.Length == 1 && part[0] == Dereference)
                            {
                                bool deref = false;

                                if (i == 0)
                                {
                                    deref = true;
                                }
                                else
                                {
                                    int x = i - 1;
                                    deref = parts[x] is Script.Operator || IsVarAssignment(parts[x]) ||
                                            (parts[x] is string && ((string)parts[x]).Length == 1 && ((string)parts[x])[0] == '(');
                                }

                                if (deref)
                                {
                                    int y = i + 1;
                                    if (y < parts.Count && (IsVarReference(parts[y]) ||
                                                            (parts[y] is string && IsIdentifier((string)parts[y]) && !IsKeyword((string)parts[y]))))
                                    {
                                        ops = Script.Operator.Dereference;
                                    }
                                }
                            }
                            #endregion

                            parts[i] = ops;
                        }
                    }
                    #endregion
                }
            }

            if (rescan)
            {
                goto start;
            }

            #endregion

            #region Operators

            #region Unary (precedent)

            for (int i = 1; i < parts.Count; i++)
            {
                if (parts[i] is Script.Operator &&
                    (parts[i - 1] is Script.Operator || parts[i - 1] as CodeBinaryOperatorType? == CodeBinaryOperatorType.Assign || IsVarAssignment(parts[i - 1])) &&
                    IsUnaryOperator((Script.Operator)parts[i]))
                {
                    int n = i + 1, m = n + 1;

                    int u = n;
                    while (u < parts.Count && parts[u] is Script.Operator && IsUnaryOperator((Script.Operator)parts[u]))
                    {
                        u++;
                    }
                    if (u == parts.Count)
                    {
                        if (LaxExpressions)
                        {
                            u--;
                            while (parts[u] is Script.Operator && ((Script.Operator)parts[u] == Script.Operator.Add || (Script.Operator)parts[u] == Script.Operator.Subtract))
                            {
                                parts.RemoveAt(u--);
                            }

                            if (u + 1 < n)
                            {
                                i = u;
                                continue;
                            }
                        }

                        throw new ParseException("Compounding unary operator with no operand");
                    }

                    if (u > n)
                    {
                        var sub = new List <object>(++u - n);
                        for (int x = n; x < u; x++)
                        {
                            sub.Add(parts[x]);
                        }
                        parts.RemoveRange(n, u - n);
                        parts.Insert(n, ParseExpression(sub));
                    }

                    if (m + 1 < parts.Count && IsVarReference(parts[n]) && IsVarAssignment(parts[m]))
                    {
                        MergeAssignmentAt(parts, i + 2);
                    }

                    if (m > parts.Count)
                    {
                        throw new ParseException("Unary operator without operand");
                    }

                    var op = (Script.Operator)parts[i];

                    if (parts[n] is CodePrimitiveExpression && op == Script.Operator.Subtract)
                    {
                        var parent = ((CodePrimitiveExpression)parts[n]);

                        if (parent.Value is int)
                        {
                            parent.Value = -(int)parent.Value;
                        }
                        else if (parent.Value is decimal)
                        {
                            parent.Value = -(decimal)parent.Value;
                        }
                        else if (parent.Value is double)
                        {
                            parent.Value = -(double)parent.Value;
                        }
                        else if (parent.Value is string)
                        {
                            parent.Value = string.Concat(Minus.ToString(), (string)parent.Value);
                        }
                        else
                        {
                            throw new ArgumentOutOfRangeException();
                        }

                        parts.RemoveAt(i);
                    }
                    else if (op == Script.Operator.Add)
                    {
                        parts.RemoveAt(i);
                    }
                    else
                    {
                        var invoke = (CodeMethodInvokeExpression)InternalMethods.OperateUnary;
                        invoke.Parameters.Add(OperatorAsFieldReference(op));

                        if (LaxExpressions)
                        {
                            if (!(IsVarReference(parts[n]) || IsVarAssignment(parts[n])))
                            {
                                invoke.Parameters.Add(new CodePrimitiveExpression(null));
                                goto next;
                            }
                        }
                        invoke.Parameters.Add(VarMixedExpr(parts[n]));

                        next:
                        parts[i] = invoke;
                        parts.RemoveAt(n);
                    }
                }
            }

            #endregion

            #region Generic

            bool scan  = true;
            int  level = -1;

            while (scan)
            {
                scan = false;
                for (int i = 0; i < parts.Count; i++)
                {
                    if (parts[i] is Script.Operator && (Script.Operator)parts[i] != Script.Operator.Assign)
                    {
                        scan = true;
                        var op = (Script.Operator)parts[i];

                        if (OperatorPrecedence(op) < level)
                        {
                            continue;
                        }

                        int x = i - 1, y = i + 1;
                        var invoke = new CodeMethodInvokeExpression();

                        if (i + 3 < parts.Count && IsVarReference(parts[i + 1]) && parts[i + 2] as CodeBinaryOperatorType? == CodeBinaryOperatorType.Assign)
                        {
                            MergeAssignmentAt(parts, i + 2);
                        }

                        #region Ternary
                        if (op == Script.Operator.TernaryA)
                        {
                            if (x < 0)
                            {
                                if (LaxExpressions)
                                {
                                    return(new CodePrimitiveExpression(null));
                                }
                                else
                                {
                                    throw new ParseException("Ternary with no condition.");
                                }
                            }

                            var eval = (CodeMethodInvokeExpression)InternalMethods.IfElse;
                            eval.Parameters.Add(VarMixedExpr(parts[x]));
                            var ternary = new CodeTernaryOperatorExpression {
                                Condition = eval
                            };

                            int depth = 1, max = parts.Count - i, start = i;
                            var branch = new[] { new List <object>(max), new List <object>(max) };

                            for (i++; i < parts.Count; i++)
                            {
                                switch (parts[i] as Script.Operator?)
                                {
                                case Script.Operator.TernaryA:
                                    depth++;
                                    break;

                                case Script.Operator.TernaryB:
                                    depth--;
                                    break;
                                }

                                if (depth == 0)
                                {
                                    for (int n = i + 1; n < parts.Count; n++)
                                    {
                                        branch[1].Add(parts[n]);
                                    }
                                    break;
                                }
                                else
                                {
                                    branch[0].Add(parts[i]);
                                }
                            }

                            if (branch[0].Count == 0)
                            {
                                throw new ParseException("Ternary operator must have at least one branch");
                            }

                            if (branch[1].Count == 0)
                            {
                                branch[1].Add(new CodePrimitiveExpression(null));
                            }

                            ternary.TrueBranch  = ParseExpression(branch[0]);
                            ternary.FalseBranch = ParseExpression(branch[1]);
                            parts[x]            = ternary;

                            parts.Remove(y);
                            parts.RemoveRange(start, parts.Count - start);
                        }
                        else if (op == Script.Operator.NullAssign)
                        {
                            if (x < 0)
                            {
                                throw new ParseException("Nullable assignment with no condition.");
                            }

                            int n = i + 1;

                            if (n >= parts.Count)
                            {
                                throw new ParseException("Nullable assignment with no right-hand operator");
                            }

                            var result = InternalVariable;
                            var left   = new CodeBinaryOperatorExpression(result, CodeBinaryOperatorType.Assign, VarMixedExpr(parts[x]));

                            var eval = (CodeMethodInvokeExpression)InternalMethods.IfElse;
                            eval.Parameters.Add(left);
                            var ternary = new CodeTernaryOperatorExpression {
                                Condition = eval, TrueBranch = result
                            };

                            var right = new List <object>();

                            while (n < parts.Count)
                            {
                                right.Add(parts[n++]);
                            }

                            ternary.FalseBranch = ParseExpression(right);

                            parts[x] = ternary;
                            parts.RemoveRange(i, parts.Count - i);
                        }
                        #endregion
                        #region Unary
                        else if (x == -1)
                        {
                            int z = y + 1;
                            if (op == Script.Operator.LogicalNotEx && IsVarReference(parts[y]) && z < parts.Count)
                            {
                                MergeAssignmentAt(parts, z);
                            }

                            if (LaxExpressions)
                            {
                                if (y > parts.Count - 1)
                                {
                                    return(new CodePrimitiveExpression(null));
                                }
                            }

                            invoke.Method = (CodeMethodReferenceExpression)InternalMethods.OperateUnary;
                            invoke.Parameters.Add(OperatorAsFieldReference(op));
                            invoke.Parameters.Add(VarMixedExpr(parts[y]));
                            parts[i] = invoke;
                            parts.RemoveAt(y);
                        }
                        #endregion
                        #region Binary
                        else
                        {
                            if (op == Script.Operator.BooleanAnd || op == Script.Operator.BooleanOr)
                            {
                                var boolean = new CodeBinaryOperatorExpression();
                                boolean.Operator = op == Script.Operator.BooleanAnd ? CodeBinaryOperatorType.BooleanAnd : CodeBinaryOperatorType.BooleanOr;

                                var iftest = (CodeMethodInvokeExpression)InternalMethods.IfElse;
                                iftest.Parameters.Add(VarMixedExpr(parts[x]));
                                boolean.Left = iftest;

                                iftest = (CodeMethodInvokeExpression)InternalMethods.IfElse;
                                var next = parts[y] as Script.Operator?;
                                if (next == Script.Operator.BooleanAnd || next == Script.Operator.BooleanOr)
                                {
                                    if (LaxExpressions)
                                    {
                                        iftest.Parameters.Add(new CodePrimitiveExpression(false));
                                    }
                                    else
                                    {
                                        throw new ParseException(ExInvalidExpression);
                                    }
                                }
                                else
                                {
                                    iftest.Parameters.Add(VarMixedExpr(parts[y]));
                                    parts.RemoveAt(y);
                                }
                                boolean.Right = iftest;

                                parts[x] = boolean;
                            }
                            else
                            {
                                if (LaxExpressions)
                                {
                                    if (parts[x] is Script.Operator && (Script.Operator)parts[x] == Script.Operator.TernaryA)
                                    {
                                        parts[x] = new CodePrimitiveExpression(null);
                                        goto next;
                                    }

                                    if (y > parts.Count - 1)
                                    {
                                        return(new CodePrimitiveExpression(null));
                                    }
                                }
                                else
                                {
                                    throw new ParseException(ExInvalidExpression);
                                }

                                invoke.Method = (CodeMethodReferenceExpression)InternalMethods.Operate;
                                invoke.Parameters.Add(OperatorAsFieldReference(op));

                                if (LaxExpressions && parts[i] is Script.Operator && (Script.Operator)parts[i] == Script.Operator.Concat && parts[x] as CodeBinaryOperatorType? == CodeBinaryOperatorType.Assign)
                                {
                                    invoke.Parameters.Add(new CodePrimitiveExpression(string.Empty));
                                }
                                else
                                {
                                    invoke.Parameters.Add(VarMixedExpr(parts[x]));
                                }

                                invoke.Parameters.Add(VarMixedExpr(parts[y]));
                                parts[x] = invoke;

next:
                                parts.RemoveAt(y);
                            }

                            parts.RemoveAt(i);
                        }
                        #endregion

                        i--;
                    }
                    else if (parts[i] as CodeBinaryOperatorType? != CodeBinaryOperatorType.Assign)
                    {
                        var x = i - 1;

                        if (x > 0 && !(parts[x] is Script.Operator || parts[x] is CodeBinaryOperatorType))
                        {
                            parts.Insert(i, Script.Operator.Concat);
                            i--;
                            continue;
                        }
                    }
                }
                level--;
            }

            #endregion

            #endregion

            #region Assignments
            for (int i = parts.Count - 1; i > 0; i--)
            {
                MergeAssignmentAt(parts, i);
            }
            #endregion

            #region Result

            if (parts.Count > 1)
            {
                for (int i = 0; i < parts.Count; i++)
                {
                    bool typed = false;

                    if (LaxExpressions)
                    {
                        typed = IsVarAssignment(parts[i]) || IsVarReference(parts[i]);
                    }

                    if (!(typed || parts[i] is CodeMethodInvokeExpression || parts[i] is CodePrimitiveExpression || parts[i] is CodeTernaryOperatorExpression || parts[i] is CodeBinaryOperatorExpression || parts[i] is CodePropertyReferenceExpression))
                    {
                        throw new ArgumentOutOfRangeException();
                    }

                    if (i % 2 == 1)
                    {
                        parts.Insert(i, Script.Operator.Concat);
                    }
                }
                var concat = ParseExpression(parts);
                parts.Clear();
                parts.Add(concat);
            }

            if (parts.Count != 1)
            {
                throw new ArgumentOutOfRangeException();
            }

            if (IsVarAssignment(parts[0]))
            {
                return((CodeBinaryOperatorExpression)parts[0]);
            }
            else
            {
                return((CodeExpression)parts[0]);
            }

            #endregion
        }
 private static CodeMemberMethod CreateEventAsyncMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, string syncMethodName, CodeMemberMethod beginMethod, CodeMemberField beginOperationDelegate, CodeMemberMethod beginOperationMethod, CodeMemberField endOperationDelegate, CodeMemberMethod endOperationMethod, CodeMemberField operationCompletedDelegate, CodeMemberMethod operationCompletedMethod)
 {
     CodeMemberMethod nameCollection = new CodeMemberMethod();
     nameCollection.Name = NamingHelper.GetUniqueName(GetEventAsyncMethodName(syncMethodName), new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMethodNameExist), context.Operations);
     nameCollection.Attributes = MemberAttributes.Public | MemberAttributes.Final;
     nameCollection.ReturnType = new CodeTypeReference(voidType);
     CodeArrayCreateExpression expression = new CodeArrayCreateExpression(new CodeTypeReference(objectArrayType), new CodeExpression[0]);
     for (int i = 0; i < (beginMethod.Parameters.Count - 2); i++)
     {
         CodeParameterDeclarationExpression expression2 = beginMethod.Parameters[i];
         CodeParameterDeclarationExpression expression3 = new CodeParameterDeclarationExpression(expression2.Type, expression2.Name);
         expression3.Direction = FieldDirection.In;
         nameCollection.Parameters.Add(expression3);
         expression.Initializers.Add(new CodeVariableReferenceExpression(expression3.Name));
     }
     string name = NamingHelper.GetUniqueName("userState", new NamingHelper.DoesNameExist(ClientClassGenerator.DoesParameterNameExist), nameCollection);
     nameCollection.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(objectType), name));
     nameCollection.Statements.Add(CreateDelegateIfNotNull(beginOperationDelegate, beginOperationMethod));
     nameCollection.Statements.Add(CreateDelegateIfNotNull(endOperationDelegate, endOperationMethod));
     nameCollection.Statements.Add(CreateDelegateIfNotNull(operationCompletedDelegate, operationCompletedMethod));
     CodeMethodInvokeExpression expression4 = new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), invokeAsyncMethodName, new CodeExpression[0]);
     expression4.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), beginOperationDelegate.Name));
     if (expression.Initializers.Count > 0)
     {
         expression4.Parameters.Add(expression);
     }
     else
     {
         expression4.Parameters.Add(new CodePrimitiveExpression(null));
     }
     expression4.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), endOperationDelegate.Name));
     expression4.Parameters.Add(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), operationCompletedDelegate.Name));
     expression4.Parameters.Add(new CodeVariableReferenceExpression(name));
     nameCollection.Statements.Add(new CodeExpressionStatement(expression4));
     clientType.Members.Add(nameCollection);
     return nameCollection;
 }
        public CodeTypeDeclaration Parse(string resourceDirectory, IEnumerable <string> additionalResourceDirectories, bool isApp, Dictionary <string, string> resourceMap)
        {
            app = isApp;
            if (!Directory.Exists(resourceDirectory))
            {
                throw new ArgumentException("Specified resource directory was not found: " + resourceDirectory);
            }

            app           = isApp;
            map           = resourceMap ?? new Dictionary <string, string> ();
            resources     = CreateResourceClass();
            animation     = CreateClass("Animation");
            animator      = CreateClass("Animator");
            arrays        = CreateClass("Array");
            attrib        = CreateClass("Attribute");
            boolean       = CreateClass("Boolean");
            font          = CreateClass("Font");
            layout        = CreateClass("Layout");
            ids           = CreateClass("Id");
            ints          = CreateClass("Integer");
            interpolators = CreateClass("Interpolator");
            menu          = CreateClass("Menu");
            mipmaps       = CreateClass("Mipmap");
            drawable      = CreateClass("Drawable");
            strings       = CreateClass("String");
            colors        = CreateClass("Color");
            dimension     = CreateClass("Dimension");
            raw           = CreateClass("Raw");
            plurals       = CreateClass("Plurals");
            styleable     = CreateClass("Styleable");
            style         = CreateClass("Style");
            transition    = CreateClass("Transition");
            xml           = CreateClass("Xml");

            string publicXmlPath = Path.Combine(JavaPlatformDirectory, "data", "res", "values", "public.xml");

            if (File.Exists(publicXmlPath))
            {
                publicXml = XDocument.Load(publicXmlPath);
            }

            var resModifiedDate = !string.IsNullOrEmpty(ResourceFlagFile) && File.Exists(ResourceFlagFile)
                                ? File.GetLastWriteTimeUtc(ResourceFlagFile)
                                : DateTime.MinValue;
            // This top most R.txt will contain EVERYTHING we need. including library resources since it represents
            // the final build.
            var rTxt = Path.Combine(resourceDirectory, "..", "R.txt");

            Log.LogDebugMessage($"Checking {rTxt} {File.Exists (rTxt)} {File.GetLastWriteTimeUtc (rTxt)} {resModifiedDate}");
            if (File.Exists(rTxt) && File.GetLastWriteTimeUtc(rTxt) > resModifiedDate)
            {
                Log.LogDebugMessage($"Processing File {rTxt}");
                ProcessRtxtFile(rTxt);
            }
            else
            {
                Log.LogDebugMessage($"Processing Directory {resourceDirectory}");
                foreach (var dir in Directory.EnumerateDirectories(resourceDirectory, "*", SearchOption.TopDirectoryOnly))
                {
                    foreach (var file in Directory.EnumerateFiles(dir, "*.*", SearchOption.AllDirectories))
                    {
                        ProcessResourceFile(file);
                    }
                }
                if (additionalResourceDirectories != null)
                {
                    foreach (var dir in additionalResourceDirectories)
                    {
                        Log.LogDebugMessage($"Processing Directory {dir}");
                        if (Directory.Exists(dir))
                        {
                            foreach (var file in Directory.EnumerateFiles(dir, "*.*", SearchOption.AllDirectories))
                            {
                                ProcessResourceFile(file);
                            }
                        }
                        else
                        {
                            Log.LogDebugMessage($"Skipping non-existent directory: {dir}");
                        }
                    }
                }
            }

            SortMembers(animation);
            SortMembers(animator);
            SortMembers(ids);
            SortMembers(attrib);
            SortMembers(arrays);
            SortMembers(boolean);
            SortMembers(colors);
            SortMembers(dimension);
            SortMembers(drawable);
            SortMembers(font);
            SortMembers(ints);
            SortMembers(interpolators);
            SortMembers(layout);
            SortMembers(mipmaps);
            SortMembers(menu);
            SortMembers(raw);
            SortMembers(plurals);
            SortMembers(strings);
            SortMembers(style);
            SortMembers(transition);
            SortMembers(xml);

            declarationIds.Add(attrib);
            declarationIds.Add(drawable);
            declarationIds.Add(mipmaps);
            declarationIds.Add(font);
            declarationIds.Add(layout);
            declarationIds.Add(animation);
            declarationIds.Add(animator);
            declarationIds.Add(transition);
            declarationIds.Add(xml);
            declarationIds.Add(raw);
            declarationIds.Add(dimension);
            declarationIds.Add(strings);
            declarationIds.Add(arrays);
            declarationIds.Add(plurals);
            declarationIds.Add(boolean);
            declarationIds.Add(colors);
            declarationIds.Add(ints);
            declarationIds.Add(menu);
            declarationIds.Add(ids);

            foreach (var customClass in custom_types)
            {
                SortMembers(customClass.Value);
                declarationIds.Add(customClass.Value);
            }

            declarationIds.Add(interpolators);
            declarationIds.Add(style);
            declarationIds.Add(styleable);

            declarationIds.Sort((a, b) => {
                return(string.Compare(a.Name, b.Name, StringComparison.OrdinalIgnoreCase));
            });

            foreach (var codeDeclaration in declarationIds)
            {
                int itemid = 0;
                Log.LogDebugMessage($"Processing {codeDeclaration.Name}");

                // We have to get the members in a different store order here becuase
                // aapt2 generates the ids based on an `Ordinal` order, but the
                // field output is in an `OrdinalIgnoreCase`.
                foreach (var fieldDeclaration in SortedMembers(codeDeclaration, StringComparer.Ordinal))
                {
                    CodeMemberField field = fieldDeclaration as CodeMemberField;
                    if (field == null)
                    {
                        continue;
                    }
                    int typeid = typeIds.IndexOf(codeDeclaration) + 1;
                    if (typeid == 0)
                    {
                        Log.LogDebugMessage($"Adding code declaration for {codeDeclaration.Name} {typeid}");
                        typeIds.Add(codeDeclaration);
                        typeid = typeIds.Count;
                    }
                    Log.LogDebugMessage($"code declaration {codeDeclaration.Name} typeid = {typeid} {field.Name}");
                    if (field.InitExpression == null)
                    {
                        Log.LogDebugMessage($"Adding InitExpression for {field.Name}");
                        int id = Convert.ToInt32(itemPackageId + typeid.ToString("X2") + itemid.ToString("X4"), fromBase: 16);
                        Log.LogDebugMessage($"{itemPackageId} {id} {itemid} = {id.ToString ("X")}");
                        field.InitExpression = new CodePrimitiveExpression(id);
                        field.Comments.Add(new CodeCommentStatement($"aapt resource value: 0x{id.ToString ("X")}"));
                        itemid++;
                    }
                }
            }

            var sb = new StringBuilder();
            SortedDictionary <int, CodeMemberField> arrayValues = new SortedDictionary <int, CodeMemberField> ();
            int value;

            foreach (var kvp in arrayMapping)
            {
                CodeMemberField           field      = kvp.Key;
                CodeArrayCreateExpression expression = field.InitExpression as CodeArrayCreateExpression;
                CodeMemberField []        fields     = kvp.Value;

                int count = expression.Initializers.Count;
                sb.Clear();
                arrayValues.Clear();
                for (int i = 0; i < count; i++)
                {
                    string name = fields [i].Name;
                    if (name.StartsWith("android:", StringComparison.OrdinalIgnoreCase))
                    {
                        name = name.Replace("android:", string.Empty);
                        var element = publicXml?.XPathSelectElement($"/resources/public[@name='{name}']") ?? null;
                        value = Convert.ToInt32(element?.Attribute("id")?.Value ?? "0x0", fromBase: 16);
                    }
                    else
                    {
                        CodePrimitiveExpression initExpression = fields [i].InitExpression as CodePrimitiveExpression;
                        value = Convert.ToInt32(initExpression.Value);
                    }
                    arrayValues.Add(value, fields [i]);
                }
                int index = 0;
                foreach (var arrayValue in arrayValues)
                {
                    value = arrayValue.Key;
                    CodeMemberField         f    = arrayValue.Value;
                    CodePrimitiveExpression code = expression.Initializers [index] as CodePrimitiveExpression;
                    code.Value = value;
                    CreateIntField(styleable, $"{field.Name}_{f.Name}", index);
                    sb.Append($"0x{value.ToString ("X")}");
                    if (index < count - 1)
                    {
                        sb.Append(",");
                    }
                    index++;
                }
                field.Comments.Add(new CodeCommentStatement($"aapt resource value: {{ {sb} }}"));
            }

            SortMembers(styleable);

            foreach (var customClass in custom_types)
            {
                resources.Members.Add(customClass.Value);
            }

            if (animation.Members.Count > 1)
            {
                resources.Members.Add(animation);
            }
            if (animator.Members.Count > 1)
            {
                resources.Members.Add(animator);
            }
            if (arrays.Members.Count > 1)
            {
                resources.Members.Add(arrays);
            }
            //NOTE: aapt always emits Resource.Attribute, so we are replicating that
            resources.Members.Add(attrib);
            if (boolean.Members.Count > 1)
            {
                resources.Members.Add(boolean);
            }
            if (colors.Members.Count > 1)
            {
                resources.Members.Add(colors);
            }
            if (dimension.Members.Count > 1)
            {
                resources.Members.Add(dimension);
            }
            if (drawable.Members.Count > 1)
            {
                resources.Members.Add(drawable);
            }
            if (font.Members.Count > 1)
            {
                resources.Members.Add(font);
            }
            if (ids.Members.Count > 1)
            {
                resources.Members.Add(ids);
            }
            if (ints.Members.Count > 1)
            {
                resources.Members.Add(ints);
            }
            if (interpolators.Members.Count > 1)
            {
                resources.Members.Add(interpolators);
            }
            if (layout.Members.Count > 1)
            {
                resources.Members.Add(layout);
            }
            if (menu.Members.Count > 1)
            {
                resources.Members.Add(menu);
            }
            if (mipmaps.Members.Count > 1)
            {
                resources.Members.Add(mipmaps);
            }
            if (raw.Members.Count > 1)
            {
                resources.Members.Add(raw);
            }
            if (plurals.Members.Count > 1)
            {
                resources.Members.Add(plurals);
            }
            if (strings.Members.Count > 1)
            {
                resources.Members.Add(strings);
            }
            if (style.Members.Count > 1)
            {
                resources.Members.Add(style);
            }
            if (styleable.Members.Count > 1)
            {
                resources.Members.Add(styleable);
            }
            if (transition.Members.Count > 1)
            {
                resources.Members.Add(transition);
            }
            if (xml.Members.Count > 1)
            {
                resources.Members.Add(xml);
            }

            return(resources);
        }
Пример #25
0
    public override void BuildTree (CodeDomProvider provider, CodeCompileUnit cu) {
        CodeNamespace ns = new CodeNamespace ("Namespace1");
        cu.Namespaces.Add (ns);

        // GENERATES (C#):
        //    public class Class2 {
        //            public int number;
        //        }
        CodeTypeDeclaration class1 = new CodeTypeDeclaration ("Class2");
        class1.IsClass = true;
        ns.Types.Add (class1);

        CodeMemberField field = new CodeMemberField (typeof (int), "number");
        field.Attributes = MemberAttributes.Final | MemberAttributes.Public;
        class1.Members.Add (field);

        class1 = new CodeTypeDeclaration ();
        class1.Name = "Class1";
        class1.BaseTypes.Add (new CodeTypeReference (typeof (object)));
        ns.Types.Add (class1);


        // the following method tests sized arrays, initialized arrays, standard arrays of small size
        // GENERATES (C#):
        //       public long ArrayMethod(int parameter) {
        //                int arraySize = 3;
        //                int[] array1;
        //                int[] array2 = new int[3];
        //                int[] array3 = new int[] {1,
        //                        4,
        //                        9};
        //                array1 = new int[arraySize];
        //                long retValue = 0;
        //                int i;
        //                for (i = 0; (i < array1.Length); i = (i + 1)) {
        //                    array1[i] = (i * i);
        //                    array2[i] = (array1[i] - i);
        //                    retValue = (retValue 
        //                                + (array1[i] 
        //                                + (array2[i] + array3[i])));
        //                }
        //                return retValue;
        //            }

        AddScenario ("CallArrayMethod", "Call and check the return value of ArrayMethod()");
        CodeMemberMethod arrayMethod = new CodeMemberMethod ();
        arrayMethod.Name = "ArrayMethod";
        arrayMethod.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "parameter"));
        arrayMethod.Attributes = (arrayMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
        arrayMethod.ReturnType = new CodeTypeReference (typeof (System.Int32));

        arrayMethod.Statements.Add (
            new CodeVariableDeclarationStatement (typeof (int), "arraySize", new CodePrimitiveExpression (3)));

        // dummy array creates
        arrayMethod.Statements.Add (new CodeVariableDeclarationStatement (typeof (int[]),
                    "dummyArray1", new CodeArrayCreateExpression (typeof (int[]), 10)));
        arrayMethod.Statements.Add (new CodeVariableDeclarationStatement (typeof (int[]),
                    "dummyArray2", new CodeArrayCreateExpression (typeof (int[]),
                        new CodeVariableReferenceExpression ("arraySize"))));

        arrayMethod.Statements.Add (
            new CodeVariableDeclarationStatement (typeof (int[]), "array1"));

        CodeArrayCreateExpression creatExp = new CodeArrayCreateExpression ();
        creatExp.CreateType = new CodeTypeReference (typeof (int[]));
        creatExp.Size = 3;

        arrayMethod.Statements.Add (
            new CodeVariableDeclarationStatement (
            new CodeTypeReference ("System.Int32", 1),
            "array2",
            creatExp));

        arrayMethod.Statements.Add (
            new CodeVariableDeclarationStatement (
            new CodeTypeReference ("System.Int32", 1),
            "array3",
            new CodeArrayCreateExpression (
            new CodeTypeReference ("System.Int32", 1),
            new CodeExpression[] {
                new CodePrimitiveExpression ((int)1), 
                new CodePrimitiveExpression ((int)4),
                new CodePrimitiveExpression ((int)9), })));

        creatExp = new CodeArrayCreateExpression ();
        creatExp.CreateType = new CodeTypeReference (typeof (int[]));
        creatExp.SizeExpression = new CodeVariableReferenceExpression ("arraySize");

        arrayMethod.Statements.Add (new CodeAssignStatement (new CodeVariableReferenceExpression ("array1"), creatExp));
        
        arrayMethod.Statements.Add (
            new CodeVariableDeclarationStatement (typeof (System.Int32), "retValue", new CodePrimitiveExpression ((int)0))); 
        arrayMethod.Statements.Add (
            new CodeVariableDeclarationStatement (typeof (int), "i"));
        arrayMethod.Statements.Add (
            new CodeIterationStatement (
            new CodeAssignStatement (new CodeVariableReferenceExpression ("i"), new CodePrimitiveExpression (0)),
            new CodeBinaryOperatorExpression (
            new CodeVariableReferenceExpression ("i"),
            CodeBinaryOperatorType.LessThan,
            new CodePropertyReferenceExpression (
            new CodeVariableReferenceExpression ("array1"),
            "Length")),
            new CodeAssignStatement (
            new CodeVariableReferenceExpression ("i"),
            new CodeBinaryOperatorExpression (
            new CodeVariableReferenceExpression ("i"),
            CodeBinaryOperatorType.Add,
            new CodePrimitiveExpression (1))),
            new CodeAssignStatement (
            new CodeArrayIndexerExpression (
            new CodeVariableReferenceExpression ("array1"),
            new CodeVariableReferenceExpression ("i")),
            new CodeBinaryOperatorExpression (
            new CodeVariableReferenceExpression ("i"),
            CodeBinaryOperatorType.Multiply,
            new CodeVariableReferenceExpression ("i"))),
            new CodeAssignStatement (
            new CodeArrayIndexerExpression (
            new CodeVariableReferenceExpression ("array2"),
            new CodeVariableReferenceExpression ("i")),
            new CodeBinaryOperatorExpression (
            new CodeArrayIndexerExpression (
            new CodeVariableReferenceExpression ("array1"),
            new CodeVariableReferenceExpression ("i")),
            CodeBinaryOperatorType.Subtract,
            new CodeVariableReferenceExpression ("i"))),
            new CodeAssignStatement(
            new CodeVariableReferenceExpression("retValue"),
            new CodeBinaryOperatorExpression(
            new CodeVariableReferenceExpression("retValue"),
            CodeBinaryOperatorType.Add,
            new CodeBinaryOperatorExpression(
            new CodeArrayIndexerExpression(
            new CodeVariableReferenceExpression("array1"),
            new CodeVariableReferenceExpression("i")),
            CodeBinaryOperatorType.Add,
            new CodeBinaryOperatorExpression(
            new CodeArrayIndexerExpression(
            new CodeVariableReferenceExpression("array2"),
            new CodeVariableReferenceExpression("i")),
            CodeBinaryOperatorType.Add,
            new CodeArrayIndexerExpression(
            new CodeVariableReferenceExpression("array3"),
            new CodeVariableReferenceExpression("i"))))))));
        arrayMethod.Statements.Add(
            new CodeMethodReturnStatement (new CodeVariableReferenceExpression ("retValue")));
        class1.Members.Add (arrayMethod);


        // GENERATES (C#):
        //        public int MoreArrayTests(int i) {
        //                int[][] arrayOfArrays = new int[][] {new int[] {3,
        //                                4},
        //                        new int[1],
        //                        new int[0]};
        //                int[] array2 = new int[0];
        //                Class2[] arrayType = new Class2[2];
        //                arrayType[1] = new Class2();
        //                arrayType[1].number = (arrayOfArrays[0][1] + i);
        //                return arrayType[1].number;
        //            }

        AddScenario ("CallMoreArrayTests", "Call and check the return value of MoreArrayTests()");
        CodeMemberMethod secondMethod = new CodeMemberMethod ();
        secondMethod.Name = "MoreArrayTests";
        secondMethod.Attributes = (arrayMethod.Attributes & ~MemberAttributes.AccessMask) | MemberAttributes.Public;
        secondMethod.ReturnType = new CodeTypeReference (typeof (int));
        secondMethod.Parameters.Add (new CodeParameterDeclarationExpression (typeof (int), "i"));

        // array of arrays
        // in Everett, VB doesn't support array of array initialization
        if (Supports (provider, GeneratorSupport.ArraysOfArrays) && !(provider is VBCodeProvider)) {
            secondMethod.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference (typeof (int[][])),
                "arrayOfArrays", new CodeArrayCreateExpression (typeof (int[][]),
                new CodeArrayCreateExpression (typeof (int[]), new CodePrimitiveExpression (3), new CodePrimitiveExpression (4)),
                new CodeArrayCreateExpression (typeof (int[]), new CodePrimitiveExpression (1)), new CodeArrayCreateExpression (typeof (int[])))));
        }

        //empty array
        secondMethod.Statements.Add (new CodeVariableDeclarationStatement (
            new CodeTypeReference ("System.Int32", 1), "array2",
            new CodeArrayCreateExpression (typeof (int[]), new CodePrimitiveExpression (0))));

        // array of nonprimitive type
        secondMethod.Statements.Add (new CodeVariableDeclarationStatement (new CodeTypeReference ("Class2", 1),
            "arrayType", new CodeArrayCreateExpression (new CodeTypeReference ("Class2", 1), new CodePrimitiveExpression (2))));
        secondMethod.Statements.Add (new CodeAssignStatement (new CodeArrayIndexerExpression (new CodeVariableReferenceExpression ("arrayType"),
            new CodePrimitiveExpression (1)), new CodeObjectCreateExpression (new CodeTypeReference ("Class2"))));

        // in Everett, VB doesn't support array of array initialization
        if (Supports (provider, GeneratorSupport.ArraysOfArrays) && !(provider is VBCodeProvider)) {
            secondMethod.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression
                (new CodeArrayIndexerExpression (new CodeVariableReferenceExpression ("arrayType"),
                new CodePrimitiveExpression (1)), "number"),
                new CodeBinaryOperatorExpression (new CodeArrayIndexerExpression (
                new CodeArrayIndexerExpression (new CodeVariableReferenceExpression ("arrayOfArrays"), new CodePrimitiveExpression (0))
                , new CodePrimitiveExpression (1)),
                CodeBinaryOperatorType.Add, new CodeArgumentReferenceExpression ("i"))));
        }
        else {
            // If the code provider doesn't support ArrayOfArrays this is generated:
            //   arrayType[1].number = i;
            secondMethod.Statements.Add (new CodeAssignStatement (new CodeFieldReferenceExpression
                (new CodeArrayIndexerExpression (new CodeVariableReferenceExpression ("arrayType"),
                new CodePrimitiveExpression (1)), "number"),
                new CodeArgumentReferenceExpression ("i")));

        }
        secondMethod.Statements.Add (new CodeMethodReturnStatement (new CodeFieldReferenceExpression
            (new CodeArrayIndexerExpression (new CodeVariableReferenceExpression ("arrayType"),
            new CodePrimitiveExpression (1)), "number")));

        class1.Members.Add (secondMethod);
    }
Пример #26
0
        public static void Process()
        {
            foreach (var f in Directory.GetFiles("ClassInformation").Reverse())
            {
                var xamlDocument = XDocument.Load(f);

                var xmlNameSpace     = xamlDocument.Root;
                var xmlNameSpaceName = xmlNameSpace?.Attribute("name")?.Value ?? string.Empty;
                if (xmlNameSpace == null)
                {
                    throw new NullReferenceException("Namespace is null!");
                }

                var compileUnit = new CodeCompileUnit();
                var nameSpace   = new CodeNamespace(xmlNameSpaceName);

                foreach (var elX in xmlNameSpace.Elements())
                {
                    switch (elX.Name.LocalName)
                    {
                    case "class":
                    {
                        var className = elX.Attribute("name")?.Value;
                        var cls       = new CodeTypeDeclaration(className)
                        {
                            IsClass = true
                        };

                        #region Packer
                        var packer = new CodeMemberMethod();
                        {
                            packer.Name       = "Pack";
                            packer.ReturnType = new CodeTypeReference(typeof(byte[]));
                            packer.Attributes = MemberAttributes.Public;

                            var packerMemoryStream =
                                new CodeVariableDeclarationStatement("using System.IO.MemoryStream", "ms")
                            {
                                InitExpression = new CodeObjectCreateExpression("System.IO.MemoryStream")
                            };

                            {
                                packer.Statements.Add(packerMemoryStream);

                                foreach (var elClass in elX.Elements())
                                {
                                    if (elClass.Attribute("write")?.Value == "False")
                                    {
                                        continue;
                                    }

                                    switch (elClass.Attribute("type")?.Value)
                                    {
                                    case "System.String":
                                    {
                                        var isEncrypted = elClass.Attribute("encrypted")?.Value == "True";
                                        CodeMethodInvokeExpression getBytesFromString;
                                        if (isEncrypted)
                                        {
                                            getBytesFromString = new CodeMethodInvokeExpression(
                                                new CodeThisReferenceExpression(),
                                                "EncryptName");
                                        }
                                        else
                                        {
                                            getBytesFromString = new CodeMethodInvokeExpression(
                                                new CodeTypeReferenceExpression("System.Text.Encoding"),
                                                "ASCII.GetBytes",
                                                new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
                                                                                 elClass.Attribute("name")?.Value));
                                        }

                                        var stringDataVariable =
                                            new CodeVariableDeclarationStatement("System.Byte[]",
                                                                                 "var_" + elClass.Attribute("name")?.Value)
                                        {
                                            InitExpression = getBytesFromString
                                        };

                                        packer.Statements.Add(stringDataVariable);

                                        var getByteCount =
                                            new CodeVariableReferenceExpression(
                                                "var_" + elClass.Attribute("name")?.Value + ".Length");

                                        var bitConverterGetBytes = new CodeMethodInvokeExpression(
                                            new CodeTypeReferenceExpression("System.BitConverter"),
                                            "GetBytes",
                                            new CodeCastExpression("System.UInt16", getByteCount));

                                        var packerMemoryStreamWriteLength = new CodeMethodInvokeExpression(
                                            new CodeVariableReferenceExpression("ms"),
                                            "Write", bitConverterGetBytes);

                                        var packerMemoryStreamWrite = new CodeMethodInvokeExpression(
                                            new CodeVariableReferenceExpression("ms"),
                                            "Write",
                                            new CodeVariableReferenceExpression(
                                                "var_" + elClass.Attribute("name")?.Value));

                                        packer.Statements.Add(packerMemoryStreamWriteLength);
                                        packer.Statements.Add(packerMemoryStreamWrite);
                                        break;
                                    }

                                    case "System.Byte[]":
                                    {
                                        var packerMemoryStreamWrite = new CodeMethodInvokeExpression(
                                            new CodeVariableReferenceExpression("ms"),
                                            "Write",
                                            new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
                                                                             elClass.Attribute("name")?.Value));

                                        packer.Statements.Add(packerMemoryStreamWrite);
                                        break;
                                    }

                                    case "System.Drawing.Color":
                                    {
                                        var packerColorToArgb = new CodeMethodInvokeExpression(
                                            new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
                                                                             elClass.Attribute("name")?.Value),
                                            "ToArgb");

                                        var bitConverterGetBytes = new CodeMethodInvokeExpression(
                                            new CodeTypeReferenceExpression("System.BitConverter"),
                                            "GetBytes",
                                            packerColorToArgb);

                                        var packerMemoryStreamWrite = new CodeMethodInvokeExpression(
                                            new CodeVariableReferenceExpression("ms"),
                                            "Write", bitConverterGetBytes);

                                        packer.Statements.Add(packerMemoryStreamWrite);
                                        break;
                                    }

                                    case "System.TimeSpan":
                                    {
                                        var packerTimeSpanTotalSeconds =
                                            new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
                                                                             elClass.Attribute("name")?.Value + ".TotalMilliseconds");

                                        var bitConverterGetBytes = new CodeMethodInvokeExpression(
                                            new CodeTypeReferenceExpression("System.BitConverter"),
                                            "GetBytes",
                                            packerTimeSpanTotalSeconds);

                                        var packerMemoryStreamWrite = new CodeMethodInvokeExpression(
                                            new CodeVariableReferenceExpression("ms"),
                                            "Write", bitConverterGetBytes);

                                        packer.Statements.Add(packerMemoryStreamWrite);
                                        break;
                                    }

                                    case "System.SByte":
                                    case "System.Byte":
                                    {
                                        var packerMemoryStreamWrite = new CodeMethodInvokeExpression(
                                            new CodeVariableReferenceExpression("ms"),
                                            "WriteByte", new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
                                                                                          elClass.Attribute("name")?.Value));

                                        packer.Statements.Add(packerMemoryStreamWrite);

                                        break;
                                    }

                                    default:
                                    {
                                        if (elClass.Attribute("then")?.Value == "Generated.ItemsDb.Enums.ItemId")
                                        {
                                            var bitConverterGetBytes = new CodeMethodInvokeExpression(
                                                new CodeTypeReferenceExpression("System.BitConverter"),
                                                "GetBytes",
                                                new CodeCastExpression(elClass.Attribute("type")?.Value, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
                                                                                                                                          elClass.Attribute("name")?.Value))
                                                );

                                            var packerMemoryStreamWrite = new CodeMethodInvokeExpression(
                                                new CodeVariableReferenceExpression("ms"),
                                                "Write", bitConverterGetBytes);

                                            packer.Statements.Add(packerMemoryStreamWrite);
                                        }
                                        else
                                        {
                                            var bitConverterGetBytes = new CodeMethodInvokeExpression(
                                                new CodeTypeReferenceExpression("System.BitConverter"),
                                                "GetBytes",
                                                new CodeFieldReferenceExpression(new CodeThisReferenceExpression(),
                                                                                 elClass.Attribute("name")?.Value));

                                            var packerMemoryStreamWrite = new CodeMethodInvokeExpression(
                                                new CodeVariableReferenceExpression("ms"),
                                                "Write", bitConverterGetBytes);

                                            packer.Statements.Add(packerMemoryStreamWrite);
                                        }

                                        break;
                                    }
                                    }
                                }
                            }

                            var packerMemoryStreamToArray = new CodeMethodInvokeExpression(
                                new CodeVariableReferenceExpression("ms"),
                                "ToArray");

                            packer.Statements.Add(new CodeMethodReturnStatement(packerMemoryStreamToArray));
                        }
                        cls.Members.Add(packer);
                        #endregion
                        Console.WriteLine("Generate Packer in {0}", xmlNameSpaceName);

                        #region Encryption
                        var nameEncryptor = new CodeMemberMethod();
                        {
                            nameEncryptor.Name       = "EncryptName";
                            nameEncryptor.ReturnType = new CodeTypeReference("System.Byte[]");

                            nameEncryptor.Statements.Add(
                                new CodeSnippetStatement("            const string secret = \"PBG892FXX982ABC*\";"));
                            nameEncryptor.Statements.Add(
                                new CodeSnippetStatement("            var encrypted = new byte[Name.Length];"));
                            nameEncryptor.Statements.Add(
                                new CodeSnippetStatement("            for (var i = 0; i < Name.Length; i++)"));
                            nameEncryptor.Statements.Add(
                                new CodeSnippetStatement("                encrypted[i] = (byte) (Name[i] ^ (secret[(i + (int) ItemId) % secret.Length]));"));
                            nameEncryptor.Statements.Add(
                                new CodeSnippetStatement("            return encrypted;"));
                        }

                        cls.Members.Add(nameEncryptor);
                        #endregion
                        Console.WriteLine("Generate Name Encryption in {0}", xmlNameSpaceName);

                        #region Properties

                        foreach (var elClass in elX.Elements())
                        {
                            var nm = elClass.Attribute("name")?.Value ?? string.Empty;

                            var t    = elClass.Attribute("type")?.Value ?? "System.Object";
                            var then = elClass.Attribute("then")?.Value ?? t;

                            Console.WriteLine("Generate Property {1} width Type {2} in {0}", xmlNameSpaceName, nm, then);

                            var prop = new CodeMemberProperty {
                                Attributes = MemberAttributes.Public
                            };
                            prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeDefaultValueExpression(new CodeTypeReference(then))));

                            prop.Name = nm;
                            prop.Type = new CodeTypeReference(then);

                            cls.Members.Add(prop);
                        }

                        #endregion

                        nameSpace.Types.Add(cls);

                        Console.WriteLine("Decoding Items.dat...");
                        _decoder.Decode(elX, "items.dat");
                    } break;

                    case "enum":
                    {
                        var className = elX.Attribute("name")?.Value;
                        var cls       = new CodeTypeDeclaration(className)
                        {
                            IsEnum = true
                        };

                        foreach (var item in _decoder.Data)
                        {
                            var field = new CodeMemberField(className, SerializeName("i" + item["ItemId"] + "_" + item["Name"]));

                            Console.WriteLine("Generate BlockId {0}", field.Name);

                            field.InitExpression = new CodeSnippetExpression($"{ (int) item["ItemId"] }");

                            cls.Members.Add(field);
                        }
                        nameSpace.Types.Add(cls);
                    } break;

                    default:
                        throw new ArgumentOutOfRangeException(nameof(elX), "Unknown type!");
                    }
                }

                nameSpace.Imports.Add(new CodeNamespaceImport("System.Linq"));
                compileUnit.Namespaces.Add(nameSpace);

                var provider = new CSharpCodeProvider();

                var fileName = nameSpace.Name.Split(".").Last();
                var path     = "../GTItemBindings.Generated/" + string.Join("/", nameSpace.Name.Split(".").Where(x => x != fileName));

                Directory.CreateDirectory(path);

                using var ms = File.Open(path + "/" + fileName + ".cs", FileMode.OpenOrCreate, FileAccess.ReadWrite);
                using var sw = new StreamWriter(ms);
                using var tw = new IndentedTextWriter(sw, "    ");

                // Generate source code using the code provider.
                provider.GenerateCodeFromCompileUnit(compileUnit, tw,
                                                     new CodeGeneratorOptions());
            }

            foreach (var item in _decoder.Data)
            {
                var compileUnit = new CodeCompileUnit();

                var clsName = "I" + item["ItemId"] + "_" + SerializeName((string)item["Name"]);
                Console.WriteLine("Generate Item Class " + clsName);
                var nameSpace = new CodeNamespace("Generated.ItemsDb.Items");

                var itemCls = new CodeTypeDeclaration(clsName);
                itemCls.BaseTypes.Add("Generated.ItemsDb.Item.Item");

                foreach (var(name, value) in item)
                {
                    #region Props

                    var prop = new CodeMemberProperty {
                        Attributes = MemberAttributes.Public
                    };

                    switch (value)
                    {
                    case TimeSpan span:
                    {
                        var primitiveExpression = new CodePrimitiveExpression(span.Ticks);

                        prop.GetStatements.Add(new CodeMethodReturnStatement(new CodeObjectCreateExpression(span.GetType(), primitiveExpression)));
                        break;
                    }

                    case Color color:
                    {
                        var primitiveExpression = new CodePrimitiveExpression(color.ToArgb());

                        var colFromArgb = new CodeMethodInvokeExpression(
                            new CodeVariableReferenceExpression("System.Drawing.Color"),
                            "FromArgb", primitiveExpression);

                        prop.GetStatements.Add(new CodeMethodReturnStatement(colFromArgb));
                        break;
                    }

                    case byte[] bytes:
                    {
                        var primitiveExpressions = (from v in bytes select new CodePrimitiveExpression(v)).ToArray();

                        var primitiveExpression = new CodeArrayCreateExpression(bytes.GetType(), primitiveExpressions);

                        prop.GetStatements.Add(new CodeMethodReturnStatement(primitiveExpression));
                        break;
                    }

                    default:
                    {
                        var primitiveExpression = new CodePrimitiveExpression(value);
                        prop.GetStatements.Add(name != "ItemId"
                                ? new CodeMethodReturnStatement(new CodeCastExpression(value.GetType(),
                                                                                       primitiveExpression))
                                : new CodeMethodReturnStatement(new CodeCastExpression("Generated.ItemsDb.Enums.ItemId",
                                                                                       primitiveExpression)));
                        break;
                    }
                    }

                    prop.Attributes = MemberAttributes.Public | MemberAttributes.Override;
                    prop.Name       = name;

                    prop.Type = name != "ItemId" ?
                                new CodeTypeReference(value.GetType()) :
                                new CodeTypeReference("Generated.ItemsDb.Enums.ItemId");

                    itemCls.Members.Add(prop);

                    #endregion
                }

                nameSpace.Types.Add(itemCls);
                compileUnit.Namespaces.Add(nameSpace);

                var provider = new CSharpCodeProvider();

                var fileName = clsName;
                var path     = "../GTItemBindings.Generated/" + string.Join("/", nameSpace.Name.Split(".").Where(x => x != fileName));

                Directory.CreateDirectory(path);

                using var ms = File.Open(path + "/" + fileName + ".cs", FileMode.OpenOrCreate, FileAccess.ReadWrite);
                using var sw = new StreamWriter(ms);
                using var tw = new IndentedTextWriter(sw, "    ");

                // Generate source code using the code provider.
                provider.GenerateCodeFromCompileUnit(compileUnit, tw,
                                                     new CodeGeneratorOptions());
            }
        }
Пример #27
0
    public CodeMemberMethod GenerateMethod(Smoke* smoke, Smoke.Method* method, string mungedName, CodeTypeReference iface)
    {
        string cppSignature = smoke->GetMethodSignature(method);
        CodeMemberMethod cmm = GenerateBasicMethodDefinition(smoke, method, cppSignature, iface);
        if (cmm == null)
        {
            return null;
        }

        // put the method into the correct type
        CodeTypeDeclaration containingType = type;
        if (cmm.Name.StartsWith("operator") || cmm.Name.StartsWith("explicit "))
        {
            if (!data.CSharpTypeMap.TryGetValue(cmm.Parameters[0].Type.GetStringRepresentation(), out containingType))
            {
                if (cmm.Parameters.Count < 2 ||
                    !data.CSharpTypeMap.TryGetValue(cmm.Parameters[1].Type.GetStringRepresentation(), out containingType))
                {
                    Debug.Print("  |--Can't find containing type for {0} - skipping", cppSignature);
                }
                return null;
            }
        }

        // already implemented?
        if (containingType.HasMethod(cmm))
        {
            if (iface == null || (method->flags & (uint) Smoke.MethodFlags.mf_protected) > 0)
            {
                // protected methods are not available in interfaces
                Debug.Print("  |--Skipping already implemented method {0}", cppSignature);
                return null;
            }
            else
            {
                cmm.PrivateImplementationType = iface;
            }
        }

        if (PreMethodBodyHooks != null)
        {
            PreMethodBodyHooks(smoke, method, cmm, containingType);
        }

        // do we have pass-by-ref parameters?
        bool generateInvokeForRefParams = cmm.Parameters.Cast<CodeParameterDeclarationExpression>().Any(expr => expr.Direction == FieldDirection.Ref);

        // generate the SmokeMethod attribute
        CodeAttributeDeclaration attr = new CodeAttributeDeclaration("SmokeMethod",
                                                                     new CodeAttributeArgument(
                                                                     	new CodePrimitiveExpression(cppSignature)));
        cmm.CustomAttributes.Add(attr);

        // choose the correct 'interceptor'
        CodeMethodInvokeExpression invoke;
        if ((cmm.Attributes & MemberAttributes.Static) == MemberAttributes.Static)
        {
            invoke = new CodeMethodInvokeExpression(SmokeSupport.staticInterceptor_Invoke);
        }
        else
        {
            invoke = new CodeMethodInvokeExpression(SmokeSupport.interceptor_Invoke);
        }

        // first pass the munged name, then the C++ signature
        invoke.Parameters.Add(new CodePrimitiveExpression(mungedName));
        invoke.Parameters.Add(new CodePrimitiveExpression(cppSignature));

        // retrieve the return type
        CodeTypeReference returnType;
        if ((method->flags & (uint) Smoke.MethodFlags.mf_dtor) > 0)
        {
            // destructor
            returnType = new CodeTypeReference(typeof(void));
        }
        else if (cmm.Name.StartsWith("explicit operator "))
        {
            // strip 'explicit operator' from the name to get the return type
            returnType = new CodeTypeReference(cmm.Name.Substring(18));
        }
        else
        {
            returnType = cmm.ReturnType;
        }

        // add the return type
        invoke.Parameters.Add(new CodeTypeOfExpression(returnType));
        invoke.Parameters.Add(new CodePrimitiveExpression(generateInvokeForRefParams));
        invoke.Parameters.Add(new CodeVariableReferenceExpression("smokeArgs"));

        ProcessEqualityOperators(cmm);

        CodeArrayCreateExpression argsInitializer = new CodeArrayCreateExpression(typeof(object[]));

        // add the parameters
        foreach (CodeParameterDeclarationExpression param in cmm.Parameters)
        {
            argsInitializer.Initializers.Add(new CodeTypeOfExpression(param.Type));
            string argReference = param.Name;
            int indexOfSpace = argReference.IndexOf(' ');
            if (indexOfSpace > 0)
            {
                argReference = argReference.Substring(0, indexOfSpace);
            }
            argsInitializer.Initializers.Add(new CodeArgumentReferenceExpression(argReference));
        }

        CodeStatement argsStatement = new CodeVariableDeclarationStatement(typeof(object[]), "smokeArgs", argsInitializer);
        cmm.Statements.Add(argsStatement);

        // we have to call "CreateProxy()" in constructors
        if (cmm is CodeConstructor)
        {
            cmm.Statements.Add(
                new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "CreateProxy")));
        }

        // add the method call statement
        CodeStatement statement;

        if (!generateInvokeForRefParams)
        {
            if (method->ret > 0 && (method->flags & (uint) Smoke.MethodFlags.mf_ctor) == 0)
            {
                statement = new CodeMethodReturnStatement(new CodeCastExpression(returnType, invoke));
            }
            else
            {
                statement = new CodeExpressionStatement(invoke);
            }
            cmm.Statements.Add(statement);
        }
        else
        {
            if (method->ret > 0 && (method->flags & (uint) Smoke.MethodFlags.mf_ctor) == 0)
            {
                statement = new CodeVariableDeclarationStatement(returnType, "smokeRetval",
                                                                 new CodeCastExpression(returnType, invoke));
                cmm.Statements.Add(statement);
            }
            else
            {
                statement = new CodeExpressionStatement(invoke);
                cmm.Statements.Add(statement);
            }

            int i = 0;
            foreach (CodeParameterDeclarationExpression param in cmm.Parameters)
            {
                ++i;
                if (param.Direction != FieldDirection.Ref)
                {
                    continue;
                }
                cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(param.Name),
                                                           new CodeCastExpression(param.Type.BaseType,
                                                                                  new CodeArrayIndexerExpression(
                                                                                  	new CodeVariableReferenceExpression("smokeArgs"),
                                                                                  	new CodePrimitiveExpression(i*2 - 1)
                                                                                  	)
                                                           	)
                                   	));
            }

            if (method->ret > 0 && (method->flags & (uint) Smoke.MethodFlags.mf_ctor) == 0)
            {
                cmm.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("smokeRetval")));
            }
        }
        containingType.Members.Add(cmm);

        if ((method->flags & (uint) Smoke.MethodFlags.mf_dtor) != 0)
        {
            containingType.BaseTypes.Add(new CodeTypeReference(typeof(IDisposable)));
            CodeMemberMethod dispose = new CodeMemberMethod();
            dispose.Name = "Dispose";
            dispose.Attributes = MemberAttributes.Public | MemberAttributes.New | MemberAttributes.Final;
            dispose.Statements.AddRange(cmm.Statements);
            dispose.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(
                                                               	new CodeTypeReferenceExpression("GC"), "SuppressFinalize",
                                                               	new CodeThisReferenceExpression()
                                                               	)));
            containingType.Members.Add(dispose);
        }
        return cmm;
    }
Пример #28
0
 public void VisitArrayInitializer(CodeArrayCreateExpression arr)
 {
     writer.Write("new");
     writer.Write(" ");
     VisitTypeReference(arr.ElementType);
     if (arr.Initializers.Length == 0)
     {
         writer.Write("[0]");
     }
     else
     {
         writer.Write("[]");
         writer.Write(" {");
         writer.WriteLine();
         ++writer.IndentLevel;
         var sep = ",";
         foreach (var initializer in arr.Initializers)
         {
             initializer.Accept(this);
             writer.Write(sep);
             writer.WriteLine();
         }
         --writer.IndentLevel;
         writer.Write("}");
     }
 }
Пример #29
0
 private void NewArray(Instruction il)
 {
     CodeExpression count = Pop();
     var type = (TypeReference)il.Operand;
     CodeArrayCreateExpression expr = new CodeArrayCreateExpression {
         SizeExpression = count,
         Type = type
     };
     Push(expr);
 }
 private static CodeMemberMethod CreateEndOperationMethod(ServiceContractGenerationContext context, CodeTypeDeclaration clientType, string syncMethodName, CodeMemberMethod endMethod)
 {
     CodeMemberMethod method = new CodeMemberMethod();
     method.Attributes = MemberAttributes.Private;
     method.ReturnType = new CodeTypeReference(objectArrayType);
     method.Name = NamingHelper.GetUniqueName(GetEndOperationMethodName(syncMethodName), new NamingHelper.DoesNameExist(ClientClassGenerator.DoesMethodNameExist), context.Operations);
     int asyncResultParamIndex = GetAsyncResultParamIndex(endMethod);
     CodeMethodInvokeExpression expression = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), endMethod.Name, new CodeExpression[0]);
     CodeArrayCreateExpression expression2 = new CodeArrayCreateExpression();
     expression2.CreateType = new CodeTypeReference(objectArrayType);
     for (int i = 0; i < endMethod.Parameters.Count; i++)
     {
         if (i == asyncResultParamIndex)
         {
             method.Parameters.Add(new CodeParameterDeclarationExpression(endMethod.Parameters[i].Type, endMethod.Parameters[i].Name));
             expression.Parameters.Add(new CodeVariableReferenceExpression(endMethod.Parameters[i].Name));
         }
         else
         {
             CodeVariableDeclarationStatement statement = new CodeVariableDeclarationStatement(endMethod.Parameters[i].Type, endMethod.Parameters[i].Name);
             CodeMethodReferenceExpression expression3 = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), getDefaultValueForInitializationMethodName, new CodeTypeReference[] { endMethod.Parameters[i].Type });
             statement.InitExpression = new CodeMethodInvokeExpression(expression3, new CodeExpression[0]);
             method.Statements.Add(statement);
             expression.Parameters.Add(new CodeDirectionExpression(endMethod.Parameters[i].Direction, new CodeVariableReferenceExpression(statement.Name)));
             expression2.Initializers.Add(new CodeVariableReferenceExpression(statement.Name));
         }
     }
     if (endMethod.ReturnType.BaseType != voidTypeRef.BaseType)
     {
         CodeVariableDeclarationStatement statement2 = new CodeVariableDeclarationStatement();
         statement2.Type = endMethod.ReturnType;
         statement2.Name = NamingHelper.GetUniqueName("retVal", new NamingHelper.DoesNameExist(ClientClassGenerator.DoesParameterNameExist), endMethod);
         statement2.InitExpression = expression;
         expression2.Initializers.Add(new CodeVariableReferenceExpression(statement2.Name));
         method.Statements.Add(statement2);
     }
     else
     {
         method.Statements.Add(expression);
     }
     if (expression2.Initializers.Count > 0)
     {
         method.Statements.Add(new CodeMethodReturnStatement(expression2));
     }
     else
     {
         method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
     }
     clientType.Members.Add(method);
     return method;
 }
Пример #31
0
 protected override void GenerateArrayCreateExpression(CodeArrayCreateExpression e)
 {
 }
Пример #32
0
 private void ValidateArrayCreateExpression(CodeArrayCreateExpression e)
 {
     ValidateTypeReference(e.CreateType);
     CodeExpressionCollection init = e.Initializers;
     if (init.Count > 0)
     {
         ValidateExpressionList(init);
     }
     else
     {
         if (e.SizeExpression != null)
         {
             ValidateExpression(e.SizeExpression);
         }
     }
 }
 private static void AddAssignStatement(CodeMemberMethod methodToAddTo, string fieldToAssign, CodeArrayCreateExpression array)
 {
     methodToAddTo.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(SteamVR_Input)), fieldToAssign), array));
 }
        void ProcessStyleable(XmlReader reader)
        {
            string topName                 = null;
            int    fieldCount              = 0;
            List <CodeMemberField> fields  = new List <CodeMemberField> ();
            List <string>          attribs = new List <string> ();

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Whitespace || reader.NodeType == XmlNodeType.Comment)
                {
                    continue;
                }
                string name = null;
                if (string.IsNullOrEmpty(topName))
                {
                    if (reader.HasAttributes)
                    {
                        while (reader.MoveToNextAttribute())
                        {
                            if (reader.Name.Replace("android:", "") == "name")
                            {
                                topName = reader.Value;
                            }
                        }
                    }
                }
                if (!reader.IsStartElement() || reader.LocalName == "declare-styleable")
                {
                    continue;
                }
                if (reader.HasAttributes)
                {
                    while (reader.MoveToNextAttribute())
                    {
                        if (reader.Name.Replace("android:", "") == "name")
                        {
                            name = reader.Value;
                        }
                    }
                }
                reader.MoveToElement();
                if (reader.LocalName == "attr")
                {
                    attribs.Add(name);
                }
                else
                {
                    if (name != null)
                    {
                        CreateIntField(ids, $"{name}");
                    }
                }
            }
            CodeMemberField field = CreateIntArrayField(styleable, topName, attribs.Count);

            if (!arrayMapping.ContainsKey(field))
            {
                attribs.Sort(StringComparer.OrdinalIgnoreCase);
                for (int i = 0; i < attribs.Count; i++)
                {
                    string name = attribs [i];
                    if (!name.StartsWith("android:", StringComparison.OrdinalIgnoreCase))
                    {
                        fields.Add(CreateIntField(attrib, name));
                    }
                    else
                    {
                        // this is an android:xxx resource, we should not calcuate the id
                        // we should get it from "somewhere" maybe the pubic.xml
                        var f = new CodeMemberField(typeof(int), name);
                        f.InitExpression = new CodePrimitiveExpression(0);
                        fields.Add(f);
                    }
                }
                CodeArrayCreateExpression c = field.InitExpression as CodeArrayCreateExpression;
                if (c == null)
                {
                    return;
                }

                arrayMapping.Add(field, fields.ToArray());
            }
        }
Пример #35
0
			public void Visit(CodeArrayCreateExpression o)
			{
				g.GenerateArrayCreateExpression(o);
			}
Пример #36
0
        void AddAsyncMembers(string messageName, CodeMemberMethod method)
        {
            CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
            CodePrimitiveExpression     enull = new CodePrimitiveExpression(null);

            CodeMemberField codeField = new CodeMemberField(typeof(System.Threading.SendOrPostCallback), messageName + "OperationCompleted");

            codeField.Attributes = MemberAttributes.Private;
            CodeTypeDeclaration.Members.Add(codeField);

            // Event arguments class

            string argsClassName          = classNames.AddUnique(messageName + "CompletedEventArgs", null);
            CodeTypeDeclaration argsClass = new CodeTypeDeclaration(argsClassName);

            argsClass.Attributes |= MemberAttributes.Public;
#if NET_2_0
            argsClass.IsPartial = true;
#endif
            argsClass.BaseTypes.Add(new CodeTypeReference("System.ComponentModel.AsyncCompletedEventArgs"));

            CodeMemberField resultsField = new CodeMemberField(typeof(object[]), "results");
            resultsField.Attributes = MemberAttributes.Private;
            argsClass.Members.Add(resultsField);

            CodeConstructor cc = new CodeConstructor();
            cc.Attributes = MemberAttributes.Assembly;
            cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object[]), "results"));
            cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(System.Exception), "exception"));
            cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(bool), "cancelled"));
            cc.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "userState"));
            cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("exception"));
            cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("cancelled"));
            cc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("userState"));
            CodeExpression thisResults = new CodeFieldReferenceExpression(ethis, "results");
            cc.Statements.Add(new CodeAssignStatement(thisResults, new CodeVariableReferenceExpression("results")));
            argsClass.Members.Add(cc);

            int ind = 0;

            if (method.ReturnType.BaseType != "System.Void")
            {
                argsClass.Members.Add(CreateArgsProperty(method.ReturnType, "Result", ind++));
            }

            foreach (CodeParameterDeclarationExpression par in method.Parameters)
            {
                if (par.Direction == FieldDirection.Out || par.Direction == FieldDirection.Ref)
                {
                    argsClass.Members.Add(CreateArgsProperty(par.Type, par.Name, ind++));
                }
            }

            bool needsArgsClass = (ind > 0);
            if (needsArgsClass)
            {
                asyncTypes.Add(argsClass);
            }
            else
            {
                argsClassName = "System.ComponentModel.AsyncCompletedEventArgs";
            }

            // Event delegate type

            CodeTypeDelegate delegateType = new CodeTypeDelegate(messageName + "CompletedEventHandler");
            delegateType.Attributes |= MemberAttributes.Public;
            delegateType.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "sender"));
            delegateType.Parameters.Add(new CodeParameterDeclarationExpression(argsClassName, "args"));

            // Event member

            CodeMemberEvent codeEvent = new CodeMemberEvent();
            codeEvent.Attributes = codeEvent.Attributes & ~MemberAttributes.AccessMask | MemberAttributes.Public;
            codeEvent.Name       = messageName + "Completed";
            codeEvent.Type       = new CodeTypeReference(delegateType.Name);
            CodeTypeDeclaration.Members.Add(codeEvent);

            // Async method (without user state param)

            CodeMemberMethod am = new CodeMemberMethod();
            am.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            am.Name       = method.Name + "Async";
            am.ReturnType = new CodeTypeReference(typeof(void));
            CodeMethodInvokeExpression inv;
            inv = new CodeMethodInvokeExpression(ethis, am.Name);
            am.Statements.Add(inv);

            // On...Completed method

            CodeMemberMethod onCompleted = new CodeMemberMethod();
            onCompleted.Name       = "On" + messageName + "Completed";
            onCompleted.Attributes = MemberAttributes.Private | MemberAttributes.Final;
            onCompleted.ReturnType = new CodeTypeReference(typeof(void));
            onCompleted.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "arg"));

            CodeConditionStatement anIf = new CodeConditionStatement();

            CodeExpression eventField = new CodeEventReferenceExpression(ethis, codeEvent.Name);
            anIf.Condition = new CodeBinaryOperatorExpression(eventField, CodeBinaryOperatorType.IdentityInequality, enull);
            CodeExpression castedArg  = new CodeCastExpression(typeof(System.Web.Services.Protocols.InvokeCompletedEventArgs), new CodeVariableReferenceExpression("arg"));
            CodeStatement  invokeArgs = new CodeVariableDeclarationStatement(typeof(System.Web.Services.Protocols.InvokeCompletedEventArgs), "invokeArgs", castedArg);
            anIf.TrueStatements.Add(invokeArgs);

            CodeDelegateInvokeExpression delegateInvoke = new CodeDelegateInvokeExpression();
            delegateInvoke.TargetObject = eventField;
            delegateInvoke.Parameters.Add(ethis);
            CodeObjectCreateExpression argsInstance  = new CodeObjectCreateExpression(argsClassName);
            CodeExpression             invokeArgsVar = new CodeVariableReferenceExpression("invokeArgs");
            if (needsArgsClass)
            {
                argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "Results"));
            }
            argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "Error"));
            argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "Cancelled"));
            argsInstance.Parameters.Add(new CodeFieldReferenceExpression(invokeArgsVar, "UserState"));
            delegateInvoke.Parameters.Add(argsInstance);
            anIf.TrueStatements.Add(delegateInvoke);

            onCompleted.Statements.Add(anIf);

            // Async method

            CodeMemberMethod asyncMethod = new CodeMemberMethod();
            asyncMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            asyncMethod.Name       = method.Name + "Async";
            asyncMethod.ReturnType = new CodeTypeReference(typeof(void));

            CodeExpression delegateField = new CodeFieldReferenceExpression(ethis, codeField.Name);
            anIf           = new CodeConditionStatement();
            anIf.Condition = new CodeBinaryOperatorExpression(delegateField, CodeBinaryOperatorType.IdentityEquality, enull);;
            CodeExpression      delegateRef = new CodeMethodReferenceExpression(ethis, onCompleted.Name);
            CodeExpression      newDelegate = new CodeObjectCreateExpression(typeof(System.Threading.SendOrPostCallback), delegateRef);
            CodeAssignStatement cas         = new CodeAssignStatement(delegateField, newDelegate);
            anIf.TrueStatements.Add(cas);
            asyncMethod.Statements.Add(anIf);

            CodeArrayCreateExpression paramsArray = new CodeArrayCreateExpression(typeof(object));

            // Assign parameters

            CodeIdentifiers paramsIds = new CodeIdentifiers();

            foreach (CodeParameterDeclarationExpression par in method.Parameters)
            {
                paramsIds.Add(par.Name, null);
                if (par.Direction == FieldDirection.In || par.Direction == FieldDirection.Ref)
                {
                    CodeParameterDeclarationExpression inpar = new CodeParameterDeclarationExpression(par.Type, par.Name);
                    am.Parameters.Add(inpar);
                    asyncMethod.Parameters.Add(inpar);
                    inv.Parameters.Add(new CodeVariableReferenceExpression(par.Name));
                    paramsArray.Initializers.Add(new CodeVariableReferenceExpression(par.Name));
                }
            }


            inv.Parameters.Add(enull);

            string userStateName = paramsIds.AddUnique("userState", null);
            asyncMethod.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), userStateName));

            CodeExpression userStateVar = new CodeVariableReferenceExpression(userStateName);
            asyncMethod.Statements.Add(BuildInvokeAsync(messageName, paramsArray, delegateField, userStateVar));

            CodeTypeDeclaration.Members.Add(am);
            CodeTypeDeclaration.Members.Add(asyncMethod);
            CodeTypeDeclaration.Members.Add(onCompleted);

            asyncTypes.Add(delegateType);
        }
	protected override void GenerateArrayCreateExpression
				(CodeArrayCreateExpression e)
			{
				Output.Write("new ");
				if(e.Initializers.Count == 0)
				{
					Output.Write(NormalizeTypeName(e.CreateType.BaseType));
					Output.Write("[");
					if(e.SizeExpression != null)
					{
						GenerateExpression(e.SizeExpression);
					}
					else
					{
						Output.Write(e.Size);
					}
					Output.Write("]");
				}
				else
				{
					OutputType(e.CreateType);
					if(e.CreateType.ArrayRank == 0)
					{
						Output.Write("[]");
					}
					Output.WriteLine(" {");
					Indent += 1;
					OutputExpressionList(e.Initializers, true);
					Indent -= 1;
					Output.Write("}");
				}
			}
        private static void GenerateActionHelpers(string actionsClassFileName)
        {
            CodeCompileUnit compileUnit = new CodeCompileUnit();

            CodeTypeDeclaration inputClass = CreatePartialInputClass(compileUnit);

            CodeArrayCreateExpression actionsArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action)));

            CodeArrayCreateExpression actionsInArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(ISteamVR_Action_In)));

            CodeArrayCreateExpression actionsOutArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(ISteamVR_Action_Out)));

            CodeArrayCreateExpression actionsVibrationArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Vibration)));

            CodeArrayCreateExpression actionsPoseArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Pose)));

            CodeArrayCreateExpression actionsSkeletonArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Skeleton)));

            CodeArrayCreateExpression actionsBooleanArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Boolean)));

            CodeArrayCreateExpression actionsSingleArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Single)));

            CodeArrayCreateExpression actionsVector2Array = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Vector2)));

            CodeArrayCreateExpression actionsVector3Array = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Vector3)));

            CodeArrayCreateExpression actionsNonPoseNonSkeletonArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(ISteamVR_Action_In)));


            //add the getaction method to
            CodeMemberMethod actionsArraysInitMethod = CreateStaticMethod(inputClass, initializeActionsArraysMethodName, false);
            CodeMemberMethod actionsPreInitMethod    = CreateStaticMethod(inputClass, preInitActionsMethodName, false);



            for (int actionSetIndex = 0; actionSetIndex < SteamVR_Input.actionFile.action_sets.Count; actionSetIndex++)
            {
                SteamVR_Input_ActionFile_ActionSet actionSet = SteamVR_Input.actionFile.action_sets[actionSetIndex];
                string actionSetShortName = actionSet.shortName;
                actionSetShortName = actionSetShortName.Substring(0, 1).ToLower() + actionSetShortName.Substring(1);

                for (int actionIndex = 0; actionIndex < actionSet.actionsList.Count; actionIndex++)
                {
                    SteamVR_Input_ActionFile_Action action = actionSet.actionsList[actionIndex];
                    string actionShortName = action.shortName;

                    string typeName = GetTypeStringForAction(action);

                    string codeFriendlyInstanceName;
                    if (actionSet.actionsList.Count(findAction => findAction.shortName == actionShortName) >= 2)
                    {
                        codeFriendlyInstanceName = string.Format("{0}_{1}_{2}", actionSetShortName, action.direction.ToString().ToLower(), actionShortName);
                    }
                    else
                    {
                        codeFriendlyInstanceName = string.Format("{0}_{1}", actionSetShortName, actionShortName);
                    }


                    CodeMemberField actionField = CreateFieldAndPropertyWrapper(inputClass, codeFriendlyInstanceName, typeName);

                    AddAssignActionStatement(actionsPreInitMethod, inputClass.Name, actionField.Name, action.name, typeName);

                    actionsArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));

                    if (action.direction == SteamVR_ActionDirections.In)
                    {
                        actionsInArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));

                        if (typeName == typeof(SteamVR_Action_Pose).Name)
                        {
                            actionsPoseArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
                        }
                        else if (typeName == typeof(SteamVR_Action_Skeleton).Name)
                        {
                            actionsSkeletonArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
                        }
                        else if (typeName == typeof(SteamVR_Action_Boolean).Name)
                        {
                            actionsBooleanArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
                        }
                        else if (typeName == typeof(SteamVR_Action_Single).Name)
                        {
                            actionsSingleArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
                        }
                        else if (typeName == typeof(SteamVR_Action_Vector2).Name)
                        {
                            actionsVector2Array.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
                        }
                        else if (typeName == typeof(SteamVR_Action_Vector3).Name)
                        {
                            actionsVector3Array.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
                        }

                        if ((typeName == typeof(SteamVR_Action_Skeleton).Name) == false && (typeName == typeof(SteamVR_Action_Pose).Name) == false)
                        {
                            actionsNonPoseNonSkeletonArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
                        }
                    }
                    else
                    {
                        actionsVibrationArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));

                        actionsOutArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
                    }
                }
            }

            AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsFieldName, actionsArray);
            AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsInFieldName, actionsInArray);
            AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsOutFieldName, actionsOutArray);
            AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsVibrationFieldName, actionsVibrationArray);
            AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsPoseFieldName, actionsPoseArray);
            AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsBooleanFieldName, actionsBooleanArray);
            AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsSingleFieldName, actionsSingleArray);
            AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsVector2FieldName, actionsVector2Array);
            AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsVector3FieldName, actionsVector3Array);
            AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsSkeletonFieldName, actionsSkeletonArray);
            AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsNonPoseNonSkeletonIn, actionsNonPoseNonSkeletonArray);


            // Build the output file name.
            string fullSourceFilePath = GetSourceFilePath(actionsClassFileName);

            CreateFile(fullSourceFilePath, compileUnit);
        }
Пример #39
0
 protected abstract void GenerateArrayCreateExpression(CodeArrayCreateExpression e);
Пример #40
0
        CodeMemberMethod GenerateMethod(CodeIdentifiers memberIds, SoapOperationBinding soapOper, SoapBodyBinding bodyBinding, XmlMembersMapping inputMembers, XmlMembersMapping outputMembers)
        {
            CodeIdentifiers  pids        = new CodeIdentifiers();
            CodeMemberMethod method      = new CodeMemberMethod();
            CodeMemberMethod methodBegin = new CodeMemberMethod();
            CodeMemberMethod methodEnd   = new CodeMemberMethod();

            method.Attributes      = MemberAttributes.Public | MemberAttributes.Final;
            methodBegin.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            methodEnd.Attributes   = MemberAttributes.Public | MemberAttributes.Final;

            SoapBindingStyle style = soapOper.Style != SoapBindingStyle.Default ? soapOper.Style : soapBinding.Style;

            // Find unique names for temporary variables

            for (int n = 0; n < inputMembers.Count; n++)
            {
                pids.AddUnique(inputMembers[n].MemberName, inputMembers[n]);
            }

            if (outputMembers != null)
            {
                for (int n = 0; n < outputMembers.Count; n++)
                {
                    pids.AddUnique(outputMembers[n].MemberName, outputMembers[n]);
                }
            }

            string varAsyncResult = pids.AddUnique("asyncResult", "asyncResult");
            string varResults     = pids.AddUnique("results", "results");
            string varCallback    = pids.AddUnique("callback", "callback");
            string varAsyncState  = pids.AddUnique("asyncState", "asyncState");

            string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name), method);

            method.Name = CodeIdentifier.MakeValid(Operation.Name);
            if (method.Name == ClassName)
            {
                method.Name += "1";
            }
            methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + method.Name), method);
            methodEnd.Name   = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + method.Name), method);

            method.ReturnType    = new CodeTypeReference(typeof(void));
            methodEnd.ReturnType = new CodeTypeReference(typeof(void));
            methodEnd.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IAsyncResult), varAsyncResult));

            CodeExpression[] paramArray = new CodeExpression [inputMembers.Count];
            CodeParameterDeclarationExpression[] outParams = new CodeParameterDeclarationExpression [outputMembers != null ? outputMembers.Count : 0];

            for (int n = 0; n < inputMembers.Count; n++)
            {
                CodeParameterDeclarationExpression param = GenerateParameter(inputMembers[n], FieldDirection.In);
                method.Parameters.Add(param);
                GenerateMemberAttributes(inputMembers, inputMembers[n], bodyBinding.Use, param);
                methodBegin.Parameters.Add(GenerateParameter(inputMembers[n], FieldDirection.In));
                paramArray [n] = new CodeVariableReferenceExpression(param.Name);
            }

            if (outputMembers != null)
            {
                bool hasReturn = false;
                for (int n = 0; n < outputMembers.Count; n++)
                {
                    CodeParameterDeclarationExpression cpd = GenerateParameter(outputMembers[n], FieldDirection.Out);
                    outParams [n] = cpd;

                    bool found = false;
                    foreach (CodeParameterDeclarationExpression ip in method.Parameters)
                    {
                        if (ip.Name == cpd.Name && ip.Type.BaseType == cpd.Type.BaseType)
                        {
                            ip.Direction = FieldDirection.Ref;
                            methodEnd.Parameters.Add(GenerateParameter(outputMembers[n], FieldDirection.Out));
                            found = true;
                            break;
                        }
                    }

                    if (found)
                    {
                        continue;
                    }

                    if (!hasReturn)
                    {
                        hasReturn            = true;
                        method.ReturnType    = cpd.Type;
                        methodEnd.ReturnType = cpd.Type;
                        GenerateReturnAttributes(outputMembers, outputMembers[n], bodyBinding.Use, method);
                        outParams [n] = null;
                        continue;
                    }

                    method.Parameters.Add(cpd);
                    GenerateMemberAttributes(outputMembers, outputMembers[n], bodyBinding.Use, cpd);
                    methodEnd.Parameters.Add(GenerateParameter(outputMembers[n], FieldDirection.Out));
                }
            }

            methodBegin.Parameters.Add(new CodeParameterDeclarationExpression(typeof(AsyncCallback), varCallback));
            methodBegin.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), varAsyncState));
            methodBegin.ReturnType = new CodeTypeReference(typeof(IAsyncResult));

            // Array of input parameters

            CodeArrayCreateExpression methodParams;

            if (paramArray.Length > 0)
            {
                methodParams = new CodeArrayCreateExpression(typeof(object), paramArray);
            }
            else
            {
                methodParams = new CodeArrayCreateExpression(typeof(object), 0);
            }

            // Assignment of output parameters

            CodeStatementCollection         outAssign = new CodeStatementCollection();
            CodeVariableReferenceExpression arrVar    = new CodeVariableReferenceExpression(varResults);

            for (int n = 0; n < outParams.Length; n++)
            {
                CodeExpression index = new CodePrimitiveExpression(n);
                if (outParams[n] == null)
                {
                    CodeExpression res = new CodeCastExpression(method.ReturnType, new CodeArrayIndexerExpression(arrVar, index));
                    outAssign.Add(new CodeMethodReturnStatement(res));
                }
                else
                {
                    CodeExpression res = new CodeCastExpression(outParams[n].Type, new CodeArrayIndexerExpression(arrVar, index));
                    CodeExpression var = new CodeVariableReferenceExpression(outParams[n].Name);
                    outAssign.Insert(0, new CodeAssignStatement(var, res));
                }
            }

            if (Style == ServiceDescriptionImportStyle.Client)
            {
                // Invoke call

                CodeThisReferenceExpression      ethis      = new CodeThisReferenceExpression();
                CodePrimitiveExpression          varMsgName = new CodePrimitiveExpression(messageName);
                CodeMethodInvokeExpression       inv;
                CodeVariableDeclarationStatement dec;

                inv = new CodeMethodInvokeExpression(ethis, "Invoke", varMsgName, methodParams);
                if (outputMembers != null && outputMembers.Count > 0)
                {
                    dec = new CodeVariableDeclarationStatement(typeof(object[]), varResults, inv);
                    method.Statements.Add(dec);
                    method.Statements.AddRange(outAssign);
                }
                else
                {
                    method.Statements.Add(inv);
                }

                // Begin Invoke Call

                CodeExpression expCallb  = new CodeVariableReferenceExpression(varCallback);
                CodeExpression expAsyncs = new CodeVariableReferenceExpression(varAsyncState);
                inv = new CodeMethodInvokeExpression(ethis, "BeginInvoke", varMsgName, methodParams, expCallb, expAsyncs);
                methodBegin.Statements.Add(new CodeMethodReturnStatement(inv));

                // End Invoke call

                CodeExpression varAsyncr = new CodeVariableReferenceExpression(varAsyncResult);
                inv = new CodeMethodInvokeExpression(ethis, "EndInvoke", varAsyncr);
                if (outputMembers != null && outputMembers.Count > 0)
                {
                    dec = new CodeVariableDeclarationStatement(typeof(object[]), varResults, inv);
                    methodEnd.Statements.Add(dec);
                    methodEnd.Statements.AddRange(outAssign);
                }
                else
                {
                    methodEnd.Statements.Add(inv);
                }
            }
            else
            {
                method.Attributes = MemberAttributes.Public | MemberAttributes.Abstract;
            }

            // Attributes

            ImportHeaders(method);

            CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Web.Services.WebMethodAttribute");

            if (messageName != method.Name)
            {
                att.Arguments.Add(GetArg("MessageName", messageName));
            }
            AddCustomAttribute(method, att, (Style == ServiceDescriptionImportStyle.Server));

            if (style == SoapBindingStyle.Rpc)
            {
                att = new CodeAttributeDeclaration("System.Web.Services.Protocols.SoapRpcMethodAttribute");
                att.Arguments.Add(GetArg(soapOper.SoapAction));
                if (inputMembers.ElementName != method.Name)
                {
                    att.Arguments.Add(GetArg("RequestElementName", inputMembers.ElementName));
                }
                if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response"))
                {
                    att.Arguments.Add(GetArg("ResponseElementName", outputMembers.ElementName));
                }
                att.Arguments.Add(GetArg("RequestNamespace", inputMembers.Namespace));
                if (outputMembers != null)
                {
                    att.Arguments.Add(GetArg("ResponseNamespace", outputMembers.Namespace));
                }
                if (outputMembers == null)
                {
                    att.Arguments.Add(GetArg("OneWay", true));
                }
            }
            else
            {
                if (outputMembers != null && (inputMembers.ElementName == "" && outputMembers.ElementName != "" ||
                                              inputMembers.ElementName != "" && outputMembers.ElementName == ""))
                {
                    throw new InvalidOperationException("Parameter style is not the same for the input message and output message");
                }

                att = new CodeAttributeDeclaration("System.Web.Services.Protocols.SoapDocumentMethodAttribute");
                att.Arguments.Add(GetArg(soapOper.SoapAction));
                if (inputMembers.ElementName != "")
                {
                    if (inputMembers.ElementName != method.Name)
                    {
                        att.Arguments.Add(GetArg("RequestElementName", inputMembers.ElementName));
                    }
                    if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response"))
                    {
                        att.Arguments.Add(GetArg("ResponseElementName", outputMembers.ElementName));
                    }
                    att.Arguments.Add(GetArg("RequestNamespace", inputMembers.Namespace));
                    if (outputMembers != null)
                    {
                        att.Arguments.Add(GetArg("ResponseNamespace", outputMembers.Namespace));
                    }
                    att.Arguments.Add(GetEnumArg("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Wrapped"));
                }
                else
                {
                    att.Arguments.Add(GetEnumArg("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Bare"));
                }

                if (outputMembers == null)
                {
                    att.Arguments.Add(GetArg("OneWay", true));
                }

                att.Arguments.Add(GetEnumArg("Use", "System.Web.Services.Description.SoapBindingUse", bodyBinding.Use.ToString()));
            }

            AddCustomAttribute(method, att, true);

            CodeTypeDeclaration.Members.Add(method);

            if (Style == ServiceDescriptionImportStyle.Client)
            {
                CodeTypeDeclaration.Members.Add(methodBegin);
                CodeTypeDeclaration.Members.Add(methodEnd);
            }

            return(method);
        }
Пример #41
0
        private void GenerateArrayCreateExpression(CodeArrayCreateExpression e)
        {
            CodeExpressionCollection init = e.Initializers;
            if (init.Count > 0)
            {
                Output.Write("new <");
                OutputType(e.CreateType);
                Output.Write(">");
                if (e.CreateType.ArrayRank == 0)
                {
                    // Unfortunately, many clients are already calling this without array
                    // types. This will allow new clients to correctly use the array type and
                    // not break existing clients. For VNext, stop doing this.
                    Output.Write("[]");
                }
                Output.WriteLine(" [");
                Indent++;
                OutputExpressionList(init, true /*newlineBetweenItems*/);
                Indent--;
                Output.Write("]");
            }
            else
            {
                Output.Write(GetBaseTypeOutput(e.CreateType));

                Output.Write("[");
                if (e.SizeExpression != null)
                {
                    GenerateExpression(e.SizeExpression);
                }
                else
                {
                    Output.Write(e.Size);
                }
                Output.Write("]");
            }
        }