Exemple #1
0
        void ProcessInterfaces(YNamespace @namespace, NamespaceDeclarationSyntax inputNamespace)
        {
            // Interfaces:

            foreach (var inputInterace in inputNamespace.ChildNodes().OfType <InterfaceDeclarationSyntax>())
            {
                var interfaceName = inputInterace.GetName();
                if (interfaceName == "")
                {
                    continue;
                }

                var @interface = new YClass(interfaceName);
                @namespace.AddChild(@interface);

                _generationUnits.Add(new GenerationUnit(@interface));

                // Methods:

                foreach (var inputMethod in inputInterace.ChildNodes().OfType <MethodDeclarationSyntax>())
                {
                    var     name             = inputMethod.Identifier.ToString();
                    var     methodReturnType = inputMethod.ReturnType;
                    var     parameterList    = inputMethod.ParameterList;
                    YMethod method;

                    // Signature:

                    if (parameterList.Parameters.Count() <= 0)
                    {
                        method = new YMethod(name, inputMethod.ReturnType.GetYType());
                    }
                    else
                    {
                        var @params = new List <YParameter>();

                        foreach (var p in parameterList.Parameters)
                        {
                            @params.Add(new YParameter(p.GetName(), p.Type.GetYType()));
                        }

                        method = new YMethod(name, inputMethod.ReturnType.GetYType(), @params.ToArray());
                    }

                    // Body:

                    // all methods of an interface are public and pure by default
                    method.IsPure     = true;
                    method.Visibility = YVisibility.Public;
                    @interface.AddChild(method);
                }

                // Misc:

                var destructor = new YDestructor();

                destructor.IsVirtual  = true;
                destructor.Visibility = YVisibility.Public;
                destructor.Body       = new YBlock();

                @interface.AddChild(destructor);
            }
        }
Exemple #2
0
        void ProcessClasses(YNamespace @namespace, NamespaceDeclarationSyntax inputNamespace)
        {
            // Classes:

            foreach (var inputClass in inputNamespace.ChildNodes().OfType <ClassDeclarationSyntax>())
            {
                var className = inputClass.GetName();
                if (className == "")
                {
                    continue;
                }

                var @class = new YClass(className);
                @namespace.AddChild(@class);

                _generationUnits.Add(new GenerationUnit(@class));

                // Fields:

                foreach (var inputField in inputClass.ChildNodes().OfType <FieldDeclarationSyntax>())
                {
                    var declaration     = inputField.Declaration;
                    var declarationType = declaration.Type;
                    var variables       = declaration.Variables;

                    if (variables.Count == 1)
                    {
                        var variable = variables[0];

                        var field = new YField()
                        {
                            Type = declarationType.GetYType(),
                            Name = variable.GetName()
                        };

                        field.Visibility = inputField.Modifiers.GetYVisibility();

                        // expresions: literal

                        // todo process negative numbers

                        if (variable.Initializer?.Value is LiteralExpressionSyntax)
                        {
                            var literalExperssion = (LiteralExpressionSyntax)variable.Initializer.Value;

                            if (literalExperssion.Token.Value is int)
                            {
                                field.Value = new YConstExpr((int)literalExperssion.Token.Value);
                            }
                        }

                        @class.AddChild(field);
                    }
                    else
                    {
                        throw new TException("Unsupported");
                    }
                }

                // Methods:

                foreach (var inputMethod in inputClass.ChildNodes().OfType <MethodDeclarationSyntax>())
                {
                    var     name             = inputMethod.Identifier.ToString();
                    var     methodReturnType = inputMethod.ReturnType;
                    var     parameterList    = inputMethod.ParameterList;
                    YMethod method;

                    // Signature:

                    if (parameterList.Parameters.Count() <= 0)
                    {
                        method = new YMethod(name, inputMethod.ReturnType.GetYType());
                    }
                    else
                    {
                        var @params = new List <YParameter>();

                        foreach (var p in parameterList.Parameters)
                        {
                            @params.Add(new YParameter(p.GetName(), p.Type.GetYType()));
                        }

                        method = new YMethod(name, inputMethod.ReturnType.GetYType(), @params.ToArray());
                    }

                    // Body:

                    method.Visibility = inputMethod.Modifiers.GetYVisibility();
                    method.Body       = ProcessStatement(inputMethod.Body);
                    @class.AddChild(method);
                }
            }
        }