Beispiel #1
0
 public EnumType(DEnum Enum, ISyntaxRegion td)
     : base(Enum, new PrimitiveType(DTokens.Int, 0), null, td)
 {
 }
Beispiel #2
0
        public void EnumValue(DEnum mye)
        {
            var ev = new DEnumValue() { Location = la.Location, Description = GetComments(), Parent = mye };

            if (laKind == Identifier && (
                Lexer.CurrentPeekToken.Kind == Assign ||
                Lexer.CurrentPeekToken.Kind == Comma ||
                Lexer.CurrentPeekToken.Kind == CloseCurlyBrace))
            {
                Step();
                ev.Name = t.Value;
                ev.NameLocation = t.Location;
            }
            else
            {
                ev.Type = Type();
                if (Expect(Identifier))
                {
                    ev.Name = t.Value;
                    ev.NameLocation = t.Location;
                }
                else if (IsEOF)
                    ev.NameHash = DTokens.IncompleteIdHash;
            }

            if (laKind == (Assign))
            {
                Step();
                ev.Initializer = AssignExpression(mye);
            }

            ev.EndLocation = t.EndLocation;
            ev.Description += CheckForPostSemicolonComment();

            mye.Add(ev);
        }
Beispiel #3
0
 public EnumType(DEnum Enum, AbstractType BaseType, ISyntaxRegion td)
     : base(Enum, BaseType, null, td)
 {
 }
Beispiel #4
0
        private DEnum EnumDeclaration(INode Parent)
        {
            var mye = new DEnum() { Location = t.Location, Description = GetComments(), Parent=Parent };

            ApplyAttributes(mye);

            if (laKind == (Identifier))
            {
                Step ();
                mye.Name = t.Value;
                mye.NameLocation = t.Location;
            }
            else if (IsEOF)
                mye.NameHash = DTokens.IncompleteIdHash;

            // Enum inhertance type
            if (laKind == (Colon))
            {
                Step();
                mye.Type = Type();
            }

            if (laKind == OpenCurlyBrace)
                EnumBody(mye);
            else
                Expect(Semicolon);

            mye.Description += CheckForPostSemicolonComment();
            return mye;
        }
Beispiel #5
0
        public void EnumBody(DEnum mye)
        {
            var OldPreviousComment = PreviousComment;
            PreviousComment = new StringBuilder();
            mye.BlockStartLocation = la.Location;

            // While there are commas, loop through
            do
            {
                Step();

                if (laKind == CloseCurlyBrace)
                    break;

                EnumValue(mye);
            }
            while (laKind == Comma);

            Expect(CloseCurlyBrace);
            PreviousComment = OldPreviousComment;

            mye.EndLocation = t.EndLocation;
        }
Beispiel #6
0
        public void EnumBody(DEnum mye)
        {
            var OldPreviousComment = PreviousComment;
            PreviousComment = new StringBuilder();
            mye.BlockStartLocation = la.Location;

            // While there are commas, loop through
            do
            {
                Step();

                if (laKind == CloseCurlyBrace)
                    break;

                var ev = new DEnumValue() { Location = la.Location, Description = GetComments(), Parent = mye };
                LastParsedObject = ev;

                if (laKind == Identifier && (
                    Lexer.CurrentPeekToken.Kind == Assign ||
                    Lexer.CurrentPeekToken.Kind == Comma ||
                    Lexer.CurrentPeekToken.Kind == CloseCurlyBrace))
                {
                    Step();
                    ev.Name = t.Value;
                    ev.NameLocation = t.Location;
                }
                else
                {
                    ev.Type = Type();
                    if (Expect(Identifier))
                    {
                        ev.Name = t.Value;
                        ev.NameLocation = t.Location;
                    }
                    else if (IsEOF)
                        ExpectingNodeName = true;
                }

                if (laKind == (Assign))
                {
                    Step();
                    ev.Initializer = AssignExpression();
                }

                ev.EndLocation = t.EndLocation;
                ev.Description += CheckForPostSemicolonComment();

                mye.Add(ev);
            }
            while (laKind == Comma);

            Expect(CloseCurlyBrace);
            PreviousComment = OldPreviousComment;

            mye.EndLocation = t.EndLocation;
        }
 public virtual void Visit(DEnum n)
 {
     VisitBlock(n);
 }
 public virtual void Visit(DEnum n)
 {
     VisitBlock(n);
 }
