Beispiel #1
0
 /// <summary>
 /// Initializes a StateMachine with a default state defined by owner. Initialization
 /// includes a reference value identifying the state.
 /// </summary>
 /// <param name="defaultState">Default state.</param>
 /// <param name="stateRef">A StateRef value identifying the state.</param>
 public StateMachine(iState defaultState, StateRef stateRef)
 {
     l_validStates = new Dictionary <StateRef, iState> ();
     l_validStates.Add(stateRef, defaultState);
     i_currentState     = defaultState;
     sr_currentStateRef = stateRef;
 }
Beispiel #2
0
        /// <summary>
        /// Executes a specified task in an asynchronous manner, waiting for its completion.
        /// </summary>
        /// <param name="task">Task to execute.</param>
        public void Execute(Task task)
        {
            // create state object
            var taskState = new StateRef <object>(new AutoResetEvent(false));

            // queue a task and wait for it to finish executing
            task.ContinueWith(TaskCompletionHandler, taskState);
            taskState.Lock.WaitOne();

            // check for and rethrow any exceptions
            if (taskState.Exception != null)
            {
                throw new Exception("Exception occured while executing asynchronous code.", taskState.Exception);
            }

            // completion method
            void TaskCompletionHandler(Task t, object state)
            {
                // retrieve state data
                var stateRef = state as StateRef <object>;

                // retrieve any exceptions or cancellation status
                if (t.IsFaulted)
                {
                    stateRef.Exception = t.Exception;
                }
                else if (t.IsCanceled)
                {
                    stateRef.Exception = new TaskCanceledException(t);
                }

                // signal that the execution is done
                stateRef.Lock.Set();
            }
        }
            internal void SaveThis(ModelSaveContext ctx)
            {
                Host.CheckValue(ctx, nameof(ctx));
                ctx.CheckAtModel();

                Host.Assert(InitialWindowSize == 0);
                Host.Assert(2 <= SeasonalWindowSize);
                Host.Assert(0 <= DiscountFactor && DiscountFactor <= 1);
                Host.Assert(Enum.IsDefined(typeof(ErrorFunction), ErrorFunction));
                Host.Assert(Model != null);

                // *** Binary format ***
                // <base>
                // int: _seasonalWindowSize
                // float: _discountFactor
                // byte: _errorFunction
                // bool: _isAdaptive
                // State: StateRef
                // AdaptiveSingularSpectrumSequenceModeler: _model

                base.SaveModel(ctx);
                ctx.Writer.Write(SeasonalWindowSize);
                ctx.Writer.Write(DiscountFactor);
                ctx.Writer.Write((byte)ErrorFunction);
                ctx.Writer.Write(IsAdaptive);
                StateRef.Save(ctx.Writer);

                ctx.SaveModel(Model, "SSA");
            }
Beispiel #4
0
                private void RenderLinksForState(StateEditorGUI state)
                {
                    StateMachineEditorLink[] links = state.GetEditableObject().GetEditorLinks();

                    if (links != null)
                    {
                        float fraction = 1.0f / (links.Length + 1.0f);
                        float current  = fraction;

                        foreach (StateMachineEditorLink link in links)
                        {
                            StateRef stateRef = link.GetStateRef();

                            if (stateRef.IsInternal())
                            {
                                StateEditorGUI toState = FindStateForLink(stateRef);

                                if (toState != null)
                                {
                                    RenderLink(link.GetDescription(), state, toState, current);
                                }
                            }
                            else
                            {
                                RenderExternalLink(link, state, current);
                            }

                            current += fraction;
                        }
                    }
                }
