[Commit] mint-2004b grammars.tex, 1.1, 1.2 mint.tex, 1.4,
1.5 nickle.tex, 1.4, 1.5 translators.tex, 1.1, 1.2
Bart Massey
commit at keithp.com
Wed Dec 1 15:00:44 PST 2004
Committed by: bart
Update of /local/src/CVS/mint-2004b
In directory home.keithp.com:/tmp/cvs-serv27424
Modified Files:
grammars.tex mint.tex nickle.tex translators.tex
Log Message:
Lots of editing. Got grammar section working nicely.
Index: grammars.tex
===================================================================
RCS file: /local/src/CVS/mint-2004b/grammars.tex,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- grammars.tex 1 Dec 2004 15:15:44 -0000 1.1
+++ grammars.tex 1 Dec 2004 23:00:41 -0000 1.2
@@ -1,34 +1,88 @@
-\section{Sample Grammars}
+\renewcommand{\baselinestretch}{0.9}
+\begin{twocolumn}%
+\section*{Appendix: Grammars}
+This section contains several MINT sample
+grammars in no particular order. It should give a good idea
+of the available possibilities of MINT.
-The mint parser generator language written in the mint parser generator language.
+\mysep
+
+\par\noindent A simple grammar for expressions.\label{gram-expr}
+\begingroup\scriptsize
\begin{verbatim}
+#
+# The canonical expression grammar
+# (with precedence)
+#
+#
+# Token section
+#
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 /\/([^\/]|\\]\/)*\//
+token plus /\+/
+token mult /\*/
+token lparen /\(/
+token rparen /\)/
+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 : name)
+rule (E : parenexpr) ->
+ lparen (E : sub) rparen
+\end{verbatim}
+\endgroup
+
+\mysep
+
+\par\noindent The MINT parser generator language written in the MINT
+parser generator language.
+
+\begingroup\scriptsize
+\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:
@@ -50,98 +104,131 @@
# Tokens section
#
rule (tokendecl_list : tokendecl_list_empty) ->
-rule (tokendecl_list : tokendecl_list) -> (tokendecl : head) (tokendecl_list : tail)
+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)
+ 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)
+ 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
+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
+ 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_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)
+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_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)
+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_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_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_list : prod_list) ->
+ (prod_list : tail) (prod : head)
rule (prod : untagged) -> (id : symbol)
-rule (prod : tagged) -> lparen (id : symbol) colon (id : name) rparen
+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 (options : list) ->
+ lbrace (option_list : tail) rbrace
-rule (option : psetlexer) -> setlexer_t equals (id : value)
-rule (option : pprecedence) -> precedence_t equals (id : value)
+rule (option_list :
+ option_list_single) -> (option : head)
+rule (option_list :
+ option_list) ->
+ (option : head) comma
+ (option_list : tail)
-rule (id_list : id_list_single) -> (id : head)
-rule (id_list : id_list) -> (id : head) (id_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}
+\endgroup
-A grammar for regular expressions which demonstrates lexer start
+\mysep
+
+\par\noindent A grammar for regular expressions which demonstrates lexer start
conditions and explicitly assigned precedence for rules.
+\begingroup\scriptsize
\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) /./
+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 invlbrace lbrace rbrace lit
+ esc lparen rparen
left star qmark
left cat
left pipe
@@ -149,74 +236,84 @@
rules:
rule (E : alt) -> (E : op1) pipe (E : op2)
-rule (E : cat) -> (E : op1) (E : op2) [precedence = cat]
+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 : 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_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 (cc_elt : range) ->
+ (literal : min) dash (literal : max)
rule (literal : literal) -> (lit : val)
rule (literal : esclit) -> (esc : val)
-
\end{verbatim}
+\endgroup
-This grammar represents a subset of nickle contaning function, variable
+\mysep
+
+\par\noindent 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.
+\begingroup\scriptsize
\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]/
+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 equal notequal greaterthan
+ lessthan gequal lequal
left plus minus
left star slash doubleslash
left lbrace
@@ -227,56 +324,106 @@
rules:
rule (stmt_list : empty) ->
-rule (stmt_list : list) -> (stmt : head) (stmt_list : tail)
+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 (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 : var) ->
+ (type : type) (id : id)
rule (vardecl_list : empty) ->
-rule (vardecl_list : list) -> (vardecl : head) semicolon (vardecl_list : tail)
+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 (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 (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 : 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 (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)
+rule (param_list : single) ->
+ (expr : head)
+rule (param_list : list) ->
+ (expr : head) comma
+ (param_list : tail)
\end{verbatim}
+\endgroup
+\end{twocolumn}
Index: mint.tex
===================================================================
RCS file: /local/src/CVS/mint-2004b/mint.tex,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- mint.tex 1 Dec 2004 19:17:37 -0000 1.4
+++ mint.tex 1 Dec 2004 23:00:41 -0000 1.5
@@ -7,6 +7,8 @@
\usepackage{prentcsmacro}
\usepackage{epic,eepic}
+\newcommand{\mysep}{\par\noindent\rule{0.75in}{0.5pt}\\}
+
\def\lastname{Kuo, LaMar, Massey, Packard}
\begin{document}
@@ -42,4 +44,7 @@
\bibliographystyle{entcs}
\bibliography{mint}
+
+\input{grammars}
+
\end{document}
Index: nickle.tex
===================================================================
RCS file: /local/src/CVS/mint-2004b/nickle.tex,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- nickle.tex 1 Dec 2004 21:55:55 -0000 1.4
+++ nickle.tex 1 Dec 2004 23:00:41 -0000 1.5
@@ -114,5 +114,5 @@
Nickle function from an existing application places
significant demands on the application developer.
The Nickle parser generator has thus been factored from the
-parsing runtime as discussed in section~\ref{sec-mint},
+parsing runtime as discussed in section~\ref{sec-tool},
overcoming these difficulties.
Index: translators.tex
===================================================================
RCS file: /local/src/CVS/mint-2004b/translators.tex,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- translators.tex 1 Dec 2004 19:17:37 -0000 1.1
+++ translators.tex 1 Dec 2004 23:00:41 -0000 1.2
@@ -29,44 +29,6 @@
A few examples may clarify things:
-\begin{verbatim}
-
-#
-# The canonical expression grammar (with precedence)
-#
-
-#
-# Token section
-#
-tokens:
-
-token plus /\+/
-token mult /\*/
-token lparen /\(/
-token rparen /\)/
-token id /[A-Za-z0-9]/
-skip whitespace /[ ]/ # 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 : name)
-rule (E : parenexpr) -> lparen (E : sub) rparen
-
-\end{verbatim}
-
In this example, there is one nonterminal (E) with four productions.
Addition and multiplication are binary operators in which the left
operand is tagged ``op1'' and the right is tagged ``op2''. Both the
More information about the Commit
mailing list