Beispiel #9
0
        private INode[] EnumDeclaration(INode Parent)
        {
            Expect(Enum);
            var ret = new List<INode>();

            var mye = new DEnum() { Location = t.Location, Description = GetComments(), Parent=Parent };
            LastParsedObject = mye;

            ApplyAttributes(mye);

            if (laKind != Identifier && IsBasicType())
                mye.Type = Type();
            else if (laKind == Auto)
            {
                Step();
                mye.Attributes.Add(new Modifier(Auto));
            }

            if (laKind == (Identifier))
            {
                // Normal enum identifier
                if (Lexer.CurrentPeekToken.Kind == (Assign) || // enum e = 1234;
                    Lexer.CurrentPeekToken.Kind == (OpenCurlyBrace) || // enum e { A,B,C, }
                    Lexer.CurrentPeekToken.Kind == (Semicolon) || // enum e;
                    Lexer.CurrentPeekToken.Kind == Colon) { // enum e : uint {..}
                    Step ();
                    mye.Name = t.Value;
                    mye.NameLocation = t.Location;
                }
                else {
                    if (mye.Type == null)
                        mye.Type = Type();

                    if (Expect(Identifier))
                    {
                        mye.Name = t.Value;
                        mye.NameLocation = t.Location;
                    }
                }
            }
            else if (IsEOF)
                ExpectingNodeName = true;

            if (IsDeclaratorSuffix)
            {
                DeclaratorSuffixes(mye);
            }

            // Enum inhertance type
            if (laKind == (Colon))
            {
                Step();
                mye.Type = Type();
            }

            // Variables with 'enum' as base type
            if (laKind == (Assign) || laKind == (Semicolon))
            {
                do
                {
                    var enumVar = new DVariable();
                    LastParsedObject = enumVar;

                    enumVar.AssignFrom(mye);

                    enumVar.Attributes.Add(new Modifier(Enum));
                    if (mye.Type != null)
                        enumVar.Type = mye.Type;
                    else
                        enumVar.Type = new DTokenDeclaration(Enum);

                    if (laKind == (Comma))
                    {
                        Step();
                        Expect(Identifier);
                        enumVar.Name = t.Value;
                        enumVar.NameLocation = t.Location;
                    }

                    if (laKind == (Assign))
                    {
                        //Step(); -- expected by initializer
                        enumVar.Initializer = Initializer(); // Seems to be specified wrongly - theoretically there must be an AssignExpression();
                    }
                    enumVar.EndLocation = t.Location;
                    ret.Add(enumVar);
                }
                while (laKind == Comma);

                Expect(Semicolon);
            }
            else if (laKind == OpenCurlyBrace) // Normal enum block
            {
                EnumBody(mye);
                ret.Add(mye);
            }

            mye.Description += CheckForPostSemicolonComment();

            return ret.ToArray();
        }
