Example #1
0
        MemberDeclarationSyntax GenFunction(@request r)
        {
            // TODO: we should be able to share a lot of this with InterfaceGenerator
            if (r.name == null)
            {
                throw new Exception("Can't have null name");            // FIXME: handle this
            }

            //TODO: share code with struct
            List <ParameterSyntax> methodParameters = new List <ParameterSyntax>();
            List <StatementSyntax> methodBody       = new List <StatementSyntax>();

            //cw.WriteLine(GeneratorUtil.ToCs(r.name) + "Request req = new " + GeneratorUtil.ToCs(r.name) + "Request ();");

            var requestType = IdentifierName(GeneratorUtil.ToCs(r.name) + "Request");

            methodBody.Add(
                LocalDeclarationStatement(
                    VariableDeclaration(
                        requestType,
                        SingletonSeparatedList(
                            VariableDeclarator(Identifier("req"),
                                               null,
                                               EqualsValueClause(
                                                   ObjectCreationExpression(
                                                       requestType).
                                                   WithArgumentList(ArgumentList())))))));


            var messageDataAccess =
                MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                       IdentifierName("req"),
                                       IdentifierName("MessageData"));

            if (isExtension)
            {
                var extHeaderAccess = MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                             messageDataAccess,
                                                             IdentifierName("ExtHeader"));

                methodBody.Add(ExpressionStatement(
                                   AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
                                                        MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                               extHeaderAccess,
                                                                               IdentifierName("MajorOpcode")),
                                                        IdentifierName("GlobalId"))));

                methodBody.Add(ExpressionStatement(
                                   AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
                                                        MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                               extHeaderAccess,
                                                                               IdentifierName("MajorOpcode")),
                                                        LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(int.Parse(r.opcode))))));
            }
            else
            {
                var headerAccess = MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                          messageDataAccess,
                                                          IdentifierName("Header"));

                methodBody.Add(ExpressionStatement(
                                   AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
                                                        MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                               headerAccess,
                                                                               IdentifierName("Opcode")),
                                                        LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(int.Parse(r.opcode))))));
            }

            if (r.Items != null)
            {
                foreach (object ob in r.Items)
                {
                    if (ob is field)
                    {
                        field f = ob as field;

                        if (f.name == null)
                        {
                            continue;
                        }

                        string paramName = "@" + GeneratorUtil.ToParm(GeneratorUtil.ToCs(f.name));

                        methodParameters.Add(Parameter(Identifier(paramName)).
                                             WithType(IdentifierName(typeMap.TypeToCs(f.type))));

                        methodBody.Add(ExpressionStatement(
                                           AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
                                                                MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                                       messageDataAccess,
                                                                                       IdentifierName("@" +
                                                                                                      GeneratorUtil.ToCs(f.name))),
                                                                IdentifierName(paramName))));
                    }
                    else if (ob is list)
                    {
                        list l = ob as list;

                        if (l.name == null)
                        {
                            continue;
                        }

                        string paramName = "@" + GeneratorUtil.ToParm(GeneratorUtil.ToCs(l.name));

                        TypeSyntax paramType;

                        if (l.type == "char")
                        {
                            paramType = PredefinedType(Token(SyntaxKind.StringKeyword));
                        }
                        else if (l.type == "CARD32")
                        {
                            paramType = ArrayType(PredefinedType(Token(SyntaxKind.UIntKeyword))).
                                        WithRankSpecifiers(SingletonList(
                                                               ArrayRankSpecifier(
                                                                   SingletonSeparatedList <ExpressionSyntax>(
                                                                       OmittedArraySizeExpression()))));
                        }
                        else
                        {
                            // FIXME: handle these
                            continue;
                        }

                        methodParameters.Add(Parameter(Identifier(paramName)).
                                             WithType(paramType));

                        methodBody.Add(ExpressionStatement(
                                           AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
                                                                MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                                       IdentifierName("req"),
                                                                                       IdentifierName("@" +
                                                                                                      GeneratorUtil.ToCs(l.name))),
                                                                IdentifierName(paramName))));
                    }
                    else if (ob is valueparam)
                    {
                        valueparam v     = ob as valueparam;
                        string     vName = (v.valuelistname == null) ? "Values" : GeneratorUtil.ToCs(v.valuelistname);
                        string     vType = typeMap.TypeToCs(v.valuemasktype);

                        string paramName = "@" + GeneratorUtil.ToParm(vName);

                        if (vType == "uint")
                        {
                            methodParameters.Add(Parameter(Identifier(paramName)).
                                                 WithType(ArrayType(PredefinedType(Token(SyntaxKind.UIntKeyword))).
                                                          WithRankSpecifiers(SingletonList(
                                                                                 ArrayRankSpecifier(
                                                                                     SingletonSeparatedList <ExpressionSyntax>(
                                                                                         OmittedArraySizeExpression()))))));

                            methodBody.Add(ExpressionStatement(
                                               AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
                                                                    MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                                           IdentifierName("req"),
                                                                                           IdentifierName("@" + vName)),
                                                                    IdentifierName(paramName))));
                        }
                    }
                }
            }

            //cw.WriteLine("c.xw.Send (req);");

            methodBody.Add(ExpressionStatement(
                               InvocationExpression(
                                   MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                          MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                                                 IdentifierName("c"),
                                                                                 IdentifierName("xw")),
                                                          IdentifierName("Send"))).
                               WithArgumentList(ArgumentList(
                                                    SingletonSeparatedList(Argument(IdentifierName("req")))))));

            if (r.reply != null)
            {
                //cw.WriteLine("return c.xrr.GenerateCookie<" + GeneratorUtil.ToCs(r.name) + "Reply> ();");

                var xrrAccess =
                    MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                           IdentifierName("c"),
                                           IdentifierName("xrr"));

                methodBody.Add(
                    ReturnStatement(
                        InvocationExpression(
                            MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                                                   xrrAccess,
                                                   GenericName("GenerateCookie").
                                                   WithTypeArgumentList(
                                                       TypeArgumentList(
                                                           SingletonSeparatedList <TypeSyntax>(
                                                               IdentifierName(
                                                                   GeneratorUtil.ToCs(r.name) + "Reply"))))))));
            }


            if (r.reply != null)
            {
                //cw.WriteLine("public Cookie<" + GeneratorUtil.ToCs(r.name) + "Reply> " + GeneratorUtil.ToCs(r.name) +
                //             " (" + parms + ");");

                return(MethodDeclaration(
                           GenericName("Cookie").
                           WithTypeArgumentList(
                               TypeArgumentList(
                                   SingletonSeparatedList <TypeSyntax>(
                                       IdentifierName(GeneratorUtil.ToCs(r.name) + "Reply")))),
                           GeneratorUtil.ToCs(r.name)).
                       WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword))).
                       WithParameterList(ParameterList(SeparatedList(methodParameters))).
                       WithBody(Block(methodBody)));
            }
            else
            {
                //cw.WriteLine("public void " + GeneratorUtil.ToCs(r.name) + " (" + parms + ");");

                return(MethodDeclaration(
                           PredefinedType(Token(SyntaxKind.VoidKeyword)),
                           GeneratorUtil.ToCs(r.name)).
                       WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword))).
                       WithParameterList(ParameterList(SeparatedList(methodParameters))).
                       WithBody(Block(methodBody)));
            }
        }