Beispiel #5
0
        /// <summary>
        /// Executes a specified task in an asynchronous manner, waiting for its completion, and returning the result.
        /// </summary>
        /// <typeparam name="T">Type of the Task's return value.</typeparam>
        /// <param name="task">Task to execute.</param>
        /// <returns>Task's result.</returns>
        public T Execute <T>(Task <T> task)
        {
            // create state object
            var taskState = new StateRef <T>(new AutoResetEvent(false));

            // queue a task and wait for it to finish executing
            task.ContinueWith(TaskCompletionHandler, taskState);
            taskState.Lock.WaitOne();

            // check for and rethrow any exceptions
            if (taskState.Exception != null)
            {
                throw taskState.Exception;
            }

            // return the result, if any
            if (taskState.HasResult)
            {
                return(taskState.Result);
            }

            // throw exception if no result
            throw new Exception("Task returned no result.");

            // completion method
            void TaskCompletionHandler(Task <T> t, object state)
            {
                // retrieve state data
                var stateRef = state as StateRef <T>;

                // retrieve any exceptions or cancellation status
                if (t.IsFaulted)
                {
                    if (t.Exception.InnerExceptions.Count == 1) // unwrap if 1
                    {
                        stateRef.Exception = t.Exception.InnerException;
                    }
                    else
                    {
                        stateRef.Exception = t.Exception;
                    }
                }
                else if (t.IsCanceled)
                {
                    stateRef.Exception = new TaskCanceledException(t);
                }

                // return the result from the task, if any
                if (t.IsCompleted && !t.IsFaulted)
                {
                    stateRef.HasResult = true;
                    stateRef.Result    = t.Result;
                }

                // signal that the execution is done
                stateRef.Lock.Set();
            }
        }
 public void LoadExternalState(StateMachineExternalStateEditorGUI state)
 {
     if (ShowOnLoadSaveChangesDialog())
     {
         StateRef stateRef = state.ExternalStateRef.GetStateRef();
         string   fileName = AssetDatabase.GetAssetPath(stateRef.GetExternalFile()._editorAsset);
         LoadFile(fileName);
     }
 }
        public StateMachine(TStateType initialState)
        {
            var reference = new StateRef {
                State = initialState
            };

            _stateReader = () => reference.State;
            _stateWriter = s => reference.State = s;
        }
Beispiel #8
0
    /// <summary>
    /// Initializes a state machine in the pre-start state (used for gameplay scenes with a countdown) with a defined target "first" state.
    /// </summary>
    /// <param name="stateRefIn">The StateRef pointing to our desired state</param>
    public StateMachine(StateRef stateRefIn)
    {
        iState prestart = new PreStartState(stateRefIn);

        l_validStates = new Dictionary <StateRef, iState>();
        l_validStates.Add(StateRef.PRESTART_STATE, prestart);
        i_currentState     = prestart;
        sr_currentStateRef = StateRef.PRESTART_STATE;
    }
                public override void SetPosition(Vector2 position)
                {
                    StateRef externalStateRef = ExternalStateRef.GetStateRef();

                    externalStateRef._editorExternalLinkPosition = position;
                    ExternalStateRef.SetStateRef(externalStateRef);

                    MarkAsDirty(true);
                }
            internal void SaveThis(ModelSaveContext ctx)
            {
                ctx.CheckAtModel();
                base.SaveModel(ctx);

                // *** Binary format ***
                // <base>
                // State: StateRef
                StateRef.Save(ctx.Writer);
            }
    /// <summary>
    /// Creates a new StateRef object containing state and a new Timer that will use the callback and state.
    /// The Timer will initially not be started. The returned object will be passed into the callback as its
    /// argument. Start the Timer by invoking StateRef.Start. Dispose the Timer, and release references to it,
    /// state, and the StateRef by invoking StateRef.Dispose. No references are held on the Timer, state or
    /// the StateRef until StateRef.Start is invoked. See the class documentation for a usage example.
    /// </summary>
    public StateRef <T> Create <T>(T state, TypedCallback <T> callback)
    {
        StateRef <T> stateRef = new StateRef <T>();

        stateRef.Parent = this;
        stateRef.State  = state;
        stateRef.Timer  = new System.Threading.Timer(
            new TimerCallback((s) => { callback.Invoke((StateRef <T>)s); }),
            stateRef, Timeout.Infinite, Timeout.Infinite);
        return(stateRef);
    }
