pas.y

早期freebsd实现

	id_list ':' type
		= $$.tr_entry = tree4(T_RFIELD, lineof($2.i_entry),
				fixlist($1.tr_entry), $3.tr_entry);
		;

variant_part:
	/* lambda */
		= $$.tr_entry = TR_NIL;
		|
	YCASE type_id YOF variant_list
		= $$.tr_entry = tree5(T_TYVARPT, lineof($1.i_entry), TR_NIL, 
				$2.tr_entry, fixlist($4.tr_entry));
		|
	YCASE YID ':' type_id YOF variant_list
		= $$.tr_entry = tree5(T_TYVARPT, lineof($1.i_entry),
				$2.tr_entry, $4.tr_entry,
					fixlist($6.tr_entry));
		;
variant_list:
	variant
		= $$.tr_entry = newlist($1.tr_entry);
		|
	variant_list ';' variant
		= $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
		|
	variant_list error
		= yyPerror("Malformed record declaration", PDECL);
		;
variant:
	/* lambda */
		= $$.tr_entry = TR_NIL;
		|
	const_list ':' '(' field_list ')'
		= $$.tr_entry = tree4(T_TYVARNT,lineof($2.i_entry), fixlist($1.tr_entry),
				$4.tr_entry);
		;

/*
 * STATEMENT LIST
 */

stat_list:
	stat
		= $$.tr_entry = newlist($1.tr_entry);
		|
	stat_lsth stat
		= {
			if ((p = $1.tr_entry) != TR_NIL && (q = p->list_node.list)->tag == T_IFX) {
				q->tag = T_IFEL;
				q->if_node.else_stmnt = $2.tr_entry;
			} else
				$$.tr_entry= addlist($1.tr_entry, $2.tr_entry);
		  }
		;

stat_lsth:
	stat_list ';'
		= if ((q = $1.tr_entry) != TR_NIL && (p = q->list_node.list) != TR_NIL && p->tag == T_IF) {
			if (yychar < 0)
				yychar = yylex();
			if (yyshifts >= 2 && yychar == YELSE) {
				recovered();
				copy((char *) (&Y), (char *) (&OY), sizeof Y);
				yerror("Deleted ';' before keyword else");
				yychar = yylex();
				p->tag = T_IFX;
			}
		  }
		;

/*
 * CASE STATEMENT LIST
 */

cstat_list:
	cstat
		= $$.tr_entry = newlist($1.tr_entry);
		|
	cstat_list ';' cstat
		= $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
		|
	error
		= {
			$$.tr_entry = TR_NIL;
Kerror:
			yyPerror("Malformed statement in case", PSTAT);
		  }
		|
	cstat_list error
		= goto Kerror;
		;

cstat:
	const_list ':' stat
		= $$.tr_entry = tree4(T_CSTAT, lineof($2.i_entry),
				fixlist($1.tr_entry), $3.tr_entry);
		|
	YCASELAB stat
		= $$.tr_entry = tree4(T_CSTAT, lineof($1.i_entry), TR_NIL,
					$2.tr_entry);
		|
	/* lambda */
		= $$.tr_entry = TR_NIL;
		;

/*
 * STATEMENT
 */

stat:
	/* lambda */
		= $$.tr_entry = TR_NIL;
		|
	YINT ':' stat
		= $$.tr_entry = tree4(T_LABEL, lineof($2.i_entry),
				$1.tr_entry == TR_NIL ? TR_NIL :
					    (struct tnode *) *hash($1.cptr, 1), $3.tr_entry);
		|
	proc_id
		= $$.tr_entry = tree4(T_PCALL, lineof(yyline), $1.tr_entry,
						TR_NIL);
		|
	proc_id '(' wexpr_list ')'
		= $$.tr_entry = tree4(T_PCALL, lineof($2.i_entry), $1.tr_entry,
					fixlist($3.tr_entry));
		|
	YID error
		= goto NSerror;
		|
	assign
		|
	YBEGIN stat_list YEND
		= {
			$$.tr_entry = tree3(T_BLOCK, lineof($1.i_entry),
						fixlist($2.tr_entry));
			if ($3.i_entry < 0)
				brerror($1.i_entry, "begin");
		  }
		|
	YCASE expr YOF cstat_list YEND
		= {
			$$.tr_entry = tree4(T_CASE, lineof($1.i_entry),
					$2.tr_entry, fixlist($4.tr_entry));
			if ($5.i_entry < 0)
				brerror($1.i_entry, "case");
		  }
		|
	YWITH var_list YDO stat
		= $$.tr_entry = tree4(T_WITH, lineof($1.i_entry),
				fixlist($2.tr_entry), $4.tr_entry);
		|
	YWHILE expr YDO stat
		= $$.tr_entry = tree4(T_WHILE, lineof($1.i_entry), $2.tr_entry,
					$4.tr_entry);
		|
	YREPEAT stat_list YUNTIL expr
		= $$.tr_entry = tree4(T_REPEAT, lineof($3.i_entry),
				fixlist($2.tr_entry), $4.tr_entry);
		|
	YFOR assign YTO expr YDO stat
		= $$.tr_entry = tree5(T_FORU, lineof($1.i_entry), $2.tr_entry,
				$4.tr_entry, $6.tr_entry);
		|
	YFOR assign YDOWNTO expr YDO stat
		= $$.tr_entry = tree5(T_FORD, lineof($1.i_entry), $2.tr_entry,
				$4.tr_entry, $6.tr_entry);
		|
	YGOTO YINT
		= $$.tr_entry = tree3(T_GOTO, lineof($1.i_entry),
				(struct tnode *) *hash($2.cptr, 1));
		|
	YIF expr YTHEN stat
		= $$.tr_entry = tree5(T_IF, lineof($1.i_entry), $2.tr_entry,
				$4.tr_entry, TR_NIL);
		|
	YIF expr YTHEN stat YELSE stat
		= $$.tr_entry = tree5(T_IFEL, lineof($1.i_entry), $2.tr_entry,
					$4.tr_entry, $6.tr_entry);
		|
	error
		= {
NSerror:
			$$.tr_entry = TR_NIL;
			yyPerror("Malformed statement", PSTAT);
		  }
		;