Beispiel #10
0
        private INode[] EnumDeclaration()
        {
            Expect(Enum);
            var ret = new List<INode>();

            var mye = new DEnum() { StartLocation = t.Location, Description = GetComments() };
            LastParsedObject = mye;

            ApplyAttributes(mye);

            if (IsBasicType() && laKind != Identifier)
                mye.Type = Type();
            else if (laKind == Auto)
            {
                Step();
                mye.Attributes.Add(new DAttribute(Auto));
            }

            if (laKind == (Identifier))
            {
                // Normal enum identifier
                if (Lexer.CurrentPeekToken.Kind == (Assign) || Lexer.CurrentPeekToken.Kind == (OpenCurlyBrace) || Lexer.CurrentPeekToken.Kind == (Semicolon) || Lexer.CurrentPeekToken.Kind == Colon)
                {
                    Step();
                    mye.Name = t.Value;
                }
                else
                {
                    mye.Type = Type();

                    Expect(Identifier);
                    mye.Name = t.Value;
                }
            }

            // Enum inhertance type
            if (laKind == (Colon))
            {
                Step();
                mye.Type = Type();
            }

            // Variables with 'enum' as base type
            if (laKind == (Assign) || laKind == (Semicolon))
            {
            another_enumvalue:
                var enumVar = new DVariable();
                LastParsedObject = enumVar;

                enumVar.AssignFrom(mye);

                enumVar.Attributes.Add(new DAttribute(Enum));
                if (mye.Type != null)
                    enumVar.Type = mye.Type;
                else
                    enumVar.Type = new DTokenDeclaration(Enum);

                if (laKind == (Comma))
                {
                    Step();
                    Expect(Identifier);
                    enumVar.Name = t.Value;
                }

                if (laKind == (Assign))
                {
                    Step();
                    enumVar.Initializer = AssignExpression();
                }
                enumVar.EndLocation = t.Location;
                ret.Add(enumVar);

                // If there are more than one definitions, loop back
                if (laKind == (Comma))
                    goto another_enumvalue;

                Expect(Semicolon);
            }
            else
            {
                // Normal enum block
                Expect(OpenCurlyBrace);

                var OldPreviousComment = PreviousComment;
                PreviousComment = "";
                mye.BlockStartLocation = t.Location;

                bool init = true;
                // While there are commas, loop through
                while ((init && laKind != (Comma)) || laKind == (Comma))
                {
                    if (!init) Step();
                    init = false;

                    if (laKind == (CloseCurlyBrace)) break;

                    var ev = new DEnumValue() { StartLocation = t.Location, Description = GetComments() };
                    LastParsedObject = ev;

                    if (laKind == (Identifier) && (Lexer.CurrentPeekToken.Kind == (Assign) || Lexer.CurrentPeekToken.Kind == (Comma) || Lexer.CurrentPeekToken.Kind == (CloseCurlyBrace)))
                    {
                        Step();
                        ev.Name = t.Value;
                    }
                    else
                    {
                        ev.Type = Type();
                        Expect(Identifier);
                        ev.Name = t.Value;
                    }

                    if (laKind == (Assign))
                    {
                        Step();
                        ev.Initializer = AssignExpression();
                    }

                    ev.EndLocation = t.EndLocation;
                    ev.Description += CheckForPostSemicolonComment();

                    mye.Add(ev);
                }
                Expect(CloseCurlyBrace);
                PreviousComment = OldPreviousComment;

                mye.EndLocation = t.EndLocation;

                // Important: Add the enum block, whereas it CAN be unnamed, to the return array
                ret.Add(mye);
            }

            mye.Description += CheckForPostSemicolonComment();

            return ret.ToArray();
        }