Example #2
0
        private MethodDeclarationSyntax GenFunction(@request r, string name)
        {
            if (r.name == null)
            {
                return(null);
            }

            //TODO: share code with struct
            List <ParameterSyntax> parameters = new List <ParameterSyntax>();

            if (r.Items != null)
            {
                foreach (object ob in r.Items)
                {
                    if (ob is field)
                    {
                        field f = ob as field;
                        if (f.name == null)
                        {
                            continue;
                        }

                        parameters.Add(Parameter(Identifier("@" + f.name)).WithType(IdentifierName(f.type)));
                    }
                    else if (ob is list)
                    {
                        list l = ob as list;

                        if (l.name == null)
                        {
                            continue;
                        }

                        string listName = "@" + GeneratorUtil.ToParm(GeneratorUtil.ToCs(l.name));

                        if (l.type == "char")
                        {
                            parameters.Add(Parameter(Identifier(listName)).
                                           WithType(PredefinedType(Token(SyntaxKind.StringKeyword))));
                        }
                        else if (l.type == "CARD32")
                        {
                            parameters.Add(Parameter(Identifier(listName)).
                                           WithType(ArrayType(PredefinedType(Token(SyntaxKind.UIntKeyword))).
                                                    WithRankSpecifiers(SingletonList(
                                                                           ArrayRankSpecifier(
                                                                               SingletonSeparatedList <ExpressionSyntax>(
                                                                                   OmittedArraySizeExpression()))))));
                        }
                    }
                    else if (ob is valueparam)
                    {
                        valueparam v = ob as valueparam;

                        string vName = (v.valuelistname == null)
                                                        ? "Values"
                                                        : "@" + GeneratorUtil.ToParm(GeneratorUtil.ToCs(v.valuelistname));
                        string vType = typeMap.TypeToCs(v.valuemasktype);

                        if (vType == "uint")
                        {
                            parameters.Add(Parameter(Identifier(vName)).
                                           WithType(ArrayType(PredefinedType(Token(SyntaxKind.UIntKeyword))).
                                                    WithRankSpecifiers(SingletonList(
                                                                           ArrayRankSpecifier(
                                                                               SingletonSeparatedList <ExpressionSyntax>(
                                                                                   OmittedArraySizeExpression()))))));
                        }
                    }
                }
            }

            if (r.reply != null)
            {
                TypeSyntax returnType = GenericName(Identifier("Cookie"),
                                                    TypeArgumentList(SingletonSeparatedList <TypeSyntax>(
                                                                         IdentifierName(GeneratorUtil.ToCs(r.name)))));

                return(MethodDeclaration(returnType, Identifier(GeneratorUtil.ToCs(r.name))).
                       WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword))).
                       WithParameterList(ParameterList(SeparatedList(parameters))).
                       WithSemicolonToken(Token(SyntaxKind.SemicolonToken)));
            }
            else
            {
                return(MethodDeclaration(PredefinedType(Token(SyntaxKind.VoidKeyword)),
                                         Identifier(GeneratorUtil.ToCs(r.name))).
                       WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword))).
                       WithParameterList(ParameterList(SeparatedList(parameters))).
                       WithSemicolonToken(Token(SyntaxKind.SemicolonToken)));
            }
        }