Beispiel #12
0
		/// <summary>
		/// Initializes a new instance of the <see cref="ActionState"/> class.
		/// </summary>
		/// <param name="stack"></param>
		/// <param name="state"></param>
		/// <param name="currentToken"></param>
		public ActionState(Frame stack, StateRef state, CodePoint currentToken)
			: this()
		{
			#region Contract
			Contract.Requires<ArgumentNullException>(stack != null);
			#endregion

			this.Stack = stack;
			this.NextState = state;
			this.CurrentToken = currentToken;
		}
Beispiel #13
0
            private static object FixupStateRefs(object obj, object stateMachine)
            {
                if (obj.GetType() == typeof(StateRef))
                {
                    StateRef StateRef = (StateRef)obj;
                    StateRef.SetParentStatemachine((StateMachine)stateMachine);
                    return(StateRef);
                }

                return(obj);
            }
        private protected override void SaveModel(ModelSaveContext ctx)
        {
            ctx.CheckAtModel();
            Host.Assert(InitialWindowSize == 0);
            base.SaveModel(ctx);

            // *** Binary format ***
            // <base>
            // State: StateRef
            StateRef.Save(ctx.Writer);
        }
            internal void SaveThis(ModelSaveContext ctx)
            {
                ctx.CheckAtModel();
                Host.Assert(InitialWindowSize == 0);
                base.SaveModel(ctx);

                // *** Binary format ***
                // <base>
                // State: StateRef
                StateRef.Save(ctx.Writer);
            }
Beispiel #16
0
    public StateDTree GetChild(StateRef stateIn)
    {
        foreach (StateDTree child in l_children)
        {
            if (child.GetState() == stateIn)
            {
                return(child);
            }
        }

        return(null);
    }
Beispiel #17
0
    new public AudioDTree GetChild(StateRef stateIn)
    {
        foreach (AudioDTree child in l_children)
        {
            if (child.GetState() == stateIn)
            {
                return(child);
            }
        }

        return(this);
    }
Beispiel #18
0
            public static IEnumerator Run(StateMachineComponent stateMachine, StateRef startState, GameObject sourceObject = null)
            {
                State state = startState.GetState(sourceObject != null ? sourceObject : stateMachine.gameObject);

                if (state != null)
                {
#if UNITY_EDITOR && DEBUG
                    string debugFileName = startState.GetExternalFile().GetFilePath();
                    StateMachineDebug.OnStateStarted(stateMachine, state, debugFileName);
#endif
                    return(state.PerformState(stateMachine));
                }

                return(null);
            }
                private StateEditorGUI FindStateForLink(StateRef link)
                {
                    int stateId = link.GetStateID();

                    if (stateId != -1)
                    {
                        foreach (StateEditorGUI state in _editableObjects)
                        {
                            if (stateId == state.GetStateId())
                            {
                                return(state);
                            }
                        }
                    }

                    return(null);
                }
Beispiel #20
0
            private static object FixupStateRefs(object obj, object stateMachine)
            {
                if (obj.GetType() == typeof(StateRef))
                {
                    StateRef StateRef = (StateRef)obj;
                    StateRef.SetParentStatemachine((StateMachine)stateMachine);
                    return(StateRef);
                }
#if UNITY_EDITOR
                else if (obj.GetType() == typeof(LocalisedStringRef))
                {
                    LocalisedStringRef localisedStringRef = (LocalisedStringRef)obj;
                    localisedStringRef.SetAutoNameParentName(((StateMachine)stateMachine)._name);
                    return(localisedStringRef);
                }
#endif
                return(obj);
            }
		/// <summary>
		/// Parses the parse table from the specified AST.
		/// </summary>
		/// <param name="ast">The AST.</param>
		/// <returns>The resulting <see cref="ParseTable"/>.</returns>
		private ParseTable Parse(ITerm ast)
		{
			#region Contract
			Contract.Requires<ArgumentNullException>(ast != null);
			Contract.Ensures(Contract.Result<ParseTable>() != null);
			#endregion
			var pt = ast.ToCons("parse-table", 5);
			int version = pt[0].ToInt32();
			Assert(version == 4 || version == 6, "Only version 4 or 6 parse tables are supported.");

			var initialState = new StateRef(pt[1].ToInt32());
			var labels = ParseLabels((IListTerm)pt[2]);
			var states = ParseStates((IListTerm)pt[3].ToCons("states", 1)[0], labels);
			var priorities = ParsePriorities((IListTerm)pt[4].ToCons("priorities", 1)[0]);

			// TODO: Injections?

			return new ParseTable(initialState, states, labels, priorities);
		}
