[Commit] mint/grammars expgram.mnt, NONE, 1.1 nickle.mnt, NONE, 1.1 regram.mnt, NONE, 1.1

[James LaMar]

Committed by: jlamar

Update of /local/src/CVS/mint/grammars
In directory home.keithp.com:/tmp/cvs-serv27318/grammars

Added Files:
	expgram.mnt nickle.mnt regram.mnt 
Log Message:
Initial version.


--- NEW FILE: expgram.mnt ---
#
# Mint test grammar
#
# The canonical expression grammar
#

#
# Token section
#
tokens:

token plus       /\+/
token mult       /\*/
token rparen     /\(/
token lparen     /\)/
token id         /[A-Za-z0-9]/
skip whitespace /[ ]/

#
# Operator precedence
#
precedence:

left plus
left mult

#
# Rules
#
rules:

rule (E : plusexpr) -> (E : op1) plus (E : op2)
rule (E : multexpr) -> (E : op1) mult (E : op2)
rule (E : id) -> id
rule (E : parenexpr) -> lparen (E : sub) rparen


--- NEW FILE: nickle.mnt ---
#
# A small test grammar for a programming language
# (A subset of nickle)
#
tokens:

token                   typedef          /typedef/
token                   return           /return/
token                   if               /if/
token                   for              /for/
token                   while            /while/
token                   semicolon        /;/
token                   colon            /:/
token                   union            /union/
token                   struct           /struct/
token                   true             /true/
token                   false            /false/
token                   int              /[0-9][0-9]*|-[0-9][0-9]*/
token                   real             /[0-9]*\.[0-9]/
token                   string           /"[^"]*"/
token                   assign           /=/
token                   equal            /==/
token                   notequal         /!=/
token                   greaterthan      />/
token                   lessthan         /</
token                   gequal           />=/
token                   lequal           /<=/
token                   plus             /\+/
token                   minus            /-/
token                   star             /\*/
token                   slash            /\//
token                   doubleslash      /\/\//
token                   lparen           /\(/
token                   rparen           /\)/
token                   lbrace           /\[/
token                   rbrace           /\]/
token                   dot              /\./
token                   lbrack           /\{/
token                   rbrack           /\}/
token                   id               /[a-zA-Z_][a-zA-Z0-9_]*/
token                   ampersand        /&/
skip                    whitespace       /[ 	
]/

precedence:

right assign
left equal notequal greaterthan lessthan gequal lequal
left plus minus
left star slash doubleslash
left lbrace
left ampersand
left dot
left id int

rules:

rule (stmt_list : empty) -> 
rule (stmt_list : list) -> (stmt : head) (stmt_list : tail)

rule (stmt : expr) -> (expr : expr) semicolon
rule (stmt : typedef) -> typedef (type : type) (id : name)
rule (stmt : funcdecl) -> (type : return_type) (id : name) lparen (formal_list : formals) rparen
                          (stmt : body)
rule (stmt : block) -> lbrack (stmt_list : stmts) rbrack
rule (stmt : return) -> return (expr : op1) semicolon
rule (stmt : if) -> if lparen (expr : condition) rparen (stmt : body)
rule (stmt : for) -> for lparen (expr : initializer) semicolon (expr : condition) semicolon
                     (expr : iteration) rparen (stmt : body)
rule (stmt : while) -> while lparen (expr : condition) rparen (stmt : body)

rule (vardecl : var) -> (type : type) (id : id)

rule (vardecl_list : empty) ->
rule (vardecl_list : list) -> (vardecl : head) semicolon (vardecl_list : tail)

rule (type : id) -> id
rule (type : struct) -> struct lbrace (vardecl_list : vardecls) rbrace
rule (type : union) -> union lbrace (vardecl_list : vardecls) rbrace
rule (type : array) -> (type : type) lbrace star rbrace

rule (formal_list : empty) ->
rule (formal_list : single) -> (vardecl : head)
rule (formal_list : list) -> (vardecl : head) comma (formal_list : tail)

rule (expr : assign) -> (expr : op1) assign (expr : op2)
rule (expr : lessthanexpr) -> (expr : op1) lessthan (expr : op2)
rule (expr : greaterthanexpr) -> (expr : op1) greaterthan (expr : op2)
rule (expr : gequalexpr) -> (expr : op1) gequal (expr : op2)
rule (expr : lequalexpr) -> (expr : op1) lequal (expr : op2)
rule (expr : equalexpr) -> (expr : op1) equal (expr : op2)
rule (expr : notequalexpr) -> (expr : op1) notequal (expr : op2)
rule (expr : plusexpr) -> (expr : op1) plus (expr : op2)
rule (expr : minusexpr) -> (expr : op1) minus (expr : op2)
rule (expr : multexpr) -> (expr : op1) star (expr : op2)
rule (expr : divexpr) -> (expr : op1) slash (expr : op2)
rule (expr : idivexpr) -> (expr : op1) doubleslash (expr : op2)
rule (expr : parenexpr) -> lparen (expr : op1) rparen
rule (expr : id) -> id
rule (expr : int) -> int 
rule (expr : string) -> string
rule (expr : arrayderef) -> (expr : array) lbrace (expr : index) rbrace
rule (expr : refderef) -> ampersand (expr : ref)
rule (expr : structderef) -> (expr : structure) dot (id : field)
rule (expr : callexpr) -> (id : name) lparen (param_list : param) rparen
rule (expr : vardeclexpr) -> (vardecl : vardecl)

rule (param_list : empty) ->
rule (param_list : single) -> (expr : head)
rule (param_list : list) -> (expr : head) comma (param_list : tail)

--- NEW FILE: regram.mnt ---
#
# Regular expression grammar
#

tokens:

token star                     /\*/
token pipe                     /\|/
token lparen                   /\(/
token rparen                   /\)/
token invlbrace                /\[^/ [setlexer = cclass]
token lbrace                   /\[/  [setlexer = cclass]
token rbrace (cclass)          /\]/  [setlexer = default]
token qmark                    /\?/
token dash   (cclass)          /-/
token esc    (cclass default)  /\\./
token lit    (cclass default)  /./

precedence:

left invlbrace lbrace rbrace lit esc lparen rparen
left star qmark
left cat
left pipe

rules:

rule (E : alt) -> (E : op1) pipe (E : op2)
rule (E : cat) -> (E : op1) (E : op2)                         [precedence = cat]
rule (E : closure) -> (E : op) star
rule (E : qmark) -> (E : op) qmark
rule (E : paren) -> lparen (E : op) rparen
rule (E : cclass ) -> lbrace (cc_data : ranges)  rbrace
rule (E : invcclass ) -> invlbrace (cc_data : ranges) rbrace
rule (E : literal) -> (literal : val)
rule (cc_data : cc_list_empty) ->
rule (cc_data : cc_list) -> (cc_elt : head) (cc_list : tail)
rule (cc_elt : single) -> (literal : val)
rule (cc_elt : range) -> (literal : min) dash (literal : max)
rule (literal : literal) -> (lit : val)
rule (literal : esclit) -> (esc : val)