Example #1
0
        // Builds a codedom delegate expression and attaches it to the given codedom namespace.
        public static void Emit(CodeNamespace codeNamespace, DelegateDeclaration del)
        {
            // Create the codedom delegate and attach it to the namespace.
            var codeDelegate = new CodeTypeDelegate();
            codeNamespace.Types.Add(codeDelegate);

            // Assign the name of the delegate
            codeDelegate.Name = del.Name;

            // Set the type of the delegate: make sure to check for null
            if (del.ReturnTypeName == "void")
                codeDelegate.ReturnType = null;
            else
                codeDelegate.ReturnType = new CodeTypeReference(del.ReturnTypeName);

            // Translate the accessibililty of the delegate
            MemberAttributes attributes = MemberAttributes.Public;
            switch(del.Accessibility)
            {
                case Accessibility.Public:
                    attributes = MemberAttributes.Public;
                    break;
                case Accessibility.Protected:
                    attributes = MemberAttributes.Family;
                    break;
                case Accessibility.Private:
                    attributes = MemberAttributes.Private;
                    break;
                case Accessibility.Internal:
                    attributes = MemberAttributes.FamilyAndAssembly;
                    break;
            }

            // Shared = static
            if (del.IsShared)
                attributes |= MemberAttributes.Static;

            codeDelegate.Attributes = attributes;

            // Translate the parameters of the delegate.
            foreach (Expression p in del.Parameters)
            {
                if (p is SimpleParameter) // ex "int i"
                    codeDelegate.Parameters.Add(new CodeParameterDeclarationExpression((p as SimpleParameter).TypeName, (p as SimpleParameter).Name));
                if (p is DirectionedParameter) // ex "ref int t"
                {
                    var codeParameter = new CodeParameterDeclarationExpression((p as DirectionedParameter).TypeName, (p as DirectionedParameter).Name);
                    switch ((p as DirectionedParameter).Direction)
                    {
                        case ParameterDirection.Out:
                            codeParameter.Direction = FieldDirection.Out;
                            break;
                        case ParameterDirection.Ref:
                            codeParameter.Direction = FieldDirection.Ref;
                            break;
                    }
                    codeDelegate.Parameters.Add(codeParameter);
                }
            }
        }
Example #2
0
        // Build the arguments of the delegate declaration.
        public static void BuildArgument(IronyParser parser, DelegateDeclaration method, ParseTreeNode node)
        {
            if (node.Term.ToString() == "out_parameter")
            {
                var a = new DirectionedParameter(null, node.FindToken().Convert());
                switch (node.ChildNodes[0].ChildNodes[0].Term.ToString())
                {
                    case "ref":
                        a.Direction = ParameterDirection.Ref;
                        break;
                    case "out":
                        a.Direction = ParameterDirection.Out;
                        break;

                }
                a.TypeName = parser.CheckAlias(node.ChildNodes[1].FindTokenAndGetText());
                a.Name = node.ChildNodes[2].FindTokenAndGetText();
                method.Parameters.Add(a);
            }
            else if (node.Term.ToString() == "array_parameter")
            {
                var a = new SimpleParameter(null, node.FindToken().Convert());
                a.TypeName = parser.CheckAlias(node.ChildNodes[0].FindTokenAndGetText()) + "[]";
                a.Name = node.ChildNodes[3].FindTokenAndGetText();
                method.Parameters.Add(a);
            }
            else if(node.Term.ToString() == "generic_parameter")
            {
                var a = new SimpleParameter(null, node.FindToken().Convert());
                string typeName = node.ChildNodes[0].ChildNodes[0].FindTokenAndGetText() + "<";
                for (int i = 0; i < node.ChildNodes[0].ChildNodes[2].ChildNodes.Count; i++ )
                {

                    typeName += parser.CheckAlias(node.ChildNodes[0].ChildNodes[2].ChildNodes[i].FindTokenAndGetText());
                    if (i < node.ChildNodes[0].ChildNodes[2].ChildNodes.Count - 1)
                        typeName += ",";
                }
                typeName += ">";
                a.TypeName = typeName;
                a.Name = node.ChildNodes[1].FindTokenAndGetText();
                method.Parameters.Add(a);
            }
            else
            {
                var a = new SimpleParameter(null, node.FindToken().Convert());
                a.TypeName = parser.CheckAlias(node.ChildNodes[0].FindTokenAndGetText());
                a.Name = node.ChildNodes[1].FindTokenAndGetText();
                method.Parameters.Add(a);
            }
        }
