示例#1
0
        private void btnOK_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(txtDestinationField.Text))
            {
                MsgBox.ShowError("Destination field is blank.");
                this.DialogResult = DialogResult.None;
                return;
            }

            if (cbxFieldType.SelectedIndex == 1 && cbxFieldType.Text == "Numeric")
            {
                foreach (DataRow row in RecodeTable.Rows)
                {
                    string textValue = row["Representation"].ToString();
                    double value;
                    bool   success = double.TryParse(textValue, out value);
                    if (!success && !string.IsNullOrEmpty(textValue))
                    {
                        MsgBox.ShowError("The destination field type has been defined as numeric, but the destination values are not valid numbers.");
                        this.DialogResult = DialogResult.None;
                        return;
                    }
                }
            }

            if (!editMode)
            {
                ColumnDataType columnDataType = ColumnDataType.Boolean | ColumnDataType.Numeric | ColumnDataType.Text;
                foreach (string s in dashboardHelper.GetFieldsAsList(columnDataType))
                {
                    if (txtDestinationField.Text.ToLowerInvariant().Equals(s.ToLowerInvariant()))
                    {
                        MsgBox.ShowError("Destination field name already exists as a column in this data set. Please use another name.");
                        this.DialogResult = DialogResult.None;
                        return;
                    }
                }

                foreach (IDashboardRule rule in dashboardHelper.Rules)
                {
                    if (rule is DataAssignmentRule)
                    {
                        DataAssignmentRule assignmentRule = rule as DataAssignmentRule;
                        if (txtDestinationField.Text.ToLowerInvariant().Equals(assignmentRule.DestinationColumnName.ToLowerInvariant()))
                        {
                            MsgBox.ShowError("Destination field name already exists as a defined field with recoded values. Please use another field name.");
                            this.DialogResult = DialogResult.None;
                            return;
                        }
                    }
                }
            }

            string friendlyRule     = "Recode the values in " + sourceColumnName + " to " + txtDestinationField.Text + "";
            string sourceColumnType = dashboardHelper.GetColumnType(sourceColumnName);

            RecodeRule = new Rule_Recode(this.DashboardHelper, friendlyRule, sourceColumnName, sourceColumnType, txtDestinationField.Text, DestinationFieldType, RecodeTable, txtElseValue.Text, checkboxMaintainSortOrder.Checked, checkboxUseWildcards.Checked);
        }
示例#2
0
        /// <summary>
        /// Constructor
        /// </summary>
        public RecodeDialog(DashboardHelper dashboardHelper, Rule_Recode rule)
        {
            this.dashboardHelper = dashboardHelper;
            this.editMode        = true;
            this.recodeRule      = rule;
            InitializeComponent();

            FillComboBoxes();

            this.txtDestinationField.Text          = rule.DestinationColumnName;
            this.cbxSourceField.SelectedItem       = rule.SourceColumnName;
            this.checkboxMaintainSortOrder.Checked = rule.ShouldMaintainSortOrder;
            this.checkboxUseWildcards.Checked      = rule.ShouldUseWildcards;
            this.txtElseValue.Text = rule.ElseValue;

            // TODO: Find better way to do this
            switch (rule.DestinationColumnType)
            {
            case "System.SByte":
            case "System.Byte":
            case "System.Boolean":
                this.cbxFieldType.SelectedItem = "Yes/No";
                break;

            case "System.String":
                this.cbxFieldType.SelectedItem = "Text";
                break;

            case "System.Single":
            case "System.Double":
            case "System.Decimal":
            case "System.Int32":
            case "System.Int16":
                this.cbxFieldType.SelectedItem = "Numeric";
                break;
            }

            this.cbxFieldType.Enabled = false;

            if (rule.RecodeInputTable.Columns.Count == 3)
            {
                rule.RecodeInputTable.Columns[0].ColumnName = COL_FROM;
                rule.RecodeInputTable.Columns[1].ColumnName = COL_TO;
                rule.RecodeInputTable.Columns[2].ColumnName = COL_REPRESENTATION;
            }
            else if (rule.RecodeInputTable.Columns.Count == 2)
            {
                rule.RecodeInputTable.Columns[0].ColumnName = COL_FROM;
                rule.RecodeInputTable.Columns[1].ColumnName = COL_REPRESENTATION;
            }

            dataGridViewRecode.DataSource = rule.RecodeInputTable;

            dataGridViewRecode.CellValidating += DataGridViewRecode_CellValidating;
        }
