Пример #1
0
 protected SourceSnippet(SourceObject start, SourceObject end, SourceStruct.Type type)
 {
     OfType   = type;
     Name     = "";          // name maybe set by inherited class
     Sequence = start;
     End      = end;
 }
Пример #2
0
 protected SourceSnippet(string name, SourceObject start, SourceObject end, SourceStruct.Type type)
 {
     OfType   = type;
     Name     = name;
     Sequence = start;
     End      = end;
 }
Пример #3
0
 public SourceObject(string text, TokenRef.Type type)
 {
     OfType   = type;
     Text     = text;
     Sequence = null;
     Previous = null;
 }
Пример #4
0
 protected SourceSnippet(string name, SourceStruct.Type type, SourceObject start)
 {
     OfType   = type;
     Name     = name;     // name maybe set by inherited class
     Sequence = start;
     End      = null;     // designates an empty Struct -e.g. a QName without a Namespace
 }
Пример #5
0
        public void LinkNext(SourceObject srcObj)
        {
            if (Sequence == null)
            {
                Sequence        = srcObj;
                srcObj.Previous = this;
            }

            else
            {
                Sequence.LinkNext(srcObj);   // find the current end of the list
            }
        }
Пример #6
0
        public static SourceStruct Build(SourceFile srcFile)
        {
            SourceObject start = srcFile.Sequence;     // the start object in a sequence of Struct objects to process
            SourceObject next = start;                 // the next object to process
            SourceStruct first = null;                 // the 1st struct built upon this call
            SourceStruct previous, build = null;

            ParseResponse response = NextStateFunc.GoToNextState(next);

            do
            {
            } while (response != ParseResponse.Null);

            return(first);
        }
Пример #7
0
        private static SourceStruct.Type IdentifyType(ref SourceObject next, out SourceObject end)
        {
            SourceStruct.Type ofType = SourceStruct.Type.Identifying;    // if not changed, this value indicates that could not be identified
            switch (next.OfType)
            {
            case TokenRef.Type.Keyword when next.Text == "using":
                ofType = SourceStruct.Type.Using;
                break;

            default:
                throw new InvalidOperationException($"Could not identify {next.ToString()}!");
            }

            end = next.Sequence;
            return(ofType);
        }
Пример #8
0
        public void InsertNextLink(SourceObject srcObj)
        {
            if (Sequence == null)
            {
                Sequence        = srcObj;    // at the end of the list -add object here
                srcObj.Previous = this;
            }

            else
            {
                srcObj.Previous = this;
                SourceObject oldNext = Sequence;
                Sequence = srcObj;
                srcObj.LinkNext(oldNext);   // find the current end of the inserted list and link the old next object there to complete Sequence
            }
        }
Пример #9
0
        /// <summary>Build the SourceStruct using the SoucreObject sequence from a SourceFile</summary>
        /// <param name="lastSrcStruct">Ref: loaded with the last SourceStruct created previously or null if none. Gets set to the last created this call</param>
        /// <param name="srcFile">The SourceFile to use for building the SourceStruct from</param>
        /// <returns>The 1st SourceStruct created by this call ...</returns>
        internal SourceStruct Build(ref SourceStruct lastSrcStruct, SourceFile srcFile)
        {
            BuildInstr   instr = BuildInstr.Continue;  // continue until a struct is identified
            SourceObject start = srcFile.Sequence;     // the start object in a sequence of Struct objects to process
            SourceObject next = start;                 // the next object to process
            SourceStruct first = null;                 // the 1st struct built upon this call
            SourceStruct previous, build = null;

            NextStateFunc.BeginParse();
            while (next != null)
            {
                ParseResponse response = NextStateFunc.GoToNextState(next);
                switch (response)
                {
                case ParseResponse.Accept:
                    if (first == null)
                    {
                        first = build;
                    }
                    break;

                case ParseResponse.Resume:
                    break;

                case ParseResponse.Next:
                case ParseResponse.Call:
                    next = next.Sequence;
                    break;

                default:
                    throw new InvalidEnumValueException(typeof(ParseResponse), response);
                }
            }

            // TODO: add check for source file completion, i.e. nothing left on the stack

            return(first);
        }
Пример #10
0
 protected SourceStruct(SourceObject start, Type type, SourceFile srcFile)
     : base(start, type)
 {
     Next = null;
     File = srcFile;
 }
Пример #11
0
        public ParseResponse GoToNextState(SourceObject next)
        {
            ParseResponse response = ParseResponse.Null;
            NextStateRec  state    = CurrentState;
            TokenRef      token    = TokenRef.Create(next.OfType, next.Text);

            do
            {
                Debug.WriteIf(state != null, $"{{{token}}} against {{{state.Token}}}", "Check");

                if (state == null)
                {
                    response = ParseResponse.Reject;
                    Debug.WriteLine(" -Match! Response = Reject");
                }

                else if (token == state.Token)
                {
                    response = state.Response;
                    Debug.WriteLine(" -Match! Response = " + response);
                }

                else if (state.Token.OfType == TokenRef.Type.Empty)
                {
                    response = state.Response;
                    Debug.WriteLine(" -Match on Empty! Response = " + response);
                }

                else if (state.Token.OfType == TokenRef.Type.Null)
                {
                    if (state.Response == ParseResponse.Next)
                    {
                        state    = state.Sequence;
                        response = ParseResponse.Null;
                    }
                    else
                    {
                        response = state.Response;
                    }

                    Debug.WriteLine(" -Special Response = " + response);
                }

                else
                {
                    Debug.WriteLine(" -NO Match! Check Next");
                    state = state.Sequence;
                }
            } while (response == ParseResponse.Null);

            // Determine next state based on response
            Debug.Write($"{{{state.Token }}} -> ", "Result");
            switch (response)
            {
            case ParseResponse.Next:
                CurrentState = state.Sequence;
                break;

            default:
                throw new InvalidEnumValueException(typeof(ParseResponse), response);
            }

            Debug.WriteLine($"{{{CurrentState.Token}}} -Response {response}!");

            return(response);
        }