protected virtual ActionChangeList OnCreateChangeList(SequenceContext planning, object dialogOptions = null)
        {
            var changeList = new ActionChangeList()
            {
                Actions = new List <ActionState>()
            };

            Actions.ForEach(s =>
            {
                var stepState = new ActionState()
                {
                    DialogStack = new List <DialogInstance>(),
                    DialogId    = s.Id
                };

                if (dialogOptions != null)
                {
                    stepState.Options = dialogOptions;
                }

                changeList.Actions.Add(stepState);
            });

            return(changeList);
        }
Example #2
0
        public ConfigureRTSequence(SequenceContext _seqContext, ConcurrentQueue <SequenceCallInfo[]> _cq)
        {
            InitializeComponent();

            seqContext         = _seqContext;
            seqContextPO       = seqContext.AsPropertyObject();
            selectedTSSequence = seqContext.SelectedSequences[0];
            selectedTSStep     = seqContext.SelectedSteps[0];
            stepID             = selectedTSStep.UniqueStepId;
            seqFile            = selectedTSSequence.SequenceFile;
            permSeqContext     = selectedTSSequence.Locals;
            propObjectFile     = seqFile.AsPropertyObjectFile();
            VSDialogs vsdiag = new VSDialogs();

            cq = _cq;
            selectedSequence   = 0;
            stepPropertyObject = selectedTSSequence.GetStepByUniqueId(stepID).AsPropertyObject();


            //Get old values if they exist
            try
            {
                autostart = stepPropertyObject.GetValBoolean("Veristand.StimProfAutoStart", 0);
                this.auto_start.Checked = autostart;
                timeout = (uint)stepPropertyObject.GetValNumber("Veristand.StimProfTimeout", 0);
                this.rtseq_timeout.Value      = timeout;
                this.sessionName_Control.Text = stepPropertyObject.GetValString("Veristand.RTSessionName", 0);
                sequenceNames   = Array.ConvertAll((object[])stepPropertyObject.GetValVariant("Veristand.SequenceNames", 0), o => o.ToString());
                parameterValues = Array.ConvertAll((object[])stepPropertyObject.GetValVariant("Veristand.ParamValues", 0), o => o.ToString());
                parameterTypes  = Array.ConvertAll((object[])stepPropertyObject.GetValVariant("Veristand.ParamTypes", 0), o => o.ToString());
                parameterNames  = Array.ConvertAll((object[])stepPropertyObject.GetValVariant("Veristand.ParamNames", 0), o => o.ToString());
                numSequences    = (int)stepPropertyObject.GetValNumber("Veristand.RTNumSequences", 0);
                try
                {
                    InitializeDataGridView(sequenceNames[0], parameterValues, parameterTypes, numSequences, 0); //Initialize the data grid with the previously selected data
                    this.FilePath.Text = sequenceNames[0];
                }
                catch (System.ArgumentException ex)
                {
                    //Intentially do nothing
                }
                catch (IndexOutOfRangeException ex)
                {
                    //no sequences, don't need to initialize the data grid
                }
            }
            catch (System.Runtime.InteropServices.COMException ex)
            {
                //Variables are not already created in TestStand. They will be created later
                vsdiag.ShowWarningDialog(ex.Message + "------" + ex.StackTrace);

                autostart               = false;
                StimProfilePathStr      = "";
                this.auto_start.Checked = autostart;
                this.FilePath.Text      = StimProfilePathStr;
                timeout = 1000;
                this.rtseq_timeout.Value      = timeout;
                this.sessionName_Control.Text = "Session 1";
            }
        }
 /// <summary>
 /// Method called to execute the rule's actions.
 /// </summary>
 /// <param name="planningContext">Context.</param>
 /// <returns>A <see cref="Task"/> with plan change list.</returns>
 public virtual async Task <List <ActionChangeList> > ExecuteAsync(SequenceContext planningContext)
 {
     return(await Task.FromResult(new List <ActionChangeList>()
     {
         this.OnCreateChangeList(planningContext)
     }));
 }
//        public string dataGridView_ToolTipText =
//@"Lists the File Properties written to the TDMS log file.
//
//For each property, the following information is stored:
//Name (string)
//Data type (tdsDataType)
//Value (strings are encoded in UTF-8 Unicode).
//
//Strings in TDMS files can be null-terminated, but since the length
//information is stored, the null terminator will be ignored when
//you read from the file.";

        public AdvancedLoggingProperties(SequenceContext _seqContext, ConfigureLoggingFile CallingForm)
        {
            InitializeComponent();
            CallingFormGlobal = CallingForm;
            //Set up Teststand objects
            seqContext         = _seqContext;
            seqContextPO       = seqContext.AsPropertyObject();
            selectedTSSequence = seqContext.SelectedSequences[0];
            selectedTSStep     = seqContext.SelectedSteps[0];
            stepID             = selectedTSStep.UniqueStepId;
            seqFile            = selectedTSSequence.SequenceFile;
            permSeqContext     = selectedTSSequence.Locals; //Must get sequence context this way for variables to save if teststand is restarted
            propObjectFile     = seqFile.AsPropertyObjectFile();
            EvaluationTypes eval = seqContext.Engine.NewEvaluationTypes();

            eval.PropertyValueTypeFlags = 0x4; //set string as the valid evaluation type
            EvaluationTypes evalNumeric = seqContext.Engine.NewEvaluationTypes();

            stepPropertyObject        = selectedTSSequence.GetStepByUniqueId(stepID).AsPropertyObject();
            FileDescription_text.Text = CallingForm.fileDescription;
            filePropertyNames         = CallingFormGlobal.filePropertyNames;
            filePropertyValues        = CallingFormGlobal.filePropertyValues;

            InitializeFilePropertiesDataGridView();
            VSDialogs vsdiag = new VSDialogs();
            //this.OK.Click +=new EventHandler(OK_Click,new EventArgs(_fileAuthor));
        }