assign:
	variable ':' '=' expr
		= $$.tr_entry = tree4(T_ASGN, lineof($2.i_entry), $1.tr_entry,
				    $4.tr_entry);
		;

/*
 * EXPRESSION
 */

expr:
	error
		= {
NEerror:
			$$.tr_entry = TR_NIL;
			yyPerror("Missing/malformed expression", PEXPR);
		  }
		|
	expr relop expr			%prec '<'
		= $$.tr_entry = tree4($2.i_entry,
			$1.tr_entry->expr_node.const_tag == SAWCON ?
			$3.tr_entry->expr_node.const_tag :
			$1.tr_entry->expr_node.const_tag,
			$1.tr_entry, $3.tr_entry);
		|
	'+' expr			%prec UNARYSIGN
		= $$.tr_entry = tree3(T_PLUS, $2.tr_entry->expr_node.const_tag,
				$2.tr_entry);
		|
	'-' expr			%prec UNARYSIGN
		= $$.tr_entry = tree3(T_MINUS, $2.tr_entry->expr_node.const_tag,
				$2.tr_entry);
		|
	expr addop expr			%prec '+'
		= $$.tr_entry = tree4($2.i_entry,
			$1.tr_entry->expr_node.const_tag == SAWCON ?
			$3.tr_entry->expr_node.const_tag :
			$1.tr_entry->expr_node.const_tag, $1.tr_entry,
			$3.tr_entry);
		|
	expr divop expr			%prec '*'
		= $$.tr_entry = tree4($2.i_entry,
			$1.tr_entry->expr_node.const_tag == SAWCON ?
			$3.tr_entry->expr_node.const_tag :
			$1.tr_entry->expr_node.const_tag, $1.tr_entry,
			$3.tr_entry);
		|
	YNIL
		= $$.tr_entry = tree2(T_NIL, NOCON);
		|
	YSTRING
		= $$.tr_entry = tree3(T_STRNG, SAWCON, $1.tr_entry);
		|
	YINT
		= $$.tr_entry = tree3(T_INT, NOCON, $1.tr_entry);
		|
	YBINT
		= $$.tr_entry = tree3(T_BINT, NOCON, $1.tr_entry);
		|
	YNUMB
		= $$.tr_entry = tree3(T_FINT, NOCON, $1.tr_entry);
		|
	variable
		|
	YID error
		= goto NEerror;
		|
	func_id '(' wexpr_list ')'
		= $$.tr_entry = tree4(T_FCALL, NOCON, $1.tr_entry,
			fixlist($3.tr_entry));
		|
	'(' expr ')'
		= $$.tr_entry = $2.tr_entry;
		|
	negop expr			%prec YNOT
		= $$.tr_entry = tree3(T_NOT, NOCON, $2.tr_entry);
		|
	'[' element_list ']'
		= $$.tr_entry = tree3(T_CSET, SAWCON, fixlist($2.tr_entry));
		|
	'[' ']'
		= $$.tr_entry = tree3(T_CSET, SAWCON, TR_NIL);
		;

element_list:
	element
		= $$.tr_entry = newlist($1.tr_entry);
		|
	element_list ',' element
		= $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
		;
element:
	expr
		|
	expr YDOTDOT expr
		= $$.tr_entry = tree3(T_RANG, $1.i_entry, $3.tr_entry);
		;

/*
 * QUALIFIED VARIABLES
 */

variable:
	YID
		= {
			@@ return (identis(var, VAR));
			$$.tr_entry = setupvar($1.cptr, TR_NIL);
		  }
		|
	qual_var
		= $1.tr_entry->var_node.qual = 
					fixlist($1.tr_entry->var_node.qual);
		;
