Amiga ACS 1998 #4/amigaacscoverdisc1998-041998.iso/utilities/shareware/dev/ppcsmalleiffel/lib_se/tmp_name.e

Text File | 1998-01-16 | 6.5 KB | 306 lines

--          This file is part of SmallEiffel The GNU Eiffel Compiler.
--          Copyright (C) 1994-98 LORIA - UHP - CRIN - INRIA - FRANCE
--            Dominique COLNET and Suzanne COLLIN - [e-mail]
--                       http://www.loria.fr/SmallEiffel
-- SmallEiffel is  free  software;  you can  redistribute it and/or modify it
-- under the terms of the GNU General Public License as published by the Free
-- Software  Foundation;  either  version  2, or (at your option)  any  later
-- version. SmallEiffel is distributed in the hope that it will be useful,but
-- WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
-- or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU General Public License
-- for  more  details.  You  should  have  received a copy of the GNU General
-- Public  License  along  with  SmallEiffel;  see the file COPYING.  If not,
-- write to the  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-- Boston, MA 02111-1307, USA.
--
class TMP_NAME
   --
   -- Unique object for temprary storage of an unkown name
   -- during syntax analysis.
   --

inherit GLOBALS;

creation {EIFFEL_PARSER}
   make

feature {NONE}

   tmp_string: STRING is
      once
     !!Result.make(256);
      end;

   unique_string_memory: STRING;

feature {EIFFEL_PARSER}

   li, co: INTEGER;

feature {NONE}

   make is
      do
      end;

feature {EIFFEL_PARSER}

   initialize(l, c: INTEGER) is
      do
     li := l;
     co := c;
     tmp_string.clear;
     unique_string_memory := Void;
      end;

feature {EIFFEL_PARSER}

   is_current: BOOLEAN is
      do
     if tmp_string.count = 7 then
        Result := us_current.same_as(tmp_string);
     end;
      end;

   is_result: BOOLEAN is
      do
     if tmp_string.count = 6 then
        Result := us_result.same_as(tmp_string);
     end;
      end;

   is_void: BOOLEAN is
      do
     if tmp_string.count = 4 then
        Result := us_void.same_as(tmp_string);
     end;
      end;

   to_string: STRING is
      do
     if unique_string_memory = Void then
        Result := unique_string.item(tmp_string);
        unique_string_memory := Result;
     else
        Result := unique_string_memory;
     end;
      end;

   count: INTEGER is
      do
     Result := tmp_string.count;
      end;

   start_position: POSITION is
      do
     !!Result.make(li,co);
      end;

   extend(ch: CHARACTER) is
      do
     tmp_string.extend(ch);
      end;

   isa_keyword: BOOLEAN is
      require
     not tmp_string.empty
      local
     c: CHARACTER;
      do
     c := tmp_string.item(1).to_lower;
     inspect
        c
     when 'a' then
        Result := look_in(keyword_a);
     when 'c' then
        Result := look_in(keyword_c);
     when 'd' then
        Result := look_in(keyword_d);
     when 'e' then
        Result := look_in(keyword_e);
     when 'f' then
        Result := look_in(keyword_f);
     when 'i' then
        Result := look_in(keyword_i);
     when 'l' then
        Result := look_in(keyword_l);
     when 'o' then
        Result := look_in(keyword_o);
     when 'p' then
        Result := fz_prefix.same_as(tmp_string);
     when 'r' then
        Result := look_in(keyword_r);
     when 's' then
        Result := look_in(keyword_s);
     when 't' then
        Result := look_in(keyword_t);
     when 'u' then
        Result := look_in(keyword_u);
     when 'v' then
        Result := fz_variant.same_as(tmp_string);
     when 'w' then
        Result := fz_when.same_as(tmp_string);
     when 'x' then
        Result := us_xor.same_as(tmp_string);
     else
     end;
      end;