Beispiel #22
0
        ListAllStateReferences(
            Guid chainId,
            long lowestIndex  = 0,
            long highestIndex = long.MaxValue)
        {
            byte[] prefix = StateRefKeyPrefix;

            var stateRefs = new List <StateRef>();

            foreach (Iterator it in IterateDb(_stateRefDb, prefix, chainId))
            {
                byte[] key            = it.Key();
                int    stateKeyLength = key.Length - sizeof(long) - prefix.Length;
                byte[] stateKeyBytes  = key.Skip(prefix.Length).Take(stateKeyLength).ToArray();
                string stateKey       = RocksDBStoreBitConverter.GetString(stateKeyBytes);

                byte[] indexBytes = key.Skip(prefix.Length + stateKeyLength).ToArray();
                long   index      = RocksDBStoreBitConverter.ToInt64(indexBytes);

                if (index < lowestIndex || index > highestIndex)
                {
                    continue;
                }

                var hash     = new HashDigest <SHA256>(it.Value());
                var stateRef = new StateRef
                {
                    StateKey   = stateKey,
                    BlockHash  = hash,
                    BlockIndex = index,
                };

                stateRefs.Add(stateRef);
            }

            return(stateRefs
                   .GroupBy(stateRef => stateRef.StateKey)
                   .ToImmutableDictionary(
                       g => g.Key,
                       g => (IImmutableList <HashDigest <SHA256> >)g
                       .Select(r => r.BlockHash).ToImmutableList()
                       ));
        }
                private void RenderExternalLink(StateMachineEditorLink link, StateEditorGUI fromState, int linkIndex)
                {
                    StateMachineExternalStateEditorGUI externalState = null;

                    StateRef stateRef = link.GetStateRef();

                    //Find external link for this state
                    foreach (StateEditorGUI state in _editableObjects)
                    {
                        StateMachineExternalStateEditorGUI extState = state as StateMachineExternalStateEditorGUI;

                        if (extState != null)
                        {
                            StateRef extStateRef = extState.ExternalStateRef.GetStateRef();

                            if (extStateRef.GetStateID() == stateRef.GetStateID() && extStateRef.GetExternalFile().GetFileGUID() == stateRef.GetExternalFile().GetFileGUID())
                            {
                                externalState = extState;
                                break;
                            }
                        }
                    }

                    //If none exists, create a new one
                    if (externalState == null)
                    {
                        externalState = (StateMachineExternalStateEditorGUI)AddNewObject(new StateMachineExternalState());
                        externalState.ExternalStateRef = link;
                        _editableObjects.Add(externalState);
                    }

                    if (!externalState.ExternalHasRendered)
                    {
                        externalState.CalcBounds(_style);
                        bool  selected     = _selectedObjects.Contains(externalState);
                        Color borderColor  = selected ? _style._stateBackgroundSelected : _style._stateBackground;
                        Rect  renderedRect = GetScreenRect(externalState.GetBounds());
                        externalState.Render(renderedRect, borderColor, _style._externalStateColor, _style, selected ? 2.0f : 1.0f);
                        externalState.ExternalHasRendered = true;
                    }

                    RenderLink(link.GetDescription(), fromState, externalState, linkIndex);
                }
    public AudioRef GetAudioState()
    {
        AudioRef foundClip = AudioRef.ERROR_CLIP;

        StateRef airState    = c_airMachine.GetCurrentState();
        StateRef rideState   = c_accelMachine.GetCurrentState();
        StateRef turnState   = c_turnMachine.GetCurrentState();
        StateRef groundState = StateRef.TERR_SNOW; // currently always snow

        // obey the order of the tree: air, ground, turn, terre
        AudioDTree currentBranch = t_audioStateTree.GetChild(airState);

        currentBranch = currentBranch.GetChild(rideState);
        currentBranch = currentBranch.GetChild(turnState);
        currentBranch = currentBranch.GetChild(groundState);

        foundClip = currentBranch.GetLeaf();

        return(foundClip);
    }
                private void RenderLinksForState(StateEditorGUI state)
                {
                    StateMachineEditorLink[] links = state.GetEditableObject().GetEditorLinks();

                    if (links != null)
                    {
                        for (int j = 0; j < links.Length; j++)
                        {
                            StateRef stateRef = links[j].GetStateRef();

                            if (stateRef.IsInternal())
                            {
                                StateEditorGUI toState = FindStateForLink(stateRef);
                                RenderLink(links[j].GetDescription(), state, toState, j);
                            }
                            else
                            {
                                RenderExternalLink(links[j], state, j);
                            }
                        }
                    }
                }