示例#3
0
        private void btnOK_Click(object sender, EventArgs e)
        {
            if (string.IsNullOrEmpty(txtDestinationField.Text))
            {
                MsgBox.ShowError("Destination fields is blank.");
                this.DialogResult = DialogResult.None;
                return;
            }

            if (!editMode)
            {
                ColumnDataType columnDataType = ColumnDataType.Boolean | ColumnDataType.Numeric | ColumnDataType.Text;
                foreach (string s in dashboardHelper.GetFieldsAsList(columnDataType))
                {
                    if (txtDestinationField.Text.ToLower().Equals(s.ToLower()))
                    {
                        MsgBox.ShowError("Destination fields name already exists as a column in this data set. Please use another name.");
                        this.DialogResult = DialogResult.None;
                        return;
                    }
                }

                foreach (IDashboardRule rule in dashboardHelper.Rules)
                {
                    if (rule is DataAssignmentRule)
                    {
                        DataAssignmentRule assignmentRule = rule as DataAssignmentRule;
                        if (txtDestinationField.Text.ToLower().Equals(assignmentRule.DestinationColumnName.ToLower()))
                        {
                            MsgBox.ShowError("Destination fields name already exists as a defined fields with recoded values. Please use another fields name.");
                            this.DialogResult = DialogResult.None;
                            return;
                        }
                    }
                }
            }

            string friendlyRule     = "Recode the values in " + sourceColumnName + " to " + txtDestinationField.Text + "";
            string sourceColumnType = dashboardHelper.GetColumnType(sourceColumnName);

            RecodeRule = new Rule_Recode(this.DashboardHelper, friendlyRule, sourceColumnName, sourceColumnType, txtDestinationField.Text, DestinationFieldType, RecodeTable, txtElseValue.Text, checkboxMaintainSortOrder.Checked, checkboxUseWildcards.Checked);
        }