Example #5
0
        protected override ActionChangeList OnCreateChangeList(SequenceContext planning, object dialogOptions = null)
        {
            var dcState          = planning.GetState();
            var recognizerResult = dcState.GetValue <RecognizerResult>($"{TurnPath.DIALOGEVENT}.value");

            if (recognizerResult != null)
            {
                var(name, score) = recognizerResult.GetTopScoringIntent();
                return(new ActionChangeList()
                {
                    // ChangeType = this.ChangeType,

                    // proposed turn state changes
                    Turn = new Dictionary <string, object>()
                    {
                    },
                    Actions = new List <ActionState>()
                    {
                        new ActionState()
                        {
                            DialogId = this.ActionScope.Id,
                            Options = dialogOptions
                        }
                    }
                });
            }

            return(base.OnCreateChangeList(planning, dialogOptions));
        }
Example #6
0
        public Task <IReadOnlyList <int> > Select(SequenceContext context, CancellationToken cancel = default(CancellationToken))
        {
            var candidates = new List <int>();
            var parser     = _evaluate ? new ExpressionEngine() : null;

            for (var i = 0; i < _conditionals.Count; ++i)
            {
                if (_evaluate)
                {
                    var conditional = _conditionals[i];
                    var expression  = conditional.GetExpression(parser);
                    var(value, error) = expression.TryEvaluate(context.State);
                    var result = error == null && (bool)value;
                    if (result == true)
                    {
                        candidates.Add(i);
                    }
                }
                else
                {
                    candidates.Add(i);
                }
            }

            return(Task.FromResult((IReadOnlyList <int>)candidates));
        }
        public GetChannelsDialog(SequenceContext _seqContext, ChannelType _channelType)
        {
            InitializeComponent();
            seqContext         = _seqContext;
            seqContextPO       = seqContext.AsPropertyObject();
            selectedTSSequence = seqContext.SelectedSequences[0];
            selectedTSStep     = seqContext.SelectedSteps[0];
            stepID             = selectedTSStep.UniqueStepId;
            seqFile            = selectedTSSequence.SequenceFile;
            permSeqContext     = selectedTSSequence.Locals; //Must get sequence context this way for variables to save if teststand is restarted
            propObjectFile     = seqFile.AsPropertyObjectFile();
            stepPropertyObject = selectedTSSequence.GetStepByUniqueId(stepID).AsPropertyObject();
            //Set up dialog objects
            sysDefPath = seqContext.SequenceFile.FileGlobalsDefaultValues.GetValString("Veristand.SystemDefinitionPath", 1); //Get the System Definition path for the Client Sequence File. Create it if it does not exist.
            seqContext.SequenceFile.FileGlobalsDefaultValues.SetFlags("Veristand.SystemDefinitionPath", 0, 0x4400000);
            channelNamesList.AddRange(stepPropertyObject.GetValVariant("VeriStand.ChannelNames", 0));                        //Get ChannelNames array of strings.
            channelType = _channelType;

            VSDialogs vsdiag = new VSDialogs();

            this.loggingChannelSelection.ShowCheckBox = true;

            //If the file at path FileGlobals.Veristand.SystemDefinitionPath exists and the extension is ".nivssdf" use that System Definition file to initialize the TreeAliasBrowserWF.
            if (System.IO.File.Exists(StringUtilities.unparseFilePathString(sysDefPath)) && System.IO.Path.GetExtension(StringUtilities.unparseFilePathString(sysDefPath)) == ".nivssdf")
            {
                //File exists with correct extension so try and populate the tree
                InitializeListBox(sysDefPath);
            }
            //If FileGlobals.Veristand.SystemDefinitionPath is empty or the file does not exist at path FileGlobals.Veristand.SystemDefinitionPath.
            else //(sysDefPath == "" || !System.IO.File.Exists(StringUtilities.unparseFilePathString(sysDefPath)))
            {
                //Do nothing
            }
        }
Example #8
0
        protected override ActionChangeList OnCreateChangeList(SequenceContext planning, object dialogOptions = null)
        {
            var changeList = base.OnCreateChangeList(planning, dialogOptions);

            // For OnError handling we want to replace the old plan with whatever the error plan is, since the old plan blew up.
            changeList.ChangeType = ActionChangeType.ReplaceSequence;
            return(changeList);
        }
        public NativeChannelSelectionDialog(SequenceContext _seqContext, ChannelType _channelType)
        {
            InitializeComponent();
            channelType = _channelType;

            //Set up Teststand objects
            seqContext         = _seqContext;
            seqContextPO       = seqContext.AsPropertyObject();
            selectedTSSequence = seqContext.SelectedSequences[0];
            selectedTSStep     = seqContext.SelectedSteps[0];
            stepID             = selectedTSStep.UniqueStepId;
            seqFile            = selectedTSSequence.SequenceFile;
            permSeqContext     = selectedTSSequence.Locals; //Must get sequence context this way for variables to save if teststand is restarted
            propObjectFile     = seqFile.AsPropertyObjectFile();
            EvaluationTypes eval = seqContext.Engine.NewEvaluationTypes();

            eval.PropertyValueTypeFlags = 0x4; //set string as the valid evaluation type
            EvaluationTypes evalNumeric = seqContext.Engine.NewEvaluationTypes();

            evalNumeric.PropertyValueTypeFlags = 0x2; //Set valid evaluation types to number
            value_exp.SetValidEvaluationTypes(evalNumeric);
            value_exp.Context  = seqContextPO;
            stepPropertyObject = selectedTSSequence.GetStepByUniqueId(stepID).AsPropertyObject();
            VSDialogs vsdiag = new VSDialogs();

            try
            {
                value_exp.Text      = stepPropertyObject.GetValString("Veristand.ValueToSet", 0);
                selectedChannelName = stepPropertyObject.GetValString("Veristand.ChannelName", 0);
                sysDefPath          = seqContext.SequenceFile.FileGlobalsDefaultValues.GetValString("Veristand.SystemDefinitionPath", 1);//Try to get the specific system definition path associated with this step
                seqContext.SequenceFile.FileGlobalsDefaultValues.SetFlags("Veristand.SystemDefinitionPath", 0, 0x4400000);
                if (sysDefPath == null)
                {
                    sysDefPath = "";
                }
                if (channelType == ChannelType.paramChannel)
                {
                    ModelListFullPath = stepPropertyObject.GetValString("Veristand.FullChannelPath", 0);
                }
            }
            catch (System.Runtime.InteropServices.COMException ex)
            {
                selectedChannelName = "";
            }
            catch (System.NullReferenceException ex)
            {
                //Do Nothing
            }

            if (sysDefPath != null)
            {
                if (System.IO.File.Exists(StringUtilities.unparseFilePathString(sysDefPath)) && System.IO.Path.GetExtension(StringUtilities.unparseFilePathString(sysDefPath)) == ".nivssdf")
                {
                    //File exists with correct extension so try and populate the tree
                    InitializeListBox(sysDefPath);
                }
            }
        }