Beispiel #26
0
            internal void SaveThis(ModelSaveContext ctx)
            {
                Host.CheckValue(ctx, nameof(ctx));
                ctx.CheckAtModel();

                Host.Assert(InitialWindowSize == 0);
                Host.Assert(Model != null);

                // *** Binary format ***
                // <base>
                // bool: _isAdaptive
                // int32: Horizon
                // State: StateRef
                // AdaptiveSingularSpectrumSequenceModeler: _model

                base.SaveModel(ctx);
                ctx.Writer.Write(IsAdaptive);
                ctx.Writer.Write(Horizon);
                ctx.Writer.Write(ConfidenceLevel);
                StateRef.Save(ctx.Writer);

                ctx.SaveModel(Model, "SSA");
            }
Beispiel #27
0
    /// <summary>
    /// Executes a command on the state machine, changing the state
    /// </summary>
    public void Execute(Command cmd, bool SkipTransition = false, bool ForceTransition = false)
    {
        StateRef e_nextState = i_currentState.GetNextState(cmd);
        bool     foundState  = l_validStates.TryGetValue(e_nextState, out i_currentState);

        if (!foundState)
        {
            Debug.Log("ERROR: State Not Found!");
            return;
        }

        // when pausing and unpausing, we want to skip the transition action as, in terms of game physics, the state shouldn't change
        if (SkipTransition)
        {
            sr_currentStateRef = e_nextState;
            return;
        }

        if (e_nextState != sr_currentStateRef || ForceTransition)
        {
            i_currentState.TransitionAct();
            sr_currentStateRef = e_nextState;
        }
    }
Beispiel #28
0
 /// <summary>
 /// Adds a new state to the list with a reference to the state.
 /// </summary>
 /// <returns><c>true</c>, if state was added</returns>
 /// <param name="newState">New state.</param>
 /// <param name="stateRef">State reference.</param>
 public bool AddState(iState newState, StateRef stateRef)
 {
     l_validStates.Add(stateRef, newState);
     return(true);
 }
Beispiel #29
0
		/// <summary>
		/// Gets an active stack frame with the specified state,
		/// or creates and adds one if there is none.
		/// </summary>
		/// <param name="state">The state to look for.</param>
		/// <returns>A <see cref="Frame"/> with the specified state.</returns>
		private Frame GetOrCreateActiveFrame(StateRef state)
		{
			#region Contract
			Contract.Ensures(Contract.Result<Frame>() != null);
			Contract.Ensures(Contract.Result<Frame>().State == state);
			#endregion

			var frame = GetActiveFrame(state);
			if (frame == null)
			{
				frame = new Frame(state);
				this.activeStacks.PushFront(frame);
			}
			return frame;
		}
Beispiel #30
0
		/// <summary>
		/// Gets the state that corresponds to the specified state reference.
		/// </summary>
		/// <param name="stateRef">The state reference.</param>
		/// <returns>The corresponding <see cref="State"/>.</returns>
		private State GetState(StateRef stateRef)
		{
			#region Contract
			Contract.Ensures(Contract.Result<State>() != null);
			#endregion

			return this.parseTable.States[stateRef.Index];
		}
