[Commit] mint-2004b grammars.tex,NONE,1.1
James LaMar
commit at keithp.com
Wed Dec 1 07:15:47 PST 2004
Committed by: jlamar
Update of /local/src/CVS/mint-2004b
In directory home.keithp.com:/tmp/cvs-serv19492
Added Files:
grammars.tex
Log Message:
Added grammars.tex
--- NEW FILE: grammars.tex ---
\section{Sample Grammars}
The mint parser generator language written in the mint parser generator language.
\begin{verbatim}
tokens:
token arrow /->/
token equals /=/
token lparen /\(/
token rparen /\)/
token token_t /token/
token skip_t /skip/
token rules /rules:/
token tokens /tokens:/
token precedences /precedence:/
token precedence_t /precedence/
token left_t /left/
token right_t /right/
token nonassoc_t /nonassoc/
skip ws /[ \t\n]/
token lbrace /\[/
token rbrace /\]/
token rule_t /rule/
token id /[A-Za-z][A-Za-z0-9]*/
token colon /:/
token setlexer_t /setlexer/
skip comment /#[^\n]*/
token comma /,/
token regex /\/([^\/]|\\]\/)*\//
precedence:
rules:
#
# Top level
#
rule (S : grammar_definition) ->
tokens
(tokendecl_list : tokendecl_list)
precedences
(precdecl_list : precdecl_list)
rules
(ruledecl_list : ruledecl_list)
#
# Tokens section
#
rule (tokendecl_list : tokendecl_list_empty) ->
rule (tokendecl_list : tokendecl_list) -> (tokendecl : head) (tokendecl_list : tail)
rule (tokendecl : tokendecl) ->
token_t (id : name) (start_cond : start_cond) (regex : pattern) (lex_options : options)
rule (tokendecl : tokendecl_skip) ->
skip_t (id : name) (start_cond : start_cond) (regex : pattern) (lex_options : options)
#
# Start conditions
#
rule (start_cond : none) ->
rule (start_cond : list) -> lparen (id_list : list) rparen
#
# Per-token options
#
rule (lex_options : none) ->
rule (lex_options : list) ->
lbrace (lex_option_list : tail) rbrace
rule (lex_option_list : lex_option_single) -> (lex_option : head)
rule (lex_option_list : lex_option_list) -> (lex_option : head) comma (lex_option : tail)
rule (lex_option : psetlexer) -> setlexer_t equals (id : value)
#
# Precedence Section
#
rule (precdecl_list : precdecl_list_empty) ->
rule (precdecl_list : precdecl_list) -> (precdecl : head) (precdecl_list : tail)
rule (precdecl : pleft) -> left_t (id_list : tokens)
rule (precdecl : pright) -> right_t (id_list : tokens)
rule (precdecl : pnonassoc) -> nonassoc_t (id_list : tokens)
#
# Rules section
#
rule (ruledecl_list : empty) ->
rule (ruledecl_list : ruledecl_list) -> (ruledecl : head) (ruledecl_list : tail)
rule (ruledecl : ruledecl) ->
rule_t lparen (id : nonterminal) colon (id : type) rparen arrow (prod_list : production)
(options : options)
rule (prod_list : prod_list_empty) ->
rule (prod_list : prod_list) -> (prod_list : tail) (prod : head)
rule (prod : untagged) -> (id : symbol)
rule (prod : tagged) -> lparen (id : symbol) colon (id : name) rparen
rule (options : none) ->
rule (options : list) -> lbrace (option_list : tail) rbrace
rule (option_list : option_list_single) -> (option : head)
rule (option_list : option_list) -> (option : head) comma (option_list : tail)
rule (option : psetlexer) -> setlexer_t equals (id : value)
rule (option : pprecedence) -> precedence_t equals (id : value)
rule (id_list : id_list_single) -> (id : head)
rule (id_list : id_list) -> (id : head) (id_list : tail)
\end{verbatim}
A grammar for regular expressions which demonstrates lexer start
conditions and explicitly assigned precedence for rules.
\begin{verbatim}
#
# 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)
\end{verbatim}
This grammar represents a subset of nickle contaning function, variable
and type declarions; basic flow control; and some of the most important
forms of expression.
\begin{verbatim}
#
# A nickle subset
#
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 /&/
token comma /,/
skip whitespace /[ \t\n]/
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)
\end{verbatim}
More information about the Commit
mailing list