feature {EIFFEL_PARSER} -- Final Conversion Routines :

   to_argument_name1: ARGUMENT_NAME1 is
      do
     !!Result.make(pos(li,co),tmp_string);
      end;

   to_argument_name2(fal: FORMAL_ARG_LIST; rank: INTEGER): ARGUMENT_NAME2 is
      do
     !!Result.refer_to(pos(li,co),fal,rank);
      end;

   to_class_name: CLASS_NAME is
      do
     !!Result.make(tmp_string,pos(li,co));
      end;

   to_e_current: E_CURRENT is
      require
     is_current
      do
     !!Result.make(pos(li,co),true);
      end;

   to_e_result: E_RESULT is
      require
     is_result
      do
     !!Result.make(pos(li,co));
      end;

   to_e_void: E_VOID is
      require
     is_void
      do
     !!Result.make(pos(li,co));
      end;

   to_simple_feature_name: SIMPLE_FEATURE_NAME is
      do
     !!Result.make(tmp_string,pos(li,co));
      end;

   to_infix_name_use: INFIX_NAME is
      do
     !!Result.make(tmp_string,pos(li,co));
      end;

   to_infix_name(sp: POSITION): INFIX_NAME is
      do
     !!Result.make(tmp_string,sp);
      end;

   to_local_name1: LOCAL_NAME1 is
      do
     !!Result.make(pos(li,co),tmp_string);
      end;

   to_local_name2(lvl: LOCAL_VAR_LIST; rank: INTEGER): LOCAL_NAME2 is
      do
     !!Result.refer_to(pos(li,co),lvl,rank);
      end;

   to_prefix_name: PREFIX_NAME is
      do
     !!Result.make(tmp_string,pos(li,co));
      end;

   to_tag_name: TAG_NAME is
      do
     !!Result.make(tmp_string,pos(li,co));
      end;

feature {NONE}

   keyword_a: ARRAY[STRING] is
      once
     Result := <<fz_alias,fz_all,us_and,fz_as>>;
      end;

   keyword_c: ARRAY[STRING] is
      once
     Result := <<fz_check,fz_class,fz_creation>>;
      end;

   keyword_d: ARRAY[STRING] is
      once
     Result := <<fz_debug,fz_deferred,fz_do>>;
      end;

   keyword_e: ARRAY[STRING] is
      once
     Result := <<fz_else,fz_elseif,fz_end,fz_ensure,
             fz_expanded,fz_export,fz_external>>;
      end;

   keyword_f: ARRAY[STRING] is
      once
     Result := <<fz_false,fz_feature,fz_from,fz_frozen>>;
      end;

   keyword_i: ARRAY[STRING] is
      once
     Result := <<fz_if,us_implies,fz_indexing,fz_infix,
             fz_inherit,fz_inspect,fz_invariant,fz_is>>;
      end;

   keyword_l: ARRAY[STRING] is
      once
     Result := <<fz_like,fz_local,fz_loop>>;
      end;

   keyword_o: ARRAY[STRING] is
      once
     Result := <<fz_obsolete,fz_old,fz_once,us_or>>;
      end;

   keyword_r: ARRAY[STRING] is
      once
     Result := <<fz_redefine,fz_rename,fz_require,fz_rescue,fz_retry>>;
      end;

   keyword_s: ARRAY[STRING] is
      once
     Result := <<fz_select,fz_separate,fz_strip>>;
      end;

   keyword_t: ARRAY[STRING] is
      once
     Result := <<fz_then,fz_true>>;
      end;

   keyword_u: ARRAY[STRING] is
      once
     Result := <<fz_undefine,fz_unique,fz_until>>;
      end;

   look_in(kt: ARRAY[STRING]): BOOLEAN is
      require
     not tmp_string.empty;
     not kt.empty;
     kt.lower = 1
      local
     i: INTEGER;
      do
     from
        i := kt.upper;
     until
        Result or else i = 0
     loop
        Result := kt.item(i).same_as(tmp_string);
        i := i - 1;
     end;
      end;

end -- TMP_NAME