Exemplo n.º 1
0
        private void balance()
        {
            EnterRule_balance();
            EnterRule("balance", 4);
            TraceIn("balance", 4);
            ChemProVTree.computation_return left  = default(ChemProVTree.computation_return);
            ChemProVTree.computation_return right = default(ChemProVTree.computation_return);

            try { DebugEnterRule(GrammarFileName, "balance");
                  DebugLocation(37, 1);
                  try
                  {
                      // D:\\code\\chemprov_codeplex\\ChemProV\\ChemProV\\Grammars\\ChemProVTree.g:38:2: ( ^( '=' left= computation right= computation ) )
                      DebugEnterAlt(1);
                      // D:\\code\\chemprov_codeplex\\ChemProV\\ChemProV\\Grammars\\ChemProVTree.g:38:4: ^( '=' left= computation right= computation )
                      {
                          DebugLocation(38, 4);
                          DebugLocation(38, 6);
                          Match(input, 16, Follow._16_in_balance112);

                          Match(input, TokenTypes.Down, null);
                          DebugLocation(38, 14);
                          PushFollow(Follow._computation_in_balance116);
                          left = computation();
                          PopFollow();

                          DebugLocation(38, 32);
                          PushFollow(Follow._computation_in_balance120);
                          right = computation();
                          PopFollow();


                          Match(input, TokenTypes.Up, null);

                          DebugLocation(38, 46);
                      }
                  }
                  catch (RecognitionException re)
                  {
                      ReportError(re);
                      Recover(input, re);
                  }
                  finally
                  {
                      TraceOut("balance", 4);
                      LeaveRule("balance", 4);
                      LeaveRule_balance();
                  }
                  DebugLocation(39, 1); } finally { DebugExitRule(GrammarFileName, "balance"); }
            return;
        }
Exemplo n.º 2
0
        private ChemProVTree.computation_return computation()
        {
            EnterRule_computation();
            EnterRule("computation", 5);
            TraceIn("computation", 5);
            ChemProVTree.computation_return retval = new ChemProVTree.computation_return(this);
            retval.Start = (CommonTree)input.LT(1);

            CommonTree IDENTIFIER1 = default(CommonTree);
            CommonTree INTEGER2    = default(CommonTree);
            CommonTree FLOAT3      = default(CommonTree);

            ChemProVTree.computation_return left  = default(ChemProVTree.computation_return);
            ChemProVTree.computation_return right = default(ChemProVTree.computation_return);

            try { DebugEnterRule(GrammarFileName, "computation");
                  DebugLocation(41, 1);
                  try
                  {
                      // D:\\code\\chemprov_codeplex\\ChemProV\\ChemProV\\Grammars\\ChemProVTree.g:42:2: ( ^( '+' left= computation right= computation ) | ^( '-' left= computation right= computation ) | ^( '*' left= computation right= computation ) | ^( '/' left= computation right= computation ) | IDENTIFIER | INTEGER | FLOAT )
                      int alt3 = 7;
                      try { DebugEnterDecision(3, false);
                            switch (input.LA(1))
                            {
                            case 13:
                            {
                                alt3 = 1;
                            }
                            break;

                            case 14:
                            {
                                alt3 = 2;
                            }
                            break;

                            case 12:
                            {
                                alt3 = 3;
                            }
                            break;

                            case 15:
                            {
                                alt3 = 4;
                            }
                            break;

                            case IDENTIFIER:
                            {
                                alt3 = 5;
                            }
                            break;

                            case INTEGER:
                            {
                                alt3 = 6;
                            }
                            break;

                            case FLOAT:
                            {
                                alt3 = 7;
                            }
                            break;

                            default:
                            {
                                NoViableAltException nvae = new NoViableAltException("", 3, 0, input);
                                DebugRecognitionException(nvae);
                                throw nvae;
                            }
                            }
                      } finally { DebugExitDecision(3); }
                      switch (alt3)
                      {
                      case 1:
                          DebugEnterAlt(1);
                          // D:\\code\\chemprov_codeplex\\ChemProV\\ChemProV\\Grammars\\ChemProVTree.g:42:4: ^( '+' left= computation right= computation )
                          {
                              DebugLocation(42, 4);
                              DebugLocation(42, 6);
                              Match(input, 13, Follow._13_in_computation140);

                              Match(input, TokenTypes.Down, null);
                              DebugLocation(42, 14);
                              PushFollow(Follow._computation_in_computation144);
                              left = computation();
                              PopFollow();

                              DebugLocation(42, 32);
                              PushFollow(Follow._computation_in_computation148);
                              right = computation();
                              PopFollow();


                              Match(input, TokenTypes.Up, null);

                              DebugLocation(42, 46);
                          }
                          break;

                      case 2:
                          DebugEnterAlt(2);
                          // D:\\code\\chemprov_codeplex\\ChemProV\\ChemProV\\Grammars\\ChemProVTree.g:43:4: ^( '-' left= computation right= computation )
                          {
                              DebugLocation(43, 4);
                              DebugLocation(43, 6);
                              Match(input, 14, Follow._14_in_computation157);

                              Match(input, TokenTypes.Down, null);
                              DebugLocation(43, 14);
                              PushFollow(Follow._computation_in_computation161);
                              left = computation();
                              PopFollow();

                              DebugLocation(43, 32);
                              PushFollow(Follow._computation_in_computation165);
                              right = computation();
                              PopFollow();


                              Match(input, TokenTypes.Up, null);

                              DebugLocation(43, 46);
                          }
                          break;

                      case 3:
                          DebugEnterAlt(3);
                          // D:\\code\\chemprov_codeplex\\ChemProV\\ChemProV\\Grammars\\ChemProVTree.g:44:4: ^( '*' left= computation right= computation )
                          {
                              DebugLocation(44, 4);
                              DebugLocation(44, 6);
                              Match(input, 12, Follow._12_in_computation174);

                              Match(input, TokenTypes.Down, null);
                              DebugLocation(44, 14);
                              PushFollow(Follow._computation_in_computation178);
                              left = computation();
                              PopFollow();

                              DebugLocation(44, 32);
                              PushFollow(Follow._computation_in_computation182);
                              right = computation();
                              PopFollow();


                              Match(input, TokenTypes.Up, null);

                              DebugLocation(44, 46);
                          }
                          break;

                      case 4:
                          DebugEnterAlt(4);
                          // D:\\code\\chemprov_codeplex\\ChemProV\\ChemProV\\Grammars\\ChemProVTree.g:45:4: ^( '/' left= computation right= computation )
                          {
                              DebugLocation(45, 4);
                              DebugLocation(45, 6);
                              Match(input, 15, Follow._15_in_computation191);

                              Match(input, TokenTypes.Down, null);
                              DebugLocation(45, 14);
                              PushFollow(Follow._computation_in_computation195);
                              left = computation();
                              PopFollow();

                              DebugLocation(45, 32);
                              PushFollow(Follow._computation_in_computation199);
                              right = computation();
                              PopFollow();


                              Match(input, TokenTypes.Up, null);

                              DebugLocation(46, 3);

                              if (left.lexerType == IDENTIFIER && right.lexerType == INTEGER && right.integerValue == 100)
                              {
                                  Lines[currentLineNumber].Tokens[left.equationTokenId].IsPercent = true;
                              }
                          }
                          break;

                      case 5:
                          DebugEnterAlt(5);
                          // D:\\code\\chemprov_codeplex\\ChemProV\\ChemProV\\Grammars\\ChemProVTree.g:52:4: IDENTIFIER
                          {
                              DebugLocation(52, 4);
                              IDENTIFIER1 = (CommonTree)Match(input, IDENTIFIER, Follow._IDENTIFIER_in_computation210);
                              DebugLocation(53, 6);

                              if (Lines.Count <= currentLineNumber)
                              {
                                  Lines.Add(new Equation());
                              }
                              Variable token = new Variable((IDENTIFIER1 != null?IDENTIFIER1.Text:null));
                              retval.equationTokenId = token.Id;
                              Lines[currentLineNumber].Tokens.Add(retval.equationTokenId, token);
                              retval.lexerType = (IDENTIFIER1 != null?IDENTIFIER1.Type:0);
                          }
                          break;

                      case 6:
                          DebugEnterAlt(6);
                          // D:\\code\\chemprov_codeplex\\ChemProV\\ChemProV\\Grammars\\ChemProVTree.g:63:4: INTEGER
                          {
                              DebugLocation(63, 4);
                              INTEGER2 = (CommonTree)Match(input, INTEGER, Follow._INTEGER_in_computation222);
                              DebugLocation(64, 3);

                              retval.lexerType = (INTEGER2 != null?INTEGER2.Type:0);
                              Int32.TryParse((INTEGER2 != null?INTEGER2.Text:null), out retval.integerValue);
                          }
                          break;

                      case 7:
                          DebugEnterAlt(7);
                          // D:\\code\\chemprov_codeplex\\ChemProV\\ChemProV\\Grammars\\ChemProVTree.g:68:4: FLOAT
                          {
                              DebugLocation(68, 4);
                              FLOAT3 = (CommonTree)Match(input, FLOAT, Follow._FLOAT_in_computation232);
                              DebugLocation(69, 3);

                              retval.lexerType = (FLOAT3 != null?FLOAT3.Type:0);
                          }
                          break;
                      }
                  }
                  catch (RecognitionException re)
                  {
                      ReportError(re);
                      Recover(input, re);
                  }
                  finally
                  {
                      TraceOut("computation", 5);
                      LeaveRule("computation", 5);
                      LeaveRule_computation();
                  }
                  DebugLocation(72, 1); } finally { DebugExitRule(GrammarFileName, "computation"); }
            return(retval);
        }