Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Diff of /sml/trunk/ckit/src/parser/grammar/tokentable.sml
ViewVC logotype

Diff of /sml/trunk/ckit/src/parser/grammar/tokentable.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 597, Wed Apr 5 18:34:51 2000 UTC revision 809, Wed Apr 18 17:53:01 2001 UTC
# Line 23  Line 23 
23    exception LexError    exception LexError
24    val keywords : item AtomTable.hash_table = AtomTable.mkTable(64, Keyword)    val keywords : item AtomTable.hash_table = AtomTable.mkTable(64, Keyword)
25    
26    val _ = let    local
27      val insert = AtomTable.insert keywords      val insert = AtomTable.insert keywords
28      fun ins (s, item) = insert (Atom.atom s, item)      fun ins (s, item) = insert (Atom.atom s, item)
29    
30        fun idTok (s, pos, endPos) =
31            if TypeDefs.checkTdef(s) = true then
32                Tokens.TYPE_NAME(s,pos,endPos)
33            else Tokens.ID(s,pos,endPos)
34    
35        (* to enter GCC-style 'underscore'-versions of certain keywords *)
36        fun insaug (s, item) = let
37            fun item' (p as (pos, endPos)) =
38                case ParseControl.underscoreKeywords of
39                    NONE => idTok (s, pos, endPos)
40                  | SOME true => item p
41                  | SOME false =>
42                    (ParseControl.violation
43                         (concat ["gcc-style keywords '__", s, "' or '__",
44                                  s, "__' are not allowed"]);
45                         raise LexError)
46    in    in
47      app ins ([          ins ("__" ^ s, item');
48            ins ("__" ^ s ^ "__", item')
49        end
50    
51        val normaltokens =
52            [("auto", Tokens.AUTO),
53             ("extern", Tokens.EXTERN),
54             ("register", Tokens.REGISTER),
55             ("static", Tokens.STATIC),
56             ("unsigned", Tokens.UNSIGNED),
57                ("break", Tokens.BREAK),                ("break", Tokens.BREAK),
58                ("case", Tokens.CASE),                ("case", Tokens.CASE),
59                ("continue", Tokens.CONTINUE),                ("continue", Tokens.CONTINUE),
60                ("default", Tokens.DEFAULT),                ("default", Tokens.DEFAULT),
61                ("do", Tokens.DO),                ("do", Tokens.DO),
62                ("else", Tokens.ELSE),                ("else", Tokens.ELSE),
               ("auto", Tokens.AUTO),  
               ("extern", Tokens.EXTERN),  
               ("register", Tokens.REGISTER),  
               ("static", Tokens.STATIC),  
63                ("for", Tokens.FOR),                ("for", Tokens.FOR),
64                ("goto", Tokens.GOTO),                ("goto", Tokens.GOTO),
65                ("if", Tokens.IF),                ("if", Tokens.IF),
               ("char", Tokens.CHAR),  
               ("double", Tokens.DOUBLE),  
66                ("enum", Tokens.ENUM),                ("enum", Tokens.ENUM),
67                ("float", Tokens.FLOAT),                ("float", Tokens.FLOAT),
68             ("double", Tokens.DOUBLE),
69             ("char", Tokens.CHAR),
70                ("int", Tokens.INT),                ("int", Tokens.INT),
71                ("long", Tokens.LONG),                ("long", Tokens.LONG),
72                ("short", Tokens.SHORT),                ("short", Tokens.SHORT),
73                ("struct", Tokens.STRUCT),                ("struct", Tokens.STRUCT),
74                ("union", Tokens.UNION),                ("union", Tokens.UNION),
               ("unsigned", Tokens.UNSIGNED),  
               ("signed", Tokens.SIGNED),  
               ("const", fn p => if ParseControl.constAllowed  
                                   then (Tokens.CONST p)  
                                 else (ParseControl.violation "the keyword 'const' not allowed";  
                                       raise LexError)),  
               ("volatile", fn p => if ParseControl.volatileAllowed  
                                      then (Tokens.VOLATILE p)  
                                    else (ParseControl.violation "the keyword 'volatile' not allowed";  
                                          raise LexError)),  
75                ("void", Tokens.VOID),                ("void", Tokens.VOID),
76                ("sizeof", Tokens.SIZEOF),                ("sizeof", Tokens.SIZEOF),
77                ("typedef", Tokens.TYPEDEF),                ("typedef", Tokens.TYPEDEF),
78                ("return", Tokens.RETURN),                ("return", Tokens.RETURN),
79                ("switch", Tokens.SWITCH),                ("switch", Tokens.SWITCH),
80                ("while", Tokens.WHILE)           ("while", Tokens.WHILE)]
81                ] @  
82                (if ParseControl.Dkeywords then      (* tokens for which gcc has __* and __*__ versions *)
83        val augmentabletokens =
84            [("signed", Tokens.SIGNED),
85             ("const", fn p => if ParseControl.constAllowed
86                                   then (Tokens.CONST p)
87                               else (ParseControl.violation
88                                     "the keyword 'const' not allowed";
89                                     raise LexError)),
90             ("volatile", fn p => if ParseControl.volatileAllowed
91                                      then (Tokens.VOLATILE p)
92                                  else (ParseControl.violation
93                                        "the keyword 'volatile' not allowed";
94                                        raise LexError))]
95    
96                  (* tokens for D *)                  (* tokens for D *)
97        val dtokens =
98                  [                  [
99                   ]                   ]
               else nil))  
   
   end  
100    
101        val _ =
102            (app ins normaltokens;
103             app ins augmentabletokens;
104             app insaug augmentabletokens;
105             (* enter D keywords only when allowed...
106              * (I think the ParseControl test is done at the wrong time here.
107              *  - Blume) *)
108             if ParseControl.Dkeywords then app ins dtokens else ())
109      in
110    fun checkToken (s, pos) = let    fun checkToken (s, pos) = let
111      val endPos = pos + size s      val endPos = pos + size s
112      val name = Atom.atom s      val name = Atom.atom s
113    in    in
114      case (AtomTable.find keywords name)            case (AtomTable.find keywords name) of
115        of (SOME tokFn) => tokFn(pos, endPos)                SOME tokFn => tokFn(pos, endPos)
116         | NONE =>              | NONE => idTok (s, pos, endPos)
            (if TypeDefs.checkTdef(s) = true then  
               Tokens.TYPE_NAME(s,pos,endPos)  
             else Tokens.ID(s,pos,endPos))  
   (* end case *)  
117    end    end
118      end (* local *)
119  end  end

Legend:
Removed from v.597  
changed lines
  Added in v.809

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0