Beispiel #11
0
        private INode[] EnumDeclaration(INode Parent)
        {
            Expect(Enum);
            var ret = new List<INode>();

            var mye = new DEnum() { Location = t.Location, Description = GetComments(), Parent=Parent };
            LastParsedObject = mye;

            ApplyAttributes(mye);

            if (IsBasicType() && laKind != Identifier)
                mye.Type = Type();
            else if (laKind == Auto)
            {
                Step();
                mye.Attributes.Add(new DAttribute(Auto));
            }

            if (laKind == (Identifier))
            {
                // Normal enum identifier
                if (Lexer.CurrentPeekToken.Kind == (Assign) || // enum e = 1234;
                    Lexer.CurrentPeekToken.Kind == (OpenCurlyBrace) || // enum e { A,B,C, }
                    Lexer.CurrentPeekToken.Kind == (Semicolon) || // enum e;
                    Lexer.CurrentPeekToken.Kind == Colon) // enum e : uint {..}
                {
                    Step();
                    mye.Name = t.Value;
                    mye.NameLocation = t.Location;
                }
                else
                {
                    if(mye.Type == null)
                        mye.Type = Type();

                    if (Expect(Identifier))
                    {
                        mye.Name = t.Value;
                        mye.NameLocation = t.Location;
                    }
                }
            }

            if (IsDeclaratorSuffix)
            {
                var _unused = new List<INode>();
                var bt2=DeclaratorSuffixes(out mye.TemplateParameters, out _unused, mye.Attributes);

                if (bt2 != null)
                {
                    bt2.InnerDeclaration = mye.Type;
                    mye.Type = bt2;
                }
            }

            // Enum inhertance type
            if (laKind == (Colon))
            {
                Step();
                mye.Type = Type();
            }

            // Variables with 'enum' as base type
            if (laKind == (Assign) || laKind == (Semicolon))
            {
                do
                {
                    var enumVar = new DVariable();
                    LastParsedObject = enumVar;

                    enumVar.AssignFrom(mye);

                    enumVar.Attributes.Add(new DAttribute(Enum));
                    if (mye.Type != null)
                        enumVar.Type = mye.Type;
                    else
                        enumVar.Type = new DTokenDeclaration(Enum);

                    if (laKind == (Comma))
                    {
                        Step();
                        Expect(Identifier);
                        enumVar.Name = t.Value;
                        enumVar.NameLocation = t.Location;
                    }

                    if (laKind == (Assign))
                    {
                        //Step(); -- expected by initializer
                        enumVar.Initializer = Initializer(); // Seems to be specified wrongly - theoretically there must be an AssignExpression();
                    }
                    enumVar.EndLocation = t.Location;
                    ret.Add(enumVar);
                }
                while (laKind == Comma);

                Expect(Semicolon);
            }
            else
            {
                // Normal enum block
                Expect(OpenCurlyBrace);

                var OldPreviousComment = PreviousComment;
                PreviousComment = "";
                mye.BlockStartLocation = t.Location;

                bool init = true;
                // While there are commas, loop through
                while ((init && laKind != (Comma)) || laKind == (Comma))
                {
                    if (!init) Step();
                    init = false;

                    if (laKind == CloseCurlyBrace) break;

                    var ev = new DEnumValue() { Location = la.Location, Description = GetComments(), Parent = mye };
                    LastParsedObject = ev;

                    if (laKind == Identifier && (
                        Lexer.CurrentPeekToken.Kind == Assign ||
                        Lexer.CurrentPeekToken.Kind == Comma ||
                        Lexer.CurrentPeekToken.Kind == CloseCurlyBrace))
                    {
                        Step();
                        ev.Name = t.Value;
                        ev.NameLocation = t.Location;
                    }
                    else
                    {
                        ev.Type = Type();
                        Expect(Identifier);
                        ev.Name = t.Value;
                        ev.NameLocation = t.Location;
                    }

                    if (laKind == (Assign))
                    {
                        Step();
                        ev.Initializer = AssignExpression();
                    }

                    ev.EndLocation = t.EndLocation;
                    ev.Description += CheckForPostSemicolonComment();

                    mye.Add(ev);
                }
                Expect(CloseCurlyBrace);
                PreviousComment = OldPreviousComment;

                mye.EndLocation = t.EndLocation;

                // Important: Add the enum block, whereas it CAN be unnamed, to the return array
                ret.Add(mye);
            }

            mye.Description += CheckForPostSemicolonComment();

            return ret.ToArray();
        }
		/*public override void VisitAttributeMetaDeclaration(AttributeMetaDeclaration md)
		{
			base.Visit(md);
		}

		public override void VisitMetaDeclarationBlock(MetaDeclarationBlock metaDeclarationBlock)
		{
			base.Visit(metaDeclarationBlock);
		}

		public override void VisitAttributeMetaDeclarationBlock(AttributeMetaDeclarationBlock attributeMetaDeclarationBlock)
		{
			base.Visit(attributeMetaDeclarationBlock);
		}

		public override void VisitAttributeMetaDeclarationSection(AttributeMetaDeclarationSection attributeMetaDeclarationSection)
		{
			base.Visit(attributeMetaDeclarationSection);
		}
		
		public override void Visit(ElseMetaDeclaration elseMetaDeclaration)
		{
			base.Visit(elseMetaDeclaration);
		}
		
		public override void Visit(ElseMetaDeclarationBlock elseMetaDeclarationBlock)
		{
			base.Visit(elseMetaDeclarationBlock);
		}*/
		#endregion
		
		public override void Visit(DEnum n)
		{
			base.Visit(n);
		}
		public override void Visit(DEnum n)
		{
			PushBlock(n);
		}