Example #3
0
        // Build a delegate declaration expression.
        public static void BuildDelegate(IronyParser parser, Root root, Expression parentExpression, ParseTreeNode currentNode)
        {
            var d = new DelegateDeclaration(parentExpression, currentNode.Token.Convert());
            parentExpression.ChildExpressions.Add(d);

            // Interpret the declaration modifiers.
            InterpretModifiers(root, d, currentNode.ChildNodes[0]);

            // Find the return type of the declaration: check for array and generic types differently.
            if (currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].Term.ToString() == "array")
            {
                d.ReturnTypeName = parser.CheckAlias(currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].FindTokenAndGetText()) + "[]";
            }
            else if (currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].Term.ToString() == "generic_identifier")
            {

                string returnType = currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].ChildNodes[0].FindTokenAndGetText() + "<";
                for(int i = 0; i < currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].ChildNodes[2].ChildNodes.Count; i++)
                {
                    var genericNode = currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].ChildNodes[2].ChildNodes[i];
                    returnType += parser.CheckAlias(genericNode.FindTokenAndGetText());
                    if (i < currentNode.ChildNodes[2].ChildNodes[0].ChildNodes[0].ChildNodes[2].ChildNodes.Count - 1)
                        returnType += ",";
                }
                returnType += ">";
                d.ReturnTypeName = returnType;
            }
            else
                d.ReturnTypeName = parser.CheckAlias(currentNode.ChildNodes[2].ChildNodes[0].FindTokenAndGetText());

            d.Name = currentNode.ChildNodes[2].ChildNodes[1].FindTokenAndGetText();

            // Build the arguments of the delegate declaration.
            if (currentNode.ChildNodes[3].ChildNodes.Count > 0)
            {
                foreach (var n in currentNode.ChildNodes[3].ChildNodes)
                {
                    BuildArgument(parser, d, n.ChildNodes[0]);
                }
            }
        }
Example #4
0
        static void InterpretModifiers(Root root, DelegateDeclaration c, ParseTreeNode node)
        {
            bool foundPublic = false;
            bool foundInternal = false;

            bool foundShared = false;

            bool foundPrivate = false;
            bool foundProtected = false;

            foreach (var modifierNode in node.ChildNodes)
            {
                string text = modifierNode.FindTokenAndGetText();

                if (text == "public")
                {
                    if (foundPublic || foundInternal || foundPrivate || foundProtected)
                    {
                        root.CompilerErrors.Add(new MultipleAccessModifiersCompilerError("",
                            modifierNode.FindToken().Location.Line,
                            modifierNode.FindToken().Location.Position));
                    }
                    else
                    {
                        c.Accessibility = Accessibility.Public;
                        foundPublic = true;
                    }
                }

                if (text == "internal")
                {
                    if (foundInternal || foundPublic || foundPrivate || foundProtected)
                    {
                        root.CompilerErrors.Add(new MultipleAccessModifiersCompilerError("",
                            modifierNode.FindToken().Location.Line,
                            modifierNode.FindToken().Location.Position));
                    }
                    else
                    {
                        c.Accessibility = Accessibility.Internal;
                        foundInternal = true;
                    }
                }

                if (text == "protected")
                {
                    if (foundInternal || foundPublic || foundPrivate || foundProtected)
                    {
                        root.CompilerErrors.Add(new MultipleAccessModifiersCompilerError("",
                            modifierNode.FindToken().Location.Line,
                            modifierNode.FindToken().Location.Position));
                    }
                    else
                    {
                        c.Accessibility = Accessibility.Protected;
                        foundProtected = true;
                    }
                }

                if (text == "private")
                {
                    if (foundInternal || foundPublic || foundPrivate || foundProtected)
                    {
                        root.CompilerErrors.Add(new MultipleAccessModifiersCompilerError("",
                            modifierNode.FindToken().Location.Line,
                            modifierNode.FindToken().Location.Position));
                    }
                    else
                    {
                        c.Accessibility = Accessibility.Private;
                        foundPrivate = true;
                    }
                }

                if (text == "shared")
                {
                    if (foundShared)
                    {
                        root.CompilerErrors.Add(new DuplicateModifiersCompilerError("",
                            modifierNode.FindToken().Location.Line,
                            modifierNode.FindToken().Location.Position));
                    }
                    else
                    {
                        c.IsShared = true;
                        foundShared = true;
                    }
                }

            }
        }