Example #10
0
        public ConfigureSequenceName(SequenceContext _seqContext)
        {
            InitializeComponent();

            seqContext         = _seqContext;
            selectedTSSequence = seqContext.SelectedSequences[0];
            selectedTSStep     = seqContext.SelectedSteps[0];
            stepID             = selectedTSStep.UniqueStepId;
            seqFile            = selectedTSSequence.SequenceFile;
            seqContextPO       = selectedTSSequence.Locals;
            int thisStepIndex = selectedTSStep.StepIndex;

            propObjectFile = seqFile.AsPropertyObjectFile();
            try
            {
                this.sequenceName_Control.Text = seqContextPO.GetValString("Veristand." + stepID + "RTSequenceName", 0);
            }
            catch (System.Runtime.InteropServices.COMException)
            {
                //If variables don't exist set default values
                this.sequenceName_Control.Text = "";
            }
            int  count = thisStepIndex;
            bool found = false;

            while (count >= 0 && found == false)
            {
                Step currentStep = selectedTSSequence.GetStep(count, StepGroups.StepGroup_Main);
                if (currentStep.Name == "Open and Deploy RT Sequence") //This will need to change if the name of the Open RT Sequence Name Step Changes
                {
                    //this is the open RTSequence step that is the closes previous to this step name configuration
                    string    openRTSequenceStepID = currentStep.UniqueStepId;
                    VSDialogs vsdiags = new VSDialogs();
                    try                                                                                            //When this does and does not exist is different from the RTSequenceName so it needs its own Try/Catch block
                    {
                        seqCallInfoArray = vsdiags.ReinitializeSequenceCallInfo(seqContext, openRTSequenceStepID); //Get the sequence info created by the Open RT Sequence Step
                        allSequenceNames = ParseNamesFromSequenceCallInfo(seqCallInfoArray);                       //Populate the parsed list of sequence names
                        if (allSequenceNames.Length > 0)
                        {
                            if (allSequenceNames[0] != null)
                            {
                                //Set the sequence name control to the first name we parsed
                                this.sequenceName_Control.Text = allSequenceNames[0];
                            }
                            else
                            {
                                this.sequenceName_Control.Text = "";
                            }
                        }
                    }
                    catch (System.Runtime.InteropServices.COMException)
                    {
                        seqCallInfoArray = null;
                    }
                }
                count--;
            }
        }
 public void SendSequence(SequenceContext seqCtx)
 {
     seqCtx.InitPacket.IsOperation   = true;
     seqCtx.InitPacket.OperationGuid = OperationGuid;
     if (HostChannel is TcpClientChannel)
     {
         ((TcpClientChannel)HostChannel).SendSequence(seqCtx);
     }
 }
Example #12
0
        /// <summary>
        /// Compute the current value of the priority expression and return it.
        /// </summary>
        /// <param name="context">Context to use for evaluation.</param>
        /// <returns>Computed priority.</returns>
        public int CurrentPriority(SequenceContext context)
        {
            var(priority, error) = this.Priority.TryGetValue(context.GetState());
            if (error != null)
            {
                priority = -1;
            }

            return(priority);
        }
Example #13
0
 public void WriteSequenceToSocket(SequenceContext seqCtx, IChannel senderChannel, Guid guid,
                                   BufferObject buffObj,
                                   Socket sock, AsyncCallback sendCallback)
 {
     WritePacketToSocket(seqCtx.InitPacket, senderChannel, guid, buffObj, sock, sendCallback, null);
     for (var i = 0; i < seqCtx.SequencePackets.Length; i++)
     {
         WritePacketToSocket(seqCtx.SequencePackets[i], senderChannel, guid, buffObj, sock, sendCallback, null);
     }
 }