Beispiel #31
0
 public StateDTree()
 {
     this.s_heldState = StateRef.ERROR_STATE;
     this.l_children  = new List <StateDTree>();
 }
		/// <summary>
		/// Parses the gotos from the parse table.
		/// </summary>
		/// <param name="listTerm">A list of goto terms.</param>
		/// <returns>The parsed gotos.</returns>
		/// <example>
		/// A goto term might look like this:
		/// <code>
		/// goto([range(9,10),13,32],21)
		/// </code>
		/// </example>
		private IReadOnlyList<Goto> ParseGotos(IListTerm listTerm)
		{
			#region Contract
			Contract.Requires<ArgumentNullException>(listTerm != null);
			Contract.Ensures(Contract.Result<IReadOnlyList<Goto>>() != null);
			#endregion

			var result = new Goto[listTerm.Count];
			int index = 0;
			foreach (var term in from t in listTerm.SubTerms select t.ToCons("goto", 2))
			{
				var characters = ParseCharacterRanges((IListTerm)term[0]);
				var labels = ParseLabelRanges((IListTerm)term[0]);
				var nextState = new StateRef(term[1].ToInt32());

				result[index++] = new Goto(nextState, characters, labels);
			}

			return result;
		}
		/// <summary>
		/// Parses a shift action item.
		/// </summary>
		/// <param name="term">The term.</param>
		/// <returns>The parsed action item.</returns>
		/// <example>
		/// The term might look like this:
		/// <code>
		/// shift(22)
		/// </code>
		/// </example>
		private ActionItem ParseShift(IConsTerm term)
		{
			#region Contract
			Contract.Requires<ArgumentNullException>(term != null);
			Contract.Requires<ArgumentException>(term.IsCons("shift", 1));
			Contract.Ensures(Contract.Result<ActionItem>() != null);
			#endregion

			var nextState = new StateRef(term[0].ToInt32());

			return new ShiftActionItem(nextState);
		}
Beispiel #34
0
		/// <summary>
		/// Initializes a new instance of the <see cref="Frame"/> class.
		/// </summary>
		/// <param name="state">The current state.</param>
		public Frame(StateRef state)
		{
			this.State = state;
			this.Links = new Collection<Link>();
		}
Beispiel #35
0
                public static object PropertyField(object obj, GUIContent label, ref bool dataChanged, GUIStyle style, params GUILayoutOption[] options)
                {
                    StateRef state = (StateRef)obj;

                    if (label == null)
                    {
                        label = new GUIContent();
                    }

                    label.text += " (" + state + ")";

                    bool editorCollapsed = !EditorGUILayout.Foldout(!state._editorCollapsed, label);

                    if (editorCollapsed != state._editorCollapsed)
                    {
                        state._editorCollapsed = editorCollapsed;
                        dataChanged            = true;
                    }

                    if (!editorCollapsed)
                    {
                        int origIndent = EditorGUI.indentLevel;
                        EditorGUI.indentLevel++;


                        EditorGUI.BeginChangeCheck();
                        eType type = (eType)EditorGUILayout.EnumPopup("Link Type", state.IsInternal() ? eType.Internal : eType.External);
                        if (EditorGUI.EndChangeCheck())
                        {
                            //If type has changed create a new ref with file set to null if internal or a blank asset ref if external.
                            state       = new StateRef(type == eType.External ? -1 : 0, state.GetParentStateMachine());
                            dataChanged = true;
                        }

                        switch (type)
                        {
                        case eType.Internal:
                        {
                            StateMachine stateMachine = state.GetParentStateMachine();
                            if (stateMachine != null)
                            {
                                int stateId = state.GetStateID();

                                //If changed state id create new state ref
                                if (DrawStateNamePopUps(stateMachine._states, ref stateId))
                                {
                                    state       = new StateRef(stateId, stateMachine);
                                    dataChanged = true;
                                }
                            }
                        }
                        break;

                        case eType.External:
                        {
                            TextAsset asset = EditorGUILayout.ObjectField("File", state.GetExternalFile()._editorAsset, typeof(TextAsset), false) as TextAsset;

                            //If asset changed update GUIDS
                            if (state.GetExternalFile()._editorAsset != asset)
                            {
                                state       = new StateRef(asset, -1, state.GetParentStateMachine());
                                dataChanged = true;
                            }

                            if (asset != null)
                            {
                                StateMachine stateMachines = Serializer.FromFile <StateMachine>(AssetDatabase.GetAssetPath(asset));
                                int          stateId       = state.GetStateID();

                                if (DrawStateNamePopUps(stateMachines._states, ref stateId))
                                {
                                    state       = new StateRef(asset, stateId, state.GetParentStateMachine());
                                    dataChanged = true;
                                }
                            }
                        }
                        break;
                        }

                        EditorGUI.indentLevel = origIndent;
                    }

                    return(state);
                }