示例#4
0
        /// <summary>
        /// Constructor
        /// </summary>
        public RecodeDialog(DashboardHelper dashboardHelper, Rule_Recode rule)
        {
            this.dashboardHelper = dashboardHelper;
            this.editMode        = true;
            InitializeComponent();

            FillComboBoxes();

            this.txtDestinationField.Text          = rule.DestinationColumnName;
            this.cbxSourceField.SelectedItem       = rule.SourceColumnName;
            this.checkboxMaintainSortOrder.Checked = rule.ShouldMaintainSortOrder;
            this.checkboxUseWildcards.Checked      = rule.ShouldUseWildcards;
            this.txtElseValue.Text = rule.ElseValue;

            // TODO: Find better way to do this
            switch (rule.DestinationColumnType)
            {
            case "System.Byte":
            case "System.Boolean":
                this.cbxFieldType.SelectedItem = "Yes/No";
                break;

            case "System.String":
                this.cbxFieldType.SelectedItem = "Text";
                break;

            case "System.Single":
            case "System.Double":
            case "System.Decimal":
            case "System.Int32":
            case "System.Int16":
                this.cbxFieldType.SelectedItem = "Numeric";
                break;
            }

            this.dataGridViewRecode.DataSource = rule.RecodeInputTable;
        }
        private void btnEditRule_Click(object sender, RoutedEventArgs e)
        {
            if (lbxRules.SelectedItems != null && lbxRules.SelectedItems.Count == 1)
            {
                Rule_Recode            recodeRule            = null;
                Rule_Format            formatRule            = null;
                Rule_ExpressionAssign  expressionAssignRule  = null;
                Rule_SimpleAssign      simpleAssignRule      = null;
                Rule_ConditionalAssign conditionalAssignRule = null;
                Rule_VariableGroup     variableGroupRule     = null;

                foreach (IDashboardRule rule in dashboardHelper.Rules)
                {
                    if (rule.FriendlyRule.Equals(lbxRules.SelectedItem.ToString()))
                    {
                        if (rule is Rule_Recode)
                        {
                            recodeRule = rule as Rule_Recode;
                            break;
                        }
                        else if (rule is Rule_Format)
                        {
                            formatRule = rule as Rule_Format;
                            break;
                        }
                        else if (rule is Rule_ExpressionAssign)
                        {
                            expressionAssignRule = rule as Rule_ExpressionAssign;
                            break;
                        }
                        else if (rule is Rule_SimpleAssign)
                        {
                            simpleAssignRule = rule as Rule_SimpleAssign;
                            break;
                        }
                        else if (rule is Rule_ConditionalAssign)
                        {
                            conditionalAssignRule = rule as Rule_ConditionalAssign;
                            break;
                        }
                        else if (rule is Rule_VariableGroup)
                        {
                            variableGroupRule = rule as Rule_VariableGroup;
                            break;
                        }
                    }
                }

                System.Windows.Forms.DialogResult result = System.Windows.Forms.DialogResult.None;

                if (recodeRule != null)
                {
                    EpiDashboard.Dialogs.RecodeDialog recodeDialog = new EpiDashboard.Dialogs.RecodeDialog(this.dashboardHelper, recodeRule);
                    result = recodeDialog.ShowDialog();

                    if (result == System.Windows.Forms.DialogResult.OK)
                    {
                        dashboardHelper.UpdateRule(recodeRule, recodeDialog.RecodeRule);
                        UpdateRules();
                        if (UserVariableChanged != null)
                        {
                            UserVariableChanged(this, new EventArgs());
                        }
                    }
                }
                else if (formatRule != null)
                {
                    EpiDashboard.Dialogs.FormatDialog formatDialog = new EpiDashboard.Dialogs.FormatDialog(this.dashboardHelper, formatRule);
                    result = formatDialog.ShowDialog();

                    if (result == System.Windows.Forms.DialogResult.OK)
                    {
                        dashboardHelper.UpdateRule(formatRule, formatDialog.FormatRule);
                        UpdateRules();
                        if (UserVariableChanged != null)
                        {
                            UserVariableChanged(this, new EventArgs());
                        }
                    }
                }
                else if (expressionAssignRule != null)
                {
                    EpiDashboard.Dialogs.ExpressionAssignDialog assignDialog = new EpiDashboard.Dialogs.ExpressionAssignDialog(this.dashboardHelper, expressionAssignRule);
                    result = assignDialog.ShowDialog();

                    if (result == System.Windows.Forms.DialogResult.OK)
                    {
                        dashboardHelper.UpdateRule(expressionAssignRule, assignDialog.AssignRule);
                        UpdateRules();
                        if (UserVariableChanged != null)
                        {
                            UserVariableChanged(this, new EventArgs());
                        }
                    }
                }
                else if (simpleAssignRule != null)
                {
                    EpiDashboard.Dialogs.SimpleAssignDialog assignDialog = new EpiDashboard.Dialogs.SimpleAssignDialog(this.dashboardHelper, simpleAssignRule);
                    result = assignDialog.ShowDialog();

                    if (result == System.Windows.Forms.DialogResult.OK)
                    {
                        dashboardHelper.UpdateRule(simpleAssignRule, assignDialog.AssignRule);
                        UpdateRules();
                        if (UserVariableChanged != null)
                        {
                            UserVariableChanged(this, new EventArgs());
                        }
                    }
                }
                else if (conditionalAssignRule != null)
                {
                    EpiDashboard.Dialogs.ConditionalAssignDialog assignDialog = new EpiDashboard.Dialogs.ConditionalAssignDialog(this.dashboardHelper, conditionalAssignRule);
                    result = assignDialog.ShowDialog();

                    if (result == System.Windows.Forms.DialogResult.OK)
                    {
                        dashboardHelper.UpdateRule(conditionalAssignRule, assignDialog.AssignRule);
                        UpdateRules();
                        if (UserVariableChanged != null)
                        {
                            UserVariableChanged(this, new EventArgs());
                        }
                    }
                }
                else if (variableGroupRule != null)
                {
                    EpiDashboard.Dialogs.CreateGroupDialog groupDialog = new EpiDashboard.Dialogs.CreateGroupDialog(this.dashboardHelper, variableGroupRule);
                    result = groupDialog.ShowDialog();

                    if (result == System.Windows.Forms.DialogResult.OK)
                    {
                        dashboardHelper.UpdateRule(variableGroupRule, groupDialog.Group);
                        UpdateRules();
                        if (UserVariableChanged != null)
                        {
                            UserVariableChanged(this, new EventArgs());
                        }
                    }
                }
            }
        }
示例#6
0
        static public AnalysisRule BuildStatments(Rule_Context context, Token token)
        {
            AnalysisRule result = null;

            if (token is NonterminalToken)
            {
                NonterminalToken nonterminal = (NonterminalToken)token;
                switch (nonterminal.Symbol.ToString())
                {
                case "<Statements>":
                    result = new Rule_Statements(context, nonterminal);
                    break;

                case "<Statement>":
                    result = new Rule_Statement(context, nonterminal);
                    break;

                case "<Always_Statement>":
                    result = new Rule_Always(context, nonterminal);
                    break;

                case "<Simple_Assign_Statement>":
                case "<Let_Statement>":
                case "<Assign_Statement>":
                    result = new Rule_Assign(context, nonterminal);
                    break;

                case "<Assign_DLL_Statement>":
                    result = new Rule_Assign_DLL_Statement(context, nonterminal);
                    break;

                case "<If_Statement>":
                case "<If_Else_Statement>":
                    result = new Rule_If_Then_Else_End(context, nonterminal);
                    break;

                case "<Define_Variable_Statement>":
                    result = new Rule_Define(context, nonterminal);
                    break;

                case "<FuncName2>":
                case "<FunctionCall>":
                    result = new Rule_FunctionCall(context, nonterminal);
                    break;

                case "<Simple_Dialog_Statement>":
                case "<Numeric_Dialog_Implicit_Statement>":
                case "<Numeric_Dialog_Explicit_Statement>":
                case "<TextBox_Dialog_Statement>":
                case "<Db_Values_Dialog_Statement>":
                case "<YN_Dialog_Statement>":
                case "<Db_Views_Dialog_Statement>":
                case "<Databases_Dialog_Statement>":
                case "<Db_Variables_Dialog_Statement>":
                case "<Multiple_Choice_Dialog_Statement>":
                case "<Dialog_Read_Statement>":
                case "<Dialog_Write_Statement>":
                case "<Dialog_Read_Filter_Statement>":
                case "<Dialog_Write_Filter_Statement>":
                case "<Dialog_Date_Statement>":
                case "<Dialog_Date_Mask_Statement>":
                    result = new Rule_Dialog(context, nonterminal);
                    break;

                case "<Read_Epi_Statement>":
                case "<Simple_Read_Statement>":
                case "<Read_Epi_File_Spec_Statement>":
                case "<Read_Sql_Statement>":
                case "<Read_Excel_File_Statement>":
                case "<Read_Db_Table_Statement>":
                    result = new Rule_Read(context, nonterminal);
                    break;

                case "<Merge_Table_Statement>":
                case "<Merge_Db_Table_Statement>":
                case "<Merge_File_Statement>":
                case "<Merge_Excel_File_Statement>":
                    result = new Rule_Merge(context, nonterminal);
                    break;

                case "<Write_All_Statement>":
                case "<Write_Some_Statement>":
                case "<Write_Except_Statement>":
                    result = new Rule_Write(context, nonterminal);
                    break;

                case "<Select_Statement>":
                case "<Cancel_Select_By_Selecting_Statement>":
                case "<Cancel_Select_Statement>":
                    result = new Rule_Select(context, nonterminal);
                    break;

                case "<Recode_Statement>":
                    result = new Rule_Recode(context, nonterminal);
                    break;

                case "<Comment_Line>":
                    result = new Rule_CommentLine(context, nonterminal);
                    break;

                case "<Execute_Statement>":
                    result = new Rule_Execute(context, nonterminal);
                    break;

                case "<Report_Display_Statement>":
                case "<Report_File_Statement>":
                case "<Report_Print_Statement>":
                    result = new Rule_Report(context, nonterminal);
                    break;

                case "<List_Statement>":
                    result = new Rule_List(context, nonterminal);
                    break;

                case "<Simple_Tables_Statement>":
                case "<Tables_One_Variable_Statement>":
                case "<Row_All_Tables_Statement>":
                case "<Row_Except_Tables_Statement>":
                case "<Column_All_Tables_Statement>":
                case "<Column_Except_Tables_Statement>":
                case "<Row_Column_Tables_Statement>":
                    result = new Rule_Tables(context, nonterminal);
                    break;

                case "<Freq_All_Statement>":
                case "<Freq_Columns_Statement>":
                case "<Freq_All_Except_Statement>":
                    result = new Rule_Freq(context, nonterminal);
                    break;

                case "<Cancel_Sort_By_Sorting_Statement>":
                case "<Cancel_Sort_Statement>":
                case "<Sort_Statement>":
                    result = new Rule_Sort(context, nonterminal);
                    break;

                case "<Means_Statement>":
                    result = new Rule_Means(context, nonterminal);
                    break;

                case "<Relate_Epi_Table_Statement>":
                case "<Relate_Table_Statement>":
                case "<Relate_Db_Table_With_Identifier_Statement>":
                case "<Relate_Db_Table_Statement>":
                case "<Relate_File_Statement>":
                case "<Relate_Excel_File_Statement>":
                    result = new Rule_Relate(context, nonterminal);
                    break;

                case "<Beep_Statement>":
                    result = new Rule_Beep(context, nonterminal);
                    break;

                case "<Quit_Statement>":
                    result = new Rule_Quit(context, nonterminal);
                    break;

                case "<Delete_Table_Long_Statement>":
                    result = new Rule_Delete_Table_Long(context, nonterminal);
                    break;

                case "<Delete_File_Statement>":
                    result = new Rule_Delete_File(context, nonterminal);
                    break;

                case "<Delete_Table_Statement>":
                    result = new Rule_Delete_Table(context, nonterminal);
                    break;

                case "<Type_Out_String_Statement>":
                case "<Type_Out_File_Statement>":
                case "<Type_Out_String_With_Font_Statement>":
                case "<Type_Out_File_With_Font_Statement>":
                    result = new Rule_Typeout(context, nonterminal);
                    break;

                case "<Simple_Routeout_Statement>":
                case "<Replace_Routeout_Statement>":
                case "<Append_Routeout_Statement>":
                    result = new Rule_RouteOut(context, nonterminal);
                    break;

                case "<Close_Out_Statement>":
                    result = new Rule_CloseOut(context, nonterminal);
                    break;

                case "<Variables_Display_Statement>":
                case "<Views_Display_Statement>":
                case "<Tables_Display_Statement>":
                    result = new Rule_Display(context, nonterminal);
                    break;

                case "<Header_Title_String_Statement>":
                case "<Header_Title_Font_Statement>":
                case "<Header_Title_String_And_Font_Statement>":
                    result = new Rule_Header(context, nonterminal);
                    break;

                case "<Simple_Undefine_Statement>":
                    result = new Rule_Undefine(context, nonterminal);
                    break;

                case "<Run_File_PGM_Statement>":
                    result = new Rule_Run_File_PGM_Statement(context, nonterminal);
                    break;

                case "<Run_String_Statement>":
                    result = new Rule_Run_String_Statement(context, nonterminal);
                    break;

                case "<Run_PGM_In_Db_Statement>":
                    result = new Rule_Run_PGM_In_Db_Statement(context, nonterminal);
                    break;

                case "<Delete_Records_All_Statement>":
                    result = new Rule_Delete_Records_All_Statement(context, nonterminal);
                    break;

                case "<Delete_Records_Selected_Statement>":
                    result = new Rule_Delete_Records_Selected_Statement(context, nonterminal);
                    break;

                case "<Simple_Print_Out_Statement>":
                case "<File_Print_Out_Statement>":
                    result = new Rule_Printout(context, nonterminal);
                    break;

                case "<SQL_Execute_Command>":
                    result = new Rule_SQLExec(context, nonterminal);
                    break;

                case "<RecordSet_Command>":
                    result = new Rule_RecordSet(context, nonterminal);
                    break;

                case "<Define_Connection_Command>":
                    result = new Rule_Define_Connection(context, nonterminal);
                    break;

                case "<Regress_Statement>":
                    result = new Rule_LinearRegression(context, nonterminal);
                    break;

                case "<Logistic_Statement>":
                    result = new Rule_LogisticRegression(context, nonterminal);
                    break;

                case "<CoxPH_Statement>":
                    result = new Rule_CoxPH(context, nonterminal);
                    break;

                case "<KM_Survival_Statement>":
                    result = new Rule_KMSurvival(context, nonterminal);
                    break;

                case "<Define_Dll_Statement>":
                    result = new Rule_DLL_Statement(context, nonterminal);
                    break;

                case "<Define_Group_Statement>":
                    result = new Rule_Define_Group(context, nonterminal);
                    break;

                case "<Summarize_Statement>":
                    result = new Rule_Summarize(context, nonterminal);
                    break;

                case "<Set_Statement>":
                    result = new Rule_Set(context, nonterminal);
                    break;

                case "<Match_Row_All_Statement>":
                case "<Match_Row_Except_Statement>":
                case "<Match_Column_All_Statement>":
                case "<Match_Column_Except_Statement>":
                case "<Match_Row_Column_Statement>":
                    result = new Rule_Match(context, nonterminal);
                    break;

                case "<Graph_Statement>":
                case "<Simple_Graph_Statement>":
                case "<Strata_Var_Graph_Statement>":
                case "<Weight_Var_Graph_Statement>":
                case "<Stra_Wei_Var_Graph_Statement>":
                case "<Graph_Opt_1_Statement>":
                case "<Graph_Opt_2_Statement>":
                case "<Graph_Opt_3_Statement>":
                case "<Graph_Opt_4_Statement>":
                case "<Graph_Opt_5_Statement>":
                case "<Graph_Generic_Opt_Statement>":
                    result = new Rule_Graph(context, nonterminal);
                    break;

                case "<Expr List>":
                    result = new Rule_ExprList(context, nonterminal);
                    break;

                case "<Expression>":
                    result = new Rule_Expression(context, nonterminal);
                    break;

                case "<And Exp>":
                    result = new Rule_AndExp(context, nonterminal);
                    break;

                case "<Not Exp>":
                    result = new Rule_NotExp(context, nonterminal);
                    break;

                case "<Compare Exp>":
                    result = new Rule_CompareExp(context, nonterminal);
                    break;

                case "<Concat Exp>":
                    result = new Rule_ConcatExp(context, nonterminal);
                    break;

                case "<Add Exp>":
                    result = new Rule_AddExp(context, nonterminal);
                    break;

                case "<Mult Exp>":
                    result = new Rule_MultExp(context, nonterminal);
                    break;

                case "<Pow Exp>":
                    result = new Rule_PowExp(context, nonterminal);
                    break;

                case "<Negate Exp>":
                    result = new Rule_NegateExp(context, nonterminal);
                    break;

                default:
                case "<Value>":
                    result = new Rule_Value(context, nonterminal);
                    break;

                case "<Undelete_All_Statement>":
                    result = new Rule_UnDelete(context, nonterminal);
                    break;

                case "<QualifiedIdList>":
                    result = new Rule_QualifiedIdList(context, nonterminal);
                    break;

                case "<Subroutine_Statement>":
                    result = new Rule_Subroutine_Statement(context, nonterminal);
                    break;

                case "<Call_Statement>":
                    result = new Rule_Call(context, nonterminal);
                    break;
                //**these are not yet implemented; move up when completed
                //**these are not yet implemented; move up when completed
                //**these are not yet implemented; move up when completed
                //**these are not yet implemented; move up when completed
                //**these are not yet implemented; move up when completed

                case "<Simple_Run_Statement>":
                case "<About_Statement>":
                case "<Browser_Statement>":
                case "<Browser_Size_Statement>":
                case "<Button_Offset_Size_1_Statement>":
                case "<Button_Offset_Size_2_Statement>":
                case "<Button_Offset_1_Statement>":
                case "<Button_Offset_2_Statement>":
                case "<Simple_CMD_Statement>":
                case "<CMD_Line_Statement>":
                case "<Delete_Table_Short_Statement>":
                case "<Exit_Statement>":
                case "<File_Dialog_Statement>":
                case "<Get_Path_Statement>":
                case "<Help_File_Statement>":
                case "<Simple_Help_Statement>":
                case "<Link_Statement>":
                case "<Link_Remove_Statement>":
                case "<Map_AVG_Statement>":
                case "<Map_Case_Statement>":
                case "<Map_Sum_Statement>":
                case "<Map_Count_Statement>":
                case "<Map_Min_Statement>":
                case "<Map_Max_Statement>":
                case "<Map_Opt_1_Statement>":
                case "<Map_Opt_2_Statement>":
                case "<Map_Opt_3_Statement>":
                case "<Map_Opt_4_Statement>":
                case "<Map_Opt_5_Statement>":
                case "<Menu_Statement>":
                case "<Menu_Command_Statement>":
                case "<Menu_Dialog_Statement>":
                case "<Menu_Execute_Statement>":
                case "<Menu_Item_Block_Name_Statement>":
                case "<Menu_Item_Separator_Statement>":
                case "<Menu_Replace_Statement>":
                case "<Move_Buttons_Statement>":
                case "<New_Page_Statement>":
                case "<On_Browser_Exit_Block>":
                case "<Picture_Statement>":
                case "<Picture_Size_Statement>":
                case "<Popup_Statement>":
                case "<Repeat_Statement>":
                case "<Screen_Text_Statement>":
                case "<Set_Buttons_Statement>":
                case "<Set_DB_Version_Statement>":
                case "<Set_DOS_Win_Statement>":
                case "<Set_Import_Year_Statement>":
                case "<Set_Ini_Dir_Statement>":
                case "<Set_Language_Statement>":
                case "<Set_Picture_Statement>":
                case "<Set_Work_Dir_Statement>":
                case "<ShutDown_Block>":
                case "<Startup_Block>":
                case "<Sys_Info_Statement>":
                case "<All_Standard_Undefine_Statement>":
                case "<All_Global_Undefine_Statement>":
                case "<Wait_For_Statement>":
                case "<Wait_For_Exit_Statement>":
                case "<Wait_For_File_Exists_Statement>":
                case "<Command_Block>":
                case "<On_Browser_Exit_Empty_Block>":
                case "<Startup_Empty_Block>":
                case "<ShutDown_Empty_Block>":
                case "<Menu_Empty_Block>":
                case "<Popup_Empty_Block>":
                case "<Empty_Command_Block>":
                    break;
                }
            }
            else // terminal token
            {
                TerminalToken terminal = (TerminalToken)token;

                switch (terminal.Symbol.ToString())
                {
                case "<Value>":
                default:
                    result = new Rule_Value(context, terminal);
                    break;
                }
            }

            return(result);
        }