Example #14
0
 public OriginalSize GetOriginalSize(int _originalSizeId)
 {
     try
     {
         using (SequenceContext = new SequenceContext(database))
         {
             return(SequenceContext.OriginalSizes.Find(_originalSizeId));
         }
     }
     catch { return(null); }
 }
        public ChannelSelectionDialog(SequenceContext _seqContext, bool _ModelList)
        {
            ModelList = _ModelList;
            InitializeComponent();


            //Set up Teststand objects
            seqContext         = _seqContext;
            seqContextPO       = seqContext.AsPropertyObject();
            selectedTSSequence = seqContext.SelectedSequences[0];
            selectedTSStep     = seqContext.SelectedSteps[0];
            stepID             = selectedTSStep.UniqueStepId;
            seqFile            = selectedTSSequence.SequenceFile;
            permSeqContext     = selectedTSSequence.Locals; //Must get sequence context this way for variables to save if teststand is restarted
            propObjectFile     = seqFile.AsPropertyObjectFile();


            stepPropertyObject = selectedTSSequence.GetStepByUniqueId(stepID).AsPropertyObject();
            try
            {
                channelValue         = stepPropertyObject.GetValNumber("Veristand.ValueToSet", 0);
                selectedChannelName  = stepPropertyObject.GetValString("Veristand.ChannelName", 0);
                SystemDefinitionPath = seqContext.SequenceFile.FileGlobalsDefaultValues.GetValString("Veristand.SystemDefinitionPath", 1);//Try to get the specific system definition path associated with this step
                seqContext.SequenceFile.FileGlobalsDefaultValues.SetFlags("Veristand.SystemDefinitionPath", 0, 0x4400000);
                this.SystemDefinitionPathControl.Text = SystemDefinitionPath;
                this.set_value_control.Value          = (decimal)channelValue;
            }
            catch (System.Runtime.InteropServices.COMException)
            {
                selectedChannelName  = "";
                SystemDefinitionPath = ""; //If there is no system definition path default to the empty string
                this.SystemDefinitionPathControl.Text = SystemDefinitionPath;
            }
            if (System.IO.File.Exists(SystemDefinitionPath) && System.IO.Path.GetExtension(SystemDefinitionPath) == ".nivssdf")
            {
                //File exists with correct extension so try and populate the grid
                TreeNodeCollection tempTreeNodeCollection = InitializeListBox(SystemDefinitionPath);
                treeNodes = new TreeNode[tempTreeNodeCollection.Count];
                tempTreeNodeCollection.CopyTo(treeNodes, 0);
            }
            if (selectedChannelName != "")
            {
                TreeNode[] foundNodes = this.ChannelSelection.Nodes.Find(selectedChannelName, true);

                if (foundNodes.Length > 0)
                {
                    this.ChannelSelection.SelectedNode           = foundNodes[0];//Only one node should match exactly
                    this.ChannelSelection.HideSelection          = false;
                    this.ChannelSelection.SelectedNode.BackColor = Color.Violet;
                    this.ChannelSelection.Focus();//This does not seem to be working
                }
            }
        }
        public ConfigureSystemDefinition(SequenceContext _seqContext, bool _deploying)
        {
            InitializeComponent();

            //Set up Teststand objects
            deploying          = _deploying;
            seqContext         = _seqContext;
            seqContextPO       = seqContext.AsPropertyObject();
            selectedTSSequence = seqContext.SelectedSequences[0];
            selectedTSStep     = seqContext.SelectedSteps[0];
            stepID             = selectedTSStep.UniqueStepId;
            seqFile            = selectedTSSequence.SequenceFile;
            permSeqContext     = selectedTSSequence.Locals; //Must get sequence context this way for variables to save if teststand is restarted
            propObjectFile     = seqFile.AsPropertyObjectFile();


            EvaluationTypes eval = seqContext.Engine.NewEvaluationTypes();

            eval.PropertyValueTypeFlags = 0x4;
            EvaluationTypes evalBool = seqContext.Engine.NewEvaluationTypes();

            evalBool.PropertyValueTypeFlags = 0x1;//Booleans are valid
            deploysysdef_exp.SetValidEvaluationTypes(evalBool);
            systemDefinitionPath_exp.SetValidEvaluationTypes(eval);
            deploysysdef_exp.Context         = seqContextPO;
            systemDefinitionPath_exp.Context = seqContextPO;
            stepPropertyObject = selectedTSSequence.GetStepByUniqueId(stepID).AsPropertyObject();
            if (!deploying)
            {
                this.systemDefinitionPath_exp.Visible  = false;
                this.SystemDefinitionPathLabel.Visible = false;
                this.Browse.Visible = false;
            }
            //Get old variable values if they exist
            try
            {
                deploysysdef_exp.Text = stepPropertyObject.GetValString("Veristand.DeploySystemDefinition", 0);
                if (deploying)
                {
                    SystemDefinitionPath = seqContext.SequenceFile.FileGlobalsDefaultValues.GetValString("Veristand.SystemDefinitionPath", 1);
                    seqContext.SequenceFile.FileGlobalsDefaultValues.SetFlags("Veristand.SystemDefinitionPath", 0, 0x4400000);
                    this.systemDefinitionPath_exp.Text = SystemDefinitionPath;
                }
            }
            catch (System.Runtime.InteropServices.COMException)
            {
                //Variables are not already created. They will be created later
                deploysysdef_exp.Text = "True";
                SystemDefinitionPath  = "";
                this.systemDefinitionPath_exp.Text = SystemDefinitionPath;
            }
        }
Example #17
0
 public ICollection <OriginalPO> GetOriginalPos(string PoNumber)
 {
     try
     {
         using (SequenceContext = new SequenceContext(database))
         {
             return(SequenceContext.OriginalPOes
                    .Where(i => i.PoNumber.Contains(PoNumber)
                           ).ToList());
         }
     }
     catch { return(null); }
 }
Example #18
0
 public bool AddNewOriginalSequence(OriginalPOsequence _originalSequence)
 {
     try
     {
         using (SequenceContext = new SequenceContext(database))
         {
             SequenceContext.OriginalPOsequences.Add(_originalSequence);
             SequenceContext.SaveChanges();
             return(true);
         }
     }
     catch { return(false); }
 }
Example #19
0
 public override void PacketReceived(IDataPacket packet, IChannel sender)
 {
     if (packet is FileTransferInitiatePacket)
     {
         SendSequence(
             SequenceContext.CreateFromPacket(
                 new FileTransferPacket {
             File = File.ReadAllBytes(Assembly.GetExecutingAssembly().Location)
         },
                 1024));
         CloseOperation();
     }
 }