Beispiel #36
0
 public BeforeInvokeArgs(PipeInvocation invocation, StateRef stateRef)
 {
     _stateRef  = stateRef;
     Invocation = invocation;
 }
Beispiel #37
0
 public PreStartState(StateRef nextStateIn)
 {
     this.nextState = nextStateIn;
 }
Beispiel #38
0
		/// <summary>
		/// Gets an active stack frame with the specified state.
		/// </summary>
		/// <param name="state">The state to look for.</param>
		/// <returns>A <see cref="Frame"/> with the specified state;
		/// or <see langword="null"/> when not found.</returns>
		private Frame GetActiveFrame(StateRef state)
		{
			#region Contract
			Contract.Ensures(Contract.Result<Frame>() == null || Contract.Result<Frame>().State == state);
			#endregion

			return this.activeStacks.FirstOrDefault(f => f.State == state);
		}
Beispiel #39
0
		/// <summary>
		/// Initializes a new instance of the <see cref="ShiftActionItem"/> class.
		/// </summary>
		/// <param name="nextState">Reference to the next state.</param>
		public ShiftActionItem(StateRef nextState)
		{
			this.NextState = nextState;
		}
Beispiel #40
0
		// TODO: Can currentToken be removed?
		/// <summary>
		/// Enqueues the specified stack frame and next state for the shifter.
		/// </summary>
		/// <param name="stack">The current stack frame.</param>
		/// <param name="nextState">The next state.</param>
		/// <param name="currentToken">The current token.</param>
		public void EnqueueForShifter(Frame stack, StateRef nextState, CodePoint currentToken)
		{
			#region Contract
			Contract.Requires<ArgumentNullException>(stack != null);
			Contract.Requires<ArgumentNullException>(nextState != null);
			#endregion
			this.forShifter.PushFront(new ActionState(stack, nextState, currentToken));
		}
Beispiel #41
0
		/// <param name="st0"></param>
		/// <param name="nextState"></param>
		/// <param name="label"></param>
		/// <param name="kids">A list of trees.</param>
		/// <param name="path"></param>
		private void Reducer(Frame st0, StateRef nextState, LabelRef label, IReadOnlyList<IParseNode> kids, Path path)
		{
			var production = this.parseTable.Labels[label.Index].Production;

			Contract.Assert(!production.IsRecover);

			// t := application of a -> A to kids
			IParseNode t = ApplyProduction(production, kids, /* TODO */ 0, /* TODO */ 0, /* TODO */ false, /* TODO */ false);

			Frame st1 = GetActiveFrame(nextState);

			if (st1 != null)
			{
				// A stack with state nextState exists. Check for ambiguities.
				Link nl = st1.TryGetParentLink(st0);
				if (nl != null)
				{
					// There exists a direct link from st1 to st0.
					// TODO: Add `t` to the possiblities of the ambiguity node at `tree(nl)`
					if (production.IsReject)
						nl.Reject();

					// TODO: Can't modify a link.
					//nl.Label = t;
				}
				else
				{
					// There is no direct link from st1 to st0.
					nl = new Link(st0, t, path.Length);
					st1.Links.Add(nl);

					if (production.IsReject)
						nl.Reject();

					ActorOnActiveStacksOverNewLink(nl);
				}
			}
			else
			{
				// Found no existing stack frame with state nextState.
				st1 = new Frame(nextState);
				this.activeStacks.PushFront(st1);
				this.forActorDelayed.PushFront(st1);

				var nl = new Link(st0, t, path.Length);
				st1.Links.Add(nl);

				if (production.IsReject)
					nl.Reject();
			}
		}