qual_var:
	array_id '[' expr_list ']'
		= $$.tr_entry = setupvar($1.cptr, tree2(T_ARY, 
				(int) fixlist($3.tr_entry)));
		|
	qual_var '[' expr_list ']'
		= $1.tr_entry->var_node.qual =
				addlist($1.tr_entry->var_node.qual,
				tree2(T_ARY, (int) fixlist($3.tr_entry)));
		|
	record_id '.' field_id
		= $$.tr_entry = setupvar($1.cptr, setupfield($3.tr_entry,
							TR_NIL));
		|
	qual_var '.' field_id
		= $1.tr_entry->var_node.qual =
		    addlist($1.tr_entry->var_node.qual,
		    setupfield($3.tr_entry, TR_NIL));
		|
	ptr_id '^'
		= $$.tr_entry = setupvar($1.cptr, tree1(T_PTR));
		|
	qual_var '^'
		= $1.tr_entry->var_node.qual = 
			addlist($1.tr_entry->var_node.qual, tree1(T_PTR));
		;

/*
 * Expression with write widths
 */
wexpr:
	expr
		|
	expr ':' expr
		= $$.tr_entry = tree4(T_WEXP, $1.i_entry, $3.tr_entry, TR_NIL);
		|
	expr ':' expr ':' expr
		= $$.tr_entry = tree4(T_WEXP, $1.i_entry, $3.tr_entry,
						$5.tr_entry);
		|
	expr octhex
		= $$.tr_entry = tree4(T_WEXP, $1.i_entry, TR_NIL, $2.tr_entry);
		|
	expr ':' expr octhex
		= $$.tr_entry = tree4(T_WEXP, $1.i_entry, $3.tr_entry,
					$4.tr_entry);
		;
octhex:
	YOCT
		= $$.i_entry = OCT;
		|
	YHEX
		= $$.i_entry = HEX;
		;

expr_list:
	expr
		= $$.tr_entry = newlist($1.tr_entry);
		|
	expr_list ',' expr
		= $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
		;

wexpr_list:
	wexpr
		= $$.tr_entry = newlist($1.tr_entry);
		|
	wexpr_list ',' wexpr
		= $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
		;

/*
 * OPERATORS
 */

relop:
	'='	= $$.i_entry = T_EQ;
		|
	'<'	= $$.i_entry = T_LT;
		|
	'>'	= $$.i_entry = T_GT;
		|
	'<' '>'	= $$.i_entry = T_NE;
		|
	'<' '='	= $$.i_entry = T_LE;
		|
	'>' '='	= $$.i_entry = T_GE;
		|
	YIN	= $$.i_entry = T_IN;
		;
addop:
	'+'	= $$.i_entry = T_ADD;
		|
	'-'	= $$.i_entry = T_SUB;
		|
	YOR	= $$.i_entry = T_OR;
		|
	'|'	= $$.i_entry = T_OR;
		;
divop:
	'*'	= $$.i_entry = T_MULT;
		|
	'/'	= $$.i_entry = T_DIVD;
		|
	YDIV	= $$.i_entry = T_DIV;
		|
	YMOD	= $$.i_entry = T_MOD;
		|
	YAND	= $$.i_entry = T_AND;
		|
	'&'	= $$.i_entry = T_AND;
		;

negop:
	YNOT
		|
	'~'
		;

/*
 * LISTS
 */

var_list:
	variable
		= $$.tr_entry = newlist($1.tr_entry);
		|
	var_list ',' variable
		= $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
		;

id_list:
	YID
		= $$.tr_entry = newlist($1.tr_entry);
		|
	id_list ',' YID
		= $$.tr_entry = addlist($1.tr_entry, $3.tr_entry);
		;

/*
 * Identifier productions with semantic restrictions
 *
 * For these productions, the characters @@ signify
 * that the associated C statement is to provide
 * the semantic restriction for this reduction.
 * These lines are made into a procedure yyEactr, similar to
 * yyactr, which determines whether the corresponding reduction
 * is permitted, or whether an error is to be signaled.
 * A zero return from yyEactr is considered an error.
 * YyEactr is called with an argument "var" giving the string
 * name of the variable in question, essentially $1, although
 * $1 will not work because yyEactr is called from loccor in
 * the recovery routines.
 */

const_id:
	YID
		= @@ return (identis(var, CONST));
		;
type_id:
	YID
		= {
			@@ return (identis(var, TYPE));
			$$.tr_entry = tree3(T_TYID, lineof(yyline), $1.tr_entry);
		  }
		;
var_id:
	YID
		= @@ return (identis(var, VAR));
		;
array_id:
	YID
		= @@ return (identis(var, ARRAY));
		;
ptr_id:
	YID
		= @@ return (identis(var, PTRFILE));
		;
record_id:
	YID
		= @@ return (identis(var, RECORD));
		;
field_id:
	YID
		= @@ return (identis(var, FIELD));
		;
proc_id:
	YID
		= @@ return (identis(var, PROC));
		;
func_id:
	YID
		= @@ return (identis(var, FUNC));
		;