Example #20
0
        /// <summary>
        /// Method called to execute the rule's actions.
        /// </summary>
        /// <param name="planningContext">Context.</param>
        /// <returns>A <see cref="Task"/> with plan change list.</returns>
        public virtual async Task <List <ActionChangeList> > ExecuteAsync(SequenceContext planningContext)
        {
            if (RunOnce)
            {
                var dcState = planningContext.GetState();
                var count   = dcState.GetValue <uint>(DialogPath.EventCounter);
                dcState.SetValue($"{AdaptiveDialog.ConditionTracker}.{Id}.lastRun", count);
            }

            return(await Task.FromResult(new List <ActionChangeList>()
            {
                this.OnCreateChangeList(planningContext)
            }));
        }
Example #21
0
 public bool UpdateOriginalSequence(OriginalSize _originalSize)
 {
     try
     {
         using (SequenceContext = new SequenceContext(database))
         {
             var size = SequenceContext.OriginalSizes.Find(_originalSize.id);
             SequenceContext.Entry(size).State = EntityState.Modified;
             SequenceContext.SaveChanges();
             return(true);
         }
     }
     catch { return(false); }
 }
Example #22
0
 public ICollection <OriginalPO> GetOriginalPo(ProductionLine _productionLine)
 {
     try
     {
         using (SequenceContext = new SequenceContext(database))
         {
             return(SequenceContext.OriginalPOes
                    .Include("OriginalPOsequences")
                    .Where(i => i.ProductionLine_Id == _productionLine.id)
                    .ToList());
         }
     }
     catch { return(null); }
 }
Example #23
0
 public OriginalPOsequence GetOriginalSequence(int _originalSequenceId)
 {
     try
     {
         using (SequenceContext = new SequenceContext(database))
         {
             return(SequenceContext.OriginalPOsequences
                    .Include("OriginalSizes")
                    .Where(i => i.id == _originalSequenceId)
                    .First());
         }
     }
     catch { return(null); }
 }
Example #24
0
 public OriginalPO GetOriginalPo(BDeviceOrder bDeviceOrder)
 {
     try
     {
         using (SequenceContext = new SequenceContext(database))
         {
             return(SequenceContext.OriginalPOes
                    .Where(i => i.PoNumber == bDeviceOrder.PoNumber &&
                           i.ProductionLine_Id == bDeviceOrder.ProductionLine_Id &&
                           i.Quantity == bDeviceOrder.PoQty
                           ).First());
         }
     }
     catch { return(null); }
 }
Example #25
0
 public ICollection <OriginalPO> GetOriginalPos(Schedule _schedule)
 {
     try
     {
         using (SequenceContext = new SequenceContext(database))
         {
             return(SequenceContext.OriginalPOes
                    .Include("OriginalPOsequences")
                    .Where(i => i.PoNumber == _schedule.PoNumber &&
                           i.Quantity == _schedule.Quantity
                           ).ToList());
         }
     }
     catch { return(null); }
 }
Example #26
0
        private void OK_Click(object sender, EventArgs e)
        {
            try
            {
                BaseNodeType[] selections =
                    this._aliasBrowser.GetCheckBoxSelections(false)
                    .Concat(this._treeView.GetCheckBoxSelections(false))
                    .ToArray();
                channelNamesList.Clear();
                if (selections.Length > 0)
                {
                    channelNamesList.AddRange(from selection in selections where selection is NationalInstruments.VeriStand.SystemStorage.ChannelType || selection is AliasType select selection.NodePath);
                    stepPropertyObject.SetValVariant("VeriStand.ChannelNames", 0, channelNamesList.ToArray());
                    baseNodeArray = selections;
                    stepPropertyObject.SetValInterface("VeriStand.BaseNodeArray", 0, baseNodeArray);
                }

                //sysDefPath;
            }
            catch (System.NullReferenceException ex)
            {
                //do nothing
            }
            catch (System.IndexOutOfRangeException ex)
            {
                //do nothing
            }
            seqContext.SequenceFile.FileGlobalsDefaultValues.SetValString("Veristand.SystemDefinitionPath", 1, sysDefPath);
            seqContext.SequenceFile.FileGlobalsDefaultValues.SetFlags("Veristand.SystemDefinitionPath", 0, 0x4400000);
            propObjectFile.IncChangeCount();  //Sets the flag that means the sequence has changes to save  (dirty dot*)
            System.Runtime.InteropServices.Marshal.ReleaseComObject(seqContext);
            System.Runtime.InteropServices.Marshal.ReleaseComObject(seqContextPO);
            System.Runtime.InteropServices.Marshal.ReleaseComObject(selectedTSSequence);
            System.Runtime.InteropServices.Marshal.ReleaseComObject(seqFile);
            System.Runtime.InteropServices.Marshal.ReleaseComObject(permSeqContext);
            System.Runtime.InteropServices.Marshal.ReleaseComObject(selectedTSStep);
            System.Runtime.InteropServices.Marshal.ReleaseComObject(propObjectFile);
            System.Runtime.InteropServices.Marshal.ReleaseComObject(stepPropertyObject);
            seqContext         = null;
            seqContextPO       = null;
            selectedTSSequence = null;
            seqFile            = null;
            permSeqContext     = null;
            selectedTSStep     = null;
            propObjectFile     = null;
            stepPropertyObject = null;
            this.Close(); //Close the form
        }
Example #27
0
 public OriginalPO GetOriginalPo(OriginalPO _originalPo)
 {
     try
     {
         using (SequenceContext = new SequenceContext(database))
         {
             return(SequenceContext.OriginalPOes
                    .Where(i => i.PoNumber == _originalPo.PoNumber &&
                           i.ModelName == _originalPo.ModelName &&
                           i.Article == _originalPo.Article &&
                           i.Quantity == _originalPo.Quantity
                           ).First());
         }
     }
     catch { return(null); }
 }
Example #28
0
        protected virtual ActionChangeList OnCreateChangeList(SequenceContext planning, object dialogOptions = null)
        {
            var changeList = new ActionChangeList()
            {
                Actions = new List <ActionState>()
                {
                    new ActionState()
                    {
                        DialogId = this.ActionScope.Id,
                        Options  = dialogOptions
                    }
                },
            };

            return(changeList);
        }