Beispiel #14
0
			public override void Visit(DEnum n)
			{
				l.Add(new FoldingRegion(GetBlockBodyRegion(n), FoldType.Type));

				base.Visit(n);
			}
        /// <returns>Either CurrentScope, a BlockStatement object that is associated with the parent method or a complete new DModule object</returns>
        public static object FindCurrentCaretContext(string code,
			IBlockNode CurrentScope,
			int caretOffset, CodeLocation caretLocation,
			out ParserTrackerVariables TrackerVariables)
        {
            bool ParseDecl = false;

            int blockStart = 0;
            var blockStartLocation = CurrentScope.BlockStartLocation;

            if (CurrentScope is DMethod)
            {
                var block = (CurrentScope as DMethod).GetSubBlockAt(caretLocation);

                if (block != null)
                    blockStart = DocumentHelper.LocationToOffset(code, blockStartLocation = block.Location);
                else
                    return FindCurrentCaretContext(code, CurrentScope.Parent as IBlockNode, caretOffset, caretLocation, out TrackerVariables);
            }
            else if (CurrentScope != null)
            {
                if (CurrentScope.BlockStartLocation.IsEmpty || caretLocation < CurrentScope.BlockStartLocation && caretLocation > CurrentScope.Location)
                {
                    ParseDecl = true;
                    blockStart = DocumentHelper.LocationToOffset(code, blockStartLocation = CurrentScope.Location);
                }
                else
                    blockStart = DocumentHelper.LocationToOffset(code, CurrentScope.BlockStartLocation);
            }

            if (blockStart >= 0 && caretOffset - blockStart > 0)
            {
                var codeToParse = code.Substring(blockStart, caretOffset - blockStart);

                var sr = new StringReader(codeToParse);
                var psr = DParser.Create(sr);

                /* Deadly important! For correct resolution behaviour,
                 * it is required to set the parser virtually to the blockStart position,
                 * so that everything using the returned object is always related to
                 * the original code file, not our code extraction!
                 */
                psr.Lexer.SetInitialLocation(blockStartLocation);

                object ret = null;

                if (CurrentScope == null || CurrentScope is IAbstractSyntaxTree)
                    ret = psr.Parse();
                else if (CurrentScope is DMethod)
                {
                    psr.Step();
                    ret = psr.BlockStatement(CurrentScope);
                }
                else if (CurrentScope is DModule)
                    ret = psr.Root();
                else
                {
                    psr.Step();
                    if (ParseDecl)
                    {
                        var ret2 = psr.Declaration(CurrentScope);

                        if (ret2 != null && ret2.Length > 0)
                            ret = ret2[0];
                    }
                    else
                    {
                        DBlockNode bn = null;
                        if (CurrentScope is DClassLike)
                        {
                            var t = new DClassLike((CurrentScope as DClassLike).ClassType);
                            t.AssignFrom(CurrentScope);
                            bn = t;
                        }
                        else if (CurrentScope is DEnum)
                        {
                            var t = new DEnum();
                            t.AssignFrom(CurrentScope);
                            bn = t;
                        }

                        bn.Clear();

                        psr.ClassBody(bn);
                        ret = bn;
                    }
                }

                TrackerVariables = psr.TrackerVariables;
                sr.Close();

                return ret;
            }

            TrackerVariables = null;

            return null;
        }
        public static ISyntaxRegion FindCurrentCaretContext(IEditorData editor, 
			out ParserTrackerVariables trackerVariables, 
			ref IBlockNode currentScope, 
			out IStatement currentStatement)
        {
            if(currentScope == null)
                currentScope = DResolver.SearchBlockAt (editor.SyntaxTree, editor.CaretLocation, out currentStatement);

            if (currentScope == null) {
                trackerVariables = null;
                currentStatement = null;
                return null;
            }

            bool ParseDecl = false;

            int blockStart = 0;
            var blockStartLocation = currentScope != null ? currentScope.BlockStartLocation : editor.CaretLocation;

            if (currentScope is DMethod)
            {
                var block = (currentScope as DMethod).GetSubBlockAt(editor.CaretLocation);

                if (block != null)
                    blockStart = DocumentHelper.GetOffsetByRelativeLocation (editor.ModuleCode, editor.CaretLocation, editor.CaretOffset, blockStartLocation = block.Location);
                else {
                    currentScope = currentScope.Parent as IBlockNode;
                    return FindCurrentCaretContext (editor, out trackerVariables, ref currentScope, out currentStatement);
                }
            }
            else if (currentScope != null)
            {
                if (currentScope.BlockStartLocation.IsEmpty || (editor.CaretLocation < currentScope.BlockStartLocation && editor.CaretLocation > currentScope.Location))
                {
                    ParseDecl = true;
                    blockStart = DocumentHelper.GetOffsetByRelativeLocation(editor.ModuleCode, editor.CaretLocation, editor.CaretOffset, blockStartLocation = currentScope.Location);
                }
                else
                    blockStart = DocumentHelper.GetOffsetByRelativeLocation(editor.ModuleCode, editor.CaretLocation, editor.CaretOffset, currentScope.BlockStartLocation);
            }

            if (blockStart >= 0 && editor.CaretOffset - blockStart > 0)
                using (var sr = new Misc.StringView(editor.ModuleCode, blockStart, editor.CaretOffset - blockStart))
                {
                    var psr = DParser.Create(sr);

                    /*					 Deadly important! For correct resolution behaviour,
                     * it is required to set the parser virtually to the blockStart position,
                     * so that everything using the returned object is always related to
                     * the original code file, not our code extraction!
                     */
                    psr.Lexer.SetInitialLocation(blockStartLocation);

                    ISyntaxRegion ret = null;

                    if (currentScope == null)
                        ret = psr.Parse();
                    else if (currentScope is DMethod)
                    {
                        psr.Step();
                        var dm = currentScope as DMethod;
                        dm.Clear();

                        if ((dm.SpecialType & DMethod.MethodType.Lambda) != 0 &&
                            psr.Lexer.LookAhead.Kind != DTokens.OpenCurlyBrace) {
                            psr.LambdaSingleStatementBody (dm);
                            ret = dm.Body;
                        } else {
                            var methodRegion = DTokens.Body;

                            if (dm.In != null && blockStartLocation == dm.In.Location)
                                methodRegion = DTokens.In;

                            if (dm.Out != null && blockStartLocation == dm.Out.Location)
                                methodRegion = DTokens.Out;

                            var newBlock = psr.BlockStatement (currentScope);
                            ret = newBlock;

                            switch (methodRegion) {
                                case DTokens.Body:
                                    newBlock.EndLocation = dm.Body.EndLocation;
                                    dm.Body = newBlock;
                                    break;
                                case DTokens.In:
                                    newBlock.EndLocation = dm.In.EndLocation;
                                    dm.In = newBlock;
                                    break;
                                case DTokens.Out:
                                    newBlock.EndLocation = dm.Out.EndLocation;
                                    dm.Out = newBlock;
                                    break;
                            }
                        }
                    }
                    else if (currentScope is DModule)
                        ret = psr.Root();
                    else
                    {
                        psr.Step();
                        if (ParseDecl)
                        {
                            var ret2 = psr.Declaration(currentScope);

                            if (ret2 != null && ret2.Length > 0)
                                ret = ret2[0];
                        }
                        else if (currentScope is DClassLike)
                        {
                            var t = new DClassLike((currentScope as DClassLike).ClassType);
                            t.AssignFrom(currentScope);
                            t.Clear();
                            psr.ClassBody(t);
                            ret = t;
                        }
                        else if (currentScope is DEnum)
                        {
                            var t = new DEnum();
                            t.AssignFrom(currentScope);
                            t.Clear();
                            psr.EnumBody(t);
                            ret = t;
                        }
                    }

                    currentScope = DResolver.SearchBlockAt (currentScope,
                        psr.Lexer.CurrentToken != null ? psr.Lexer.CurrentToken.EndLocation : editor.CaretLocation,
                        out currentStatement);
                    trackerVariables = psr.TrackerVariables;
                    return ret;
                }

            trackerVariables = null;
            currentStatement = null;
            return null;
        }