Return to pascal.lex CVS log

Up to [Research Unix] / researchv10no / cmd / sml / lib / mlyacc

Annotation of researchv10no/cmd/sml/lib/mlyacc/pascal.lex, revision 1.1

1.1     ! root        1: open C.LexValue
        !             2: type lexresult=V
        !             3: val eof = fn () => EOF
        !             4: val lineno = C.G.lineno
        !             5: 
        !             6: structure KeyWord : sig
        !             7:                        val find : string -> V option
        !             8:                    end =
        !             9:   struct
        !            10: 
        !            11:        val TableSize = 211
        !            12:        val HashFactor = 5
        !            13: 
        !            14:        val hash = fn s =>
        !            15:           fold (fn (c,v)=>(v*HashFactor+(ord c)) mod TableSize) (explode s) 0
        !            16: 
        !            17: 
        !            18:        val HashTable = array(TableSize,nil) : (string * V) list array
        !            19: 
        !            20: 
        !            21:        val add = fn (s,v) =>
        !            22:         let val i = hash s
        !            23:         in update(HashTable,i,(s,v) :: (HashTable sub i))
        !            24:         end
        !            25: 
        !            26:         val find = fn s =>
        !            27:          let val i = hash s
        !            28:              fun f ((key,v)::r) = if s=key then SOME v else f r
        !            29:                | f nil = NONE
        !            30:          in  f (HashTable sub i)
        !            31:          end
        !            32:  
        !            33:        val _ = 
        !            34:            (List.app add
        !            35:        [("and",YAND),
        !            36:         ("array",YARRAY),
        !            37:         ("begin",YBEGIN),
        !            38:         ("case",YCASE),
        !            39:         ("const",YCONST),
        !            40:         ("div",YDIV),
        !            41:         ("do",YDO),
        !            42:         ("downto",YDOWNTO),
        !            43:         ("else",YELSE),
        !            44:         ("end",YEND),
        !            45:         ("extern",YEXTERN),
        !            46:         ("file",YFILE),
        !            47:         ("for",YFOR),
        !            48:         ("forward",YFORWARD),
        !            49:         ("function",YFUNCTION),
        !            50:         ("goto",YGOTO),
        !            51:         ("hex",YHEX),
        !            52:         ("if",YIF),
        !            53:         ("in",YIN),
        !            54:         ("label",YLABEL),
        !            55:         ("mod",YMOD),
        !            56:         ("nil",YNIL),
        !            57:         ("not",YNOT),
        !            58:         ("oct",YOCT),
        !            59:         ("of",YOF),
        !            60:         ("or",YOR),
        !            61:         ("packed",YPACKED),
        !            62:         ("procedure",YPROCEDURE),
        !            63:         ("program",YPROG),
        !            64:         ("record",YRECORD),
        !            65:         ("repeat",YREPEAT),
        !            66:         ("set",YSET),
        !            67:         ("then",YTHEN),
        !            68:         ("to",YTO),
        !            69:         ("type",YTYPE),
        !            70:         ("until",YUNTIL),
        !            71:         ("var",YVAR),
        !            72:         ("while",YWHILE),
        !            73:         ("with",YWITH)
        !            74:        ])
        !            75:    end
        !            76:    open KeyWord
        !            77: 
        !            78: %%
        !            79: 
        !            80: %s C B;
        !            81: alpha=[A-Za-z];
        !            82: digit=[0-9];
        !            83: optsign=("+"|"-")?;
        !            84: integer={digit}+;
        !            85: frac="."{digit}+;
        !            86: exp=(e|E){optsign}{digit}+;
        !            87: octdigit=[0-7];
        !            88: ws = [\ \t];
        !            89: %%
        !            90: <INITIAL>{ws}+ => (lex());
        !            91: <INITIAL>\n    => (inc lineno; lex());
        !            92: <INITIAL>{alpha}+ => (case find yytext of SOME v => v | _ => YID);
        !            93: <INITIAL>{alpha}({alpha}|{digit})*  => (YID);
        !            94: <INITIAL>{optsign}{integer}({frac}{exp}?|{frac}?{exp}) => (YNUMB);
        !            95: <INITIAL>{optsign}{integer} => (YINT);
        !            96: <INITIAL>{octdigit}+(b|B) => (YBINT);
        !            97: <INITIAL>"'"([^']|"''")*"'" => (YSTRING);
        !            98: <INITIAL>"(*" =>   (YYBEGIN C; lex());
        !            99: <INITIAL>".."  => (YDOTDOT);
        !           100: <INITIAL>"."   => (YDOT);
        !           101: <INITIAL>"("   => (YLPAR);
        !           102: <INITIAL>")"   => (YRPAR);
        !           103: <INITIAL>";"   => (YSEMI);
        !           104: <INITIAL>","   => (YCOMMA);
        !           105: <INITIAL>":"   => (YCOLON);
        !           106: <INITIAL>"^"   => (YCARET);
        !           107: <INITIAL>"["   => (YLBRA);
        !           108: <INITIAL>"]"   => (YRBRA);
        !           109: <INITIAL>"~"   => (YTILDE);
        !           110: <INITIAL>"<"   => (YLESS);
        !           111: <INITIAL>"="   => (YEQUAL);
        !           112: <INITIAL>">"   => (YGREATER);
        !           113: <INITIAL>"+"   => (YPLUS);
        !           114: <INITIAL>"-"   => (YMINUS);
        !           115: <INITIAL>"|"   => (YBAR);
        !           116: <INITIAL>"*"   => (YSTAR);
        !           117: <INITIAL>"/"   => (YSLASH);
        !           118: <INITIAL>"{"   => (YYBEGIN B; lex());
        !           119: <INITIAL>.     => (YILLCH);
        !           120: <C>\n          => (inc lineno; lex());
        !           121: <C>[^()*\n]+   => (lex());
        !           122: <C>"(*"                => (lex());
        !           123: <C>"*)"                => (YYBEGIN INITIAL; lex());
        !           124: <C>[*()]       => (lex());
        !           125: <B>\n          => (inc lineno; lex());
        !           126: <B>[^{}\n]+    => (lex());
        !           127: <B>"{"         => (lex());
        !           128: <B>"}"         => (YYBEGIN INITIAL; lex());

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.