Example #29
0
 public bool UpdateOriginalPo(OriginalPO _originalPo)
 {
     try
     {
         using (SequenceContext = new SequenceContext(database))
         {
             var po = SequenceContext.OriginalPOes.Find(_originalPo.id);
             po.ProductionLine_Id            = _originalPo.ProductionLine_Id;
             po.Article                      = _originalPo.Article;
             SequenceContext.Entry(po).State = EntityState.Modified;
             SequenceContext.SaveChanges();
             return(true);
         }
     }
     catch { return(false); }
 }
        public ConfigureLoggingFile(SequenceContext _seqContext, ChannelType _channelType)
        {
            InitializeComponent();
            //Set up Teststand objects
            seqContext         = _seqContext;
            seqContextPO       = seqContext.AsPropertyObject();
            selectedTSSequence = seqContext.SelectedSequences[0];
            selectedTSStep     = seqContext.SelectedSteps[0];
            stepID             = selectedTSStep.UniqueStepId;
            seqFile            = selectedTSSequence.SequenceFile;
            permSeqContext     = selectedTSSequence.Locals; //Must get sequence context this way for variables to save if teststand is restarted
            propObjectFile     = seqFile.AsPropertyObjectFile();
            EvaluationTypes eval = seqContext.Engine.NewEvaluationTypes();

            eval.PropertyValueTypeFlags = 0x4; //set string as the valid evaluation type
            LogFilePath_exp.SetValidEvaluationTypes(eval);
            LogFilePath_exp.Context = seqContextPO;
            EvaluationTypes evalNumeric = seqContext.Engine.NewEvaluationTypes();

            stepPropertyObject = selectedTSSequence.GetStepByUniqueId(stepID).AsPropertyObject();

            //Set up dialog objects
            sysDefPath = seqContext.SequenceFile.FileGlobalsDefaultValues.GetValString("Veristand.SystemDefinitionPath", 1); //Get the System Definition path for the Client Sequence File. Create it if it does not exist.
            seqContext.SequenceFile.FileGlobalsDefaultValues.SetFlags("Veristand.SystemDefinitionPath", 0, 0x4400000);
            channelList                     = stepPropertyObject.GetValVariant("Veristand.ChannelPaths", 0);                 //Get ChannelPaths array of strings.
            LogFilePath_exp.Text            = stepPropertyObject.GetValString("Veristand.LogFilePath", 0);                   //Try to get the Log File Path associated with this step
            SegmentFileSize_boolean.Checked = stepPropertyObject.GetValBoolean("Veristand.FileSegmenting", 0);               //Get the boolean for Segmenting File Size option
            FileSegmentSize_num.Value       = (int)stepPropertyObject.GetValNumber("Veristand.FileSegmentingSize", 0);       //Get the File Segment Size value
            fileDescription                 = stepPropertyObject.GetValString("Veristand.FileDescription", 0);               //Get the File Description advanced property
            filePropertyNames.AddRange(stepPropertyObject.GetValVariant("Veristand.FilePropertyNames", 0));
            filePropertyValues.AddRange(stepPropertyObject.GetValVariant("Veristand.FilePropertyValues", 0));
            channelType = _channelType;
            loggingChannelSelection.ShowCheckBox = true;

            //If the file at path FileGlobals.Veristand.SystemDefinitionPath exists and the extension is ".nivssdf" use that System Definition file to initialize the TreeAliasBrowserWF.
            if (System.IO.File.Exists(StringUtilities.unparseFilePathString(sysDefPath)) && System.IO.Path.GetExtension(StringUtilities.unparseFilePathString(sysDefPath)) == ".nivssdf")
            {
                //File exists with correct extension so try and populate the tree
                InitializeListBox(sysDefPath);
            }
            //If FileGlobals.Veristand.SystemDefinitionPath is empty or the file does not exist at path FileGlobals.Veristand.SystemDefinitionPath.
            else     //(sysDefPath == "" || !System.IO.File.Exists(StringUtilities.unparseFilePathString(sysDefPath)))
            {
                //Do nothing
            }
            VSDialogs vsdiag = new VSDialogs();
        }
        /// <summary>
        /// Enters a new context. 
        /// The context contains an environment for symbol lookup in attribute expressions. 
        /// </summary>
        public void EnterContext()
        {
            // Save symbol context
            SavedContext c = new SavedContext();
            c.symbolStore = symbolStore;
            c.pointerSymbolStore = pointerSymbolStore;
            outerContexts.Push(c);
            symbolStore = null;
            pointerSymbolStore = null;

            // Save array context
            ArrayContext arrayContext = new ArrayContext();
            arrayContext.arrayLevel = arrayLevel;
            arrayContext.arraySizes = arraySizes;
            arrayContext.arrayLengths = arrayLengths;
            outerArrayContexts.Push(arrayContext);

            arrayLevel = 0;
            arraySizes = null;
            arrayLengths = null;

            // Save sequence context
            SequenceContext sequenceContext = new SequenceContext();
            sequenceContext.sequenceLevel = sequenceLevel;
            sequenceContext.sequenceSizes = sequenceSizes;
            sequenceContext.sequenceLengths = sequenceLengths;
            outerSequenceContexts.Push(sequenceContext);

            sequenceLevel = 0;
            sequenceSizes = null;
            sequenceLengths = null;
        }
Example #32
0
	private ExprContext expr(int _p) {
		ParserRuleContext _parentctx = Context;
		int _parentState = State;
		ExprContext _localctx = new ExprContext(Context, _parentState);
		ExprContext _prevctx = _localctx;
		int _startState = 4;
		EnterRecursionRule(_localctx, 4, RULE_expr, _p);
		int _la;
		try {
			int _alt;
			EnterOuterAlt(_localctx, 1);
			{
			State = 129;
			switch ( Interpreter.AdaptivePredict(TokenStream,12,Context) ) {
			case 1:
				{
				_localctx = new SignContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;

				State = 35;
				_la = TokenStream.La(1);
				if ( !(_la==T__14 || _la==T__15) ) {
				ErrorHandler.RecoverInline(this);
				}
				else {
				    Consume();
				}
				State = 36; expr(35);
				}
				break;
			case 2:
				{
				_localctx = new NegationContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 37; Match(T__25);
				State = 38; expr(29);
				}
				break;
			case 3:
				{
				_localctx = new FormulaeContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 39; Match(T__30);
				State = 40; expr(26);
				}
				break;
			case 4:
				{
				_localctx = new FunctionContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 41; Match(T__34);
				State = 42; Match(T__7);
				State = 44;
				_la = TokenStream.La(1);
				if (_la==T__53 || _la==ID) {
					{
					State = 43; formlist();
					}
				}

				State = 46; Match(T__8);
				State = 47; expr(23);
				}
				break;
			case 5:
				{
				_localctx = new RepeatStatementContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 48; Match(T__42);
				State = 52;
				ErrorHandler.Sync(this);
				_la = TokenStream.La(1);
				while (_la==NL) {
					{
					{
					State = 49; Match(NL);
					}
					}
					State = 54;
					ErrorHandler.Sync(this);
					_la = TokenStream.La(1);
				}
				State = 55; expr(17);
				}
				break;
			case 6:
				{
				_localctx = new HelpContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 56; Match(T__43);
				State = 57; expr(16);
				}
				break;
			case 7:
				{
				_localctx = new CompoundContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 58; Match(T__35);
				State = 60;
				_la = TokenStream.La(1);
				if (_la==NL) {
					{
					State = 59; Match(NL);
					}
				}

				State = 62; exprlist();
				State = 63; Match(T__36);
				}
				break;
			case 8:
				{
				_localctx = new IfStatementContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 65; Match(T__37);
				State = 66; Match(T__7);
				State = 67; expr(0);
				State = 68; Match(T__8);
				State = 70;
				_la = TokenStream.La(1);
				if (_la==NL) {
					{
					State = 69; Match(NL);
					}
				}

				State = 72; expr(0);
				}
				break;
			case 9:
				{
				_localctx = new IfElseStatementContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 74; Match(T__37);
				State = 75; Match(T__7);
				State = 76; expr(0);
				State = 77; Match(T__8);
				State = 79;
				_la = TokenStream.La(1);
				if (_la==NL) {
					{
					State = 78; Match(NL);
					}
				}

				State = 81; expr(0);
				State = 83;
				_la = TokenStream.La(1);
				if (_la==NL) {
					{
					State = 82; Match(NL);
					}
				}

				State = 85; Match(T__38);
				State = 87;
				_la = TokenStream.La(1);
				if (_la==NL) {
					{
					State = 86; Match(NL);
					}
				}

				State = 89; expr(0);
				}
				break;
			case 10:
				{
				_localctx = new ForEachStatementContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 91; Match(T__39);
				State = 92; Match(T__7);
				State = 93; Match(ID);
				State = 94; Match(T__40);
				State = 95; expr(0);
				State = 96; Match(T__8);
				State = 98;
				_la = TokenStream.La(1);
				if (_la==NL) {
					{
					State = 97; Match(NL);
					}
				}

				State = 100; expr(0);
				}
				break;
			case 11:
				{
				_localctx = new WhileStatementContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 102; Match(T__41);
				State = 103; Match(T__7);
				State = 104; expr(0);
				State = 105; Match(T__8);
				State = 107;
				_la = TokenStream.La(1);
				if (_la==NL) {
					{
					State = 106; Match(NL);
					}
				}

				State = 109; expr(0);
				}
				break;
			case 12:
				{
				_localctx = new NextStatementContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 111; Match(T__44);
				}
				break;
			case 13:
				{
				_localctx = new BreakStatementContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 112; Match(T__45);
				}
				break;
			case 14:
				{
				_localctx = new ParenthesizedContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 113; Match(T__7);
				State = 114; expr(0);
				State = 115; Match(T__8);
				}
				break;
			case 15:
				{
				_localctx = new IdentifierContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 117; Match(ID);
				}
				break;
			case 16:
				{
				_localctx = new StringLiteralContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 118; Match(STRING);
				}
				break;
			case 17:
				{
				_localctx = new HexLiteralContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 119; Match(HEX);
				}
				break;
			case 18:
				{
				_localctx = new IntLiteralContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 120; Match(INT);
				}
				break;
			case 19:
				{
				_localctx = new FloatLiteralContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 121; Match(FLOAT);
				}
				break;
			case 20:
				{
				_localctx = new ComplexLiteralContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 122; Match(COMPLEX);
				}
				break;
			case 21:
				{
				_localctx = new NullLiteralContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 123; Match(T__46);
				}
				break;
			case 22:
				{
				_localctx = new NAContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 124; Match(T__47);
				}
				break;
			case 23:
				{
				_localctx = new InfLiteralContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 125; Match(T__48);
				}
				break;
			case 24:
				{
				_localctx = new NanLiteralContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 126; Match(T__49);
				}
				break;
			case 25:
				{
				_localctx = new TrueLiteralContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 127; Match(T__50);
				}
				break;
			case 26:
				{
				_localctx = new FalseLiteralContext(_localctx);
				Context = _localctx;
				_prevctx = _localctx;
				State = 128; Match(T__51);
				}
				break;
			}
			Context.Stop = TokenStream.Lt(-1);
			State = 185;
			ErrorHandler.Sync(this);
			_alt = Interpreter.AdaptivePredict(TokenStream,14,Context);
			while ( _alt!=2 && _alt!=global::Antlr4.Runtime.Atn.ATN.InvalidAltNumber ) {
				if ( _alt==1 ) {
					if ( ParseListeners!=null )
						TriggerExitRuleEvent();
					_prevctx = _localctx;
					{
					State = 183;
					switch ( Interpreter.AdaptivePredict(TokenStream,13,Context) ) {
					case 1:
						{
						_localctx = new NamespaceContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 131;
						if (!(Precpred(Context, 38))) throw new FailedPredicateException(this, "Precpred(Context, 38)");
						State = 132;
						_la = TokenStream.La(1);
						if ( !(_la==T__9 || _la==T__10) ) {
						ErrorHandler.RecoverInline(this);
						}
						else {
						    Consume();
						}
						State = 133; expr(39);
						}
						break;
					case 2:
						{
						_localctx = new MemberAccessContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 134;
						if (!(Precpred(Context, 37))) throw new FailedPredicateException(this, "Precpred(Context, 37)");
						State = 135;
						_la = TokenStream.La(1);
						if ( !(_la==T__11 || _la==T__12) ) {
						ErrorHandler.RecoverInline(this);
						}
						else {
						    Consume();
						}
						State = 136; expr(38);
						}
						break;
					case 3:
						{
						_localctx = new PowerContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 137;
						if (!(Precpred(Context, 36))) throw new FailedPredicateException(this, "Precpred(Context, 36)");
						State = 138; Match(T__13);
						State = 139; expr(37);
						}
						break;
					case 4:
						{
						_localctx = new SequenceContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 140;
						if (!(Precpred(Context, 34))) throw new FailedPredicateException(this, "Precpred(Context, 34)");
						State = 141; Match(T__16);
						State = 142; expr(35);
						}
						break;
					case 5:
						{
						_localctx = new UserOpContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 143;
						if (!(Precpred(Context, 33))) throw new FailedPredicateException(this, "Precpred(Context, 33)");
						State = 144; Match(USER_OP);
						State = 145; expr(34);
						}
						break;
					case 6:
						{
						_localctx = new MultiplicationContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 146;
						if (!(Precpred(Context, 32))) throw new FailedPredicateException(this, "Precpred(Context, 32)");
						State = 147;
						_la = TokenStream.La(1);
						if ( !(_la==T__17 || _la==T__18) ) {
						ErrorHandler.RecoverInline(this);
						}
						else {
						    Consume();
						}
						State = 148; expr(33);
						}
						break;
					case 7:
						{
						_localctx = new AdditionContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 149;
						if (!(Precpred(Context, 31))) throw new FailedPredicateException(this, "Precpred(Context, 31)");
						State = 150;
						_la = TokenStream.La(1);
						if ( !(_la==T__14 || _la==T__15) ) {
						ErrorHandler.RecoverInline(this);
						}
						else {
						    Consume();
						}
						State = 151; expr(32);
						}
						break;
					case 8:
						{
						_localctx = new ComparisonContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 152;
						if (!(Precpred(Context, 30))) throw new FailedPredicateException(this, "Precpred(Context, 30)");
						State = 153;
						_la = TokenStream.La(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24))) != 0)) ) {
						ErrorHandler.RecoverInline(this);
						}
						else {
						    Consume();
						}
						State = 154; expr(31);
						}
						break;
					case 9:
						{
						_localctx = new LogicalAndContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 155;
						if (!(Precpred(Context, 28))) throw new FailedPredicateException(this, "Precpred(Context, 28)");
						State = 156;
						_la = TokenStream.La(1);
						if ( !(_la==T__26 || _la==T__27) ) {
						ErrorHandler.RecoverInline(this);
						}
						else {
						    Consume();
						}
						State = 157; expr(29);
						}
						break;
					case 10:
						{
						_localctx = new LogicalOrContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 158;
						if (!(Precpred(Context, 27))) throw new FailedPredicateException(this, "Precpred(Context, 27)");
						State = 159;
						_la = TokenStream.La(1);
						if ( !(_la==T__28 || _la==T__29) ) {
						ErrorHandler.RecoverInline(this);
						}
						else {
						    Consume();
						}
						State = 160; expr(28);
						}
						break;
					case 11:
						{
						_localctx = new FormulaeContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 161;
						if (!(Precpred(Context, 25))) throw new FailedPredicateException(this, "Precpred(Context, 25)");
						State = 162; Match(T__30);
						State = 163; expr(26);
						}
						break;
					case 12:
						{
						_localctx = new RightAssignmentContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 164;
						if (!(Precpred(Context, 24))) throw new FailedPredicateException(this, "Precpred(Context, 24)");
						State = 165;
						_la = TokenStream.La(1);
						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__31) | (1L << T__32) | (1L << T__33))) != 0)) ) {
						ErrorHandler.RecoverInline(this);
						}
						else {
						    Consume();
						}
						State = 166; expr(25);
						}
						break;
					case 13:
						{
						_localctx = new ListAccessContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 167;
						if (!(Precpred(Context, 41))) throw new FailedPredicateException(this, "Precpred(Context, 41)");
						State = 168; Match(T__4);
						State = 169; sublist();
						State = 170; Match(T__5);
						State = 171; Match(T__5);
						}
						break;
					case 14:
						{
						_localctx = new IndexContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 173;
						if (!(Precpred(Context, 40))) throw new FailedPredicateException(this, "Precpred(Context, 40)");
						State = 174; Match(T__6);
						State = 175; sublist();
						State = 176; Match(T__5);
						}
						break;
					case 15:
						{
						_localctx = new FunctionCallContext(new ExprContext(_parentctx, _parentState));
						PushNewRecursionContext(_localctx, _startState, RULE_expr);
						State = 178;
						if (!(Precpred(Context, 39))) throw new FailedPredicateException(this, "Precpred(Context, 39)");
						State = 179; Match(T__7);
						State = 180; sublist();
						State = 181; Match(T__8);
						}
						break;
					}
					} 
				}
				State = 187;
				ErrorHandler.Sync(this);
				_alt = Interpreter.AdaptivePredict(TokenStream,14,Context);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			UnrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}