/src/tools/interpreter/debugger/liberty_interpreter_debugger_grammar.e

http://github.com/tybor/Liberty · Specman e · 62 lines · 41 code · 7 blank · 14 comment · 0 complexity · 80b5706db066de55fd9597a458c33320 MD5 · raw file 

    

  1. -- This file is part of Liberty Eiffel.
    2. 

  2. --
    3. 

  3. -- Liberty Eiffel is free software: you can redistribute it and/or modify
    4. 

  4. -- it under the terms of the GNU General Public License as published by
    5. 

  5. -- the Free Software Foundation, version 3 of the License.
    6. 

  6. --
    7. 

  7. -- Liberty Eiffel is distributed in the hope that it will be useful,
    8. 

  8. -- but WITHOUT ANY WARRANTY; without even the implied warranty of
    9. 

  9. -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    10. 

  10. -- GNU General Public License for more details.
    11. 

  11. --
    12. 

  12. -- You should have received a copy of the GNU General Public License
    13. 

  13. -- along with Liberty Eiffel.  If not, see <http://www.gnu.org/licenses/>.
    14. 

  14. --
    15. 

  15. class LIBERTY_INTERPRETER_DEBUGGER_GRAMMAR
    16. 

  16. 

  17. inherit
    18. 

  18.    EIFFEL_GRAMMAR
    19. 

  19.       redefine
    20. 

  20.          the_table
    21. 

  21.       end
    22. 

  22. 

  23. create {LIBERTY_INTERPRETER_DEBUGGER}
    24. 

  24.    make
    25. 

  25. 

  26. feature {}
    27. 

  27.    the_table: PARSE_TABLE is
    28. 

  28.       once
    29. 

  29.          Result := {PARSE_TABLE << "Entry", {PARSE_NON_TERMINAL << {FAST_ARRAY[STRING] << "KW show", "Show", "KW end of line" >> }, agent build_root;
    30. 

  30.                                                                    {FAST_ARRAY[STRING] << "KW up", "Up" >> }, agent build_root;
    31. 

  31.                                                                    {FAST_ARRAY[STRING] << "KW down", "Down" >> }, agent build_root;
    32. 

  32.                                                                    {FAST_ARRAY[STRING] << "KW continue", "KW end of line" >> }, agent build_root;
    33. 

  33.                                                                    {FAST_ARRAY[STRING] << "KW step", "Step", "KW end of line" >> }, agent build_root;
    34. 

  34.                                                                    {FAST_ARRAY[STRING] << "KW quit", "KW end of line" >> }, agent build_root >> };
    35. 

  35.                                    "Show", {PARSE_NON_TERMINAL << {FAST_ARRAY[STRING] << "KW stack" >> }, Void;
    36. 

  36.                                                                   {FAST_ARRAY[STRING] << "KW frame" >> }, Void >> };
    37. 

  37.                                    "Step", {PARSE_NON_TERMINAL << epsilon, Void;
    38. 

  38.                                                                   {FAST_ARRAY[STRING] << "KW in" >> }, Void;
    39. 

  39.                                                                   {FAST_ARRAY[STRING] << "KW out" >> }, Void;
    40. 

  40.                                                                   {FAST_ARRAY[STRING] << "KW number" >> }, Void >> };
    41. 

  41.                                    "Up", {PARSE_NON_TERMINAL << epsilon, Void;
    42. 

  42.                                                                 {FAST_ARRAY[STRING] << "KW number" >> }, Void >> };
    43. 

  43.                                    "Down", {PARSE_NON_TERMINAL << epsilon, Void;
    44. 

  44.                                                                   {FAST_ARRAY[STRING] << "KW number" >> }, Void >> };
    45. 

  45. 

  46.                                    "KW continue",    create {PARSE_TERMINAL}.make(agent parse_keyword(?, "continue"), Void);
    47. 

  47.                                    "KW down",        create {PARSE_TERMINAL}.make(agent parse_keyword(?, "down"),    Void);
    48. 

  48.                                    "KW frame",       create {PARSE_TERMINAL}.make(agent parse_keyword(?, "frame"),    Void);
    49. 

  49.                                    "KW in",          create {PARSE_TERMINAL}.make(agent parse_keyword(?, "in"),       Void);
    50. 

  50.                                    "KW out",         create {PARSE_TERMINAL}.make(agent parse_keyword(?, "out"),      Void);
    51. 

  51.                                    "KW quit",        create {PARSE_TERMINAL}.make(agent parse_keyword(?, "quit"),     Void);
    52. 

  52.                                    "KW show",        create {PARSE_TERMINAL}.make(agent parse_keyword(?, "show"),     Void);
    53. 

  53.                                    "KW stack",       create {PARSE_TERMINAL}.make(agent parse_keyword(?, "stack"),    Void);
    54. 

  54.                                    "KW step",        create {PARSE_TERMINAL}.make(agent parse_keyword(?, "step"),     Void);
    55. 

  55.                                    "KW up",          create {PARSE_TERMINAL}.make(agent parse_keyword(?, "up"),    Void);
    56. 

  56. 

  57.                                    "KW number",      create {PARSE_TERMINAL}.make(agent parse_number, Void);
    58. 

  58. 

  59.                                    "KW end of line", create {PARSE_TERMINAL}.make(agent parse_end, Void) >> };
    60. 

  60.       end
    61. 

  61. 

  62. end -- class LIBERTY_INTERPRETER_DEBUGGER_GRAMMAR
    63.