--- /dev/null
+/**************************************************************************
+* File: hsparser.y *
+* *
+* Author: Maria M. Gutierrez *
+* Modified by: Kevin Hammond *
+* Last date revised: December 13 1991. KH. *
+* Modification: o Haskell 1.1 Syntax. *
+* o Data Parallel Syntax. *
+* *
+* *
+* Description: This file contains the LALR(1) grammar for Haskell. *
+* *
+* Entry Point: module *
+* *
+* Problems: None known. *
+* *
+* *
+* LALR(1) Syntax for Haskell 1.2 + Data Parallelism *
+* *
+**************************************************************************/
+
+
+%{
+#ifdef DEBUG
+# define YYDEBUG 1
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include "hspincl.h"
+#include "constants.h"
+#include "utils.h"
+
+
+
+/**********************************************************************
+* *
+* *
+* Imported Variables and Functions *
+* *
+* *
+**********************************************************************/
+
+extern BOOLEAN nonstandardFlag;
+extern BOOLEAN expect_ccurly;
+extern BOOLEAN etags;
+
+extern BOOLEAN ispatt PROTO((tree, BOOLEAN));
+extern tree function PROTO((tree));
+
+static char modname[MODNAME_SIZE];
+static char *the_module_name;
+static char iface_name[MODNAME_SIZE];
+static char interface_filename[FILENAME_SIZE];
+
+static list module_exports; /* Exported entities */
+static list prelude_imports; /* Entities imported from the Prelude */
+
+extern list all; /* All valid deriving classes */
+
+extern tree niltree;
+extern list Lnil;
+
+extern tree root;
+
+/* For FN, PREVPATT and SAMEFN macros */
+extern tree fns[];
+extern short samefn[];
+extern tree prevpatt[];
+extern short icontexts;
+
+
+/* Line Numbers */
+extern int hsplineno;
+extern int startlineno;
+
+/**********************************************************************
+* *
+* *
+* Fixity and Precedence Declarations *
+* *
+* *
+**********************************************************************/
+
+list fixlist;
+static int Fixity = 0, Precedence = 0;
+struct infix;
+
+char *ineg();
+
+static BOOLEAN hidden = FALSE; /* Set when HIDING used */
+
+extern BOOLEAN inpat; /* True when parsing a pattern */
+extern BOOLEAN implicitPrelude; /* True when we should read the Prelude if not given */
+
+%}
+
+%union {
+ tree utree;
+ list ulist;
+ ttype uttype;
+ atype uatype;
+ binding ubinding;
+ pbinding upbinding;
+ finfot ufinfo;
+ impidt uimpid;
+ entidt uentid;
+ id uid;
+ int uint;
+ float ufloat;
+ char *ustring;
+ hpragma uhpragma;
+}
+
+
+/**********************************************************************
+* *
+* *
+* These are lexemes. *
+* *
+* *
+**********************************************************************/
+
+
+%token VARID CONID
+ VARSYM CONSYM MINUS
+
+%token INTEGER FLOAT CHAR STRING
+ CHARPRIM INTPRIM FLOATPRIM DOUBLEPRIM
+ CLITLIT VOIDPRIM
+
+
+
+/**********************************************************************
+* *
+* *
+* Special Symbols *
+* *
+* *
+**********************************************************************/
+
+%token OCURLY CCURLY VCCURLY SEMI
+%token OBRACK CBRACK OPAREN CPAREN
+%token COMMA BQUOTE
+%token OPOD CPOD OPROC CPROC
+
+
+/**********************************************************************
+* *
+* *
+* Reserved Operators *
+* *
+* *
+**********************************************************************/
+
+%token RARROW
+%token VBAR EQUAL DARROW DOTDOT
+%token DCOLON LARROW
+%token WILDCARD AT LAZY LAMBDA
+%token DRAWNFROM INDEXFROM
+
+
+/**********************************************************************
+* *
+* *
+* Reserved Identifiers *
+* *
+* *
+**********************************************************************/
+
+%token LET IN
+%token WHERE CASE OF
+%token TYPE DATA CLASS INSTANCE DEFAULT
+%token INFIX INFIXL INFIXR
+%token MODULE IMPORT INTERFACE HIDING
+%token CCALL CCALL_DANGEROUS CASM CASM_DANGEROUS SCC
+
+%token IF THEN ELSE
+%token RENAMING DERIVING TO
+
+/**********************************************************************
+* *
+* *
+* Special Symbols for the Lexer *
+* *
+* *
+**********************************************************************/
+
+%token LEOF
+%token ARITY_PRAGMA SPECIALIZE_PRAGMA STRICTNESS_PRAGMA UPDATE_PRAGMA
+%token END_PRAGMA
+
+/**********************************************************************
+* *
+* *
+* Precedences of the various tokens *
+* *
+* *
+**********************************************************************/
+
+
+%left CASE LET IN LAMBDA
+ IF ELSE CCALL CCALL_DANGEROUS
+ CASM CASM_DANGEROUS SCC AT
+
+%left VARSYM CONSYM PLUS MINUS BQUOTE
+
+%left DCOLON
+
+%left SEMI COMMA
+
+%left OCURLY OBRACK OPAREN
+
+%left OPOD OPROC
+
+%left EQUAL
+
+%right DARROW
+%right RARROW
+
+
+
+/**********************************************************************
+* *
+* *
+* Type Declarations *
+* *
+* *
+**********************************************************************/
+
+
+%type <ulist> alt alts altrest quals vars varsrest cons
+ tyvars constrs dtypes types atypes
+ exps pats context context_list tyvar_list
+ maybeexports export_list
+ impspec maybeimpspec import_list
+ impdecls maybeimpdecls impdecl
+ renaming renamings renaming_list
+ tyclses tycls_list
+ gdrhs gdpat valrhs valrhs1
+ lampats
+ upto
+ cexp
+ tyvar_pids
+ parquals
+ pragmas
+
+
+%type <utree> exp dexp fexp kexp oexp aexp literal
+ tuple list sequence comprehension qual qualrest
+ gd
+ apat bpat pat apatc conpat dpat fpat opat aapat
+ dpatk fpatk opatk aapatk
+ texps
+ processor parqual
+
+%type <uid> MINUS VARID CONID VARSYM CONSYM
+ var vark con conk varop varop1 conop op op1
+ varid conid varsym consym minus plus
+ tycls tycon modid ccallid
+
+%type <ubinding> topdecl topdecls
+ typed datad classd instd defaultd
+ decl decls valdef valdefs sign
+ iimport iimports maybeiimports
+ ityped idatad iclassd iinstd ivarsd
+ itopdecl itopdecls
+ maybe_where
+ interface readinterface ibody
+ cbody rinst
+ impdecl_rest
+
+%type <uttype> simple simple_long type atype btype ttype ntatype inst class
+ tyvar
+
+%type <uatype> constr
+
+%type <ustring> STRING FLOAT INTEGER CHARPRIM INTPRIM FLOATPRIM DOUBLEPRIM CLITLIT VOIDPRIM
+%type <uint> CHAR
+%type <uentid> export import
+%type <uhpragma> pragma
+
+
+/**********************************************************************
+* *
+* *
+* Start Symbol for the Parser *
+* *
+* *
+**********************************************************************/
+
+%start pmodule
+
+
+%%
+
+pmodule : readprelude module
+ ;
+
+module : MODULE modid maybeexports
+ { the_module_name = $2; module_exports = $3; }
+ WHERE body
+ | { the_module_name = install_literal("Main"); module_exports = Lnil; }
+ body
+ ;
+
+body : ocurly maybeimpdecls maybefixes topdecls ccurly
+ {
+ root = mkhmodule(the_module_name,lconc(prelude_imports,$2),module_exports,$4);
+ }
+ | vocurly maybeimpdecls maybefixes topdecls vccurly
+ {
+ root = mkhmodule(the_module_name,lconc(prelude_imports,$2),module_exports,$4);
+ }
+
+ | vocurly impdecls vccurly
+ {
+ root = mkhmodule(the_module_name,lconc(prelude_imports,$2),module_exports,mknullbind());
+ }
+ | ocurly impdecls ccurly
+ {
+ root = mkhmodule(the_module_name,lconc(prelude_imports,$2),module_exports,mknullbind());
+ }
+
+/* Adds 1 S/R, 2 R/R conflicts, alternatives add 3 R/R conflicts */
+ | vocurly maybeimpdecls vccurly
+ {
+ root = mkhmodule(the_module_name,lconc(prelude_imports,$2),module_exports,mknullbind());
+ }
+ | ocurly maybeimpdecls ccurly
+ {
+ root = mkhmodule(the_module_name,lconc(prelude_imports,$2),module_exports,mknullbind());
+ }
+ ;
+
+
+maybeexports : /* empty */ { $$ = Lnil; }
+ | OPAREN export_list CPAREN { $$ = $2; }
+ ;
+
+export_list:
+ export { $$ = lsing($1); }
+ | export_list COMMA export { $$ = lapp($1,$3); }
+ ;
+
+export :
+ var { $$ = mkentid($1); }
+ | tycon { $$ = mkenttype($1); }
+ | tycon OPAREN DOTDOT CPAREN { $$ = mkenttypeall($1); }
+ | tycon OPAREN cons CPAREN
+ { $$ = mkenttypecons($1,$3);
+ /* should be a datatype with cons representing all constructors */
+ }
+ | tycon OPAREN vars CPAREN
+ { $$ = mkentclass($1,$3);
+ /* should be a class with vars representing all Class operations */
+ }
+ | tycon OPAREN CPAREN
+ { $$ = mkentclass($1,Lnil);
+ /* "tycon" should be a class with no operations */
+ }
+ | tycon DOTDOT
+ { $$ = mkentmod($1);
+ /* "tycon" is a module id (but "modid" is bad for your identifier's health [KH]) */
+ }
+ ;
+
+
+impspec : OPAREN import_list CPAREN { $$ = $2; hidden = FALSE; }
+ | HIDING OPAREN import_list CPAREN { $$ = $3; hidden = TRUE; }
+ | OPAREN CPAREN { $$ = Lnil; hidden = FALSE; }
+ ;
+
+maybeimpspec : /* empty */ { $$ = Lnil; }
+ | impspec { $$ = $1; }
+ ;
+
+import_list:
+ import { $$ = lsing($1); }
+ | import_list COMMA import { $$ = lapp($1,$3); }
+ ;
+
+import :
+ var { $$ = mkentid($1); }
+ | tycon { $$ = mkenttype($1); }
+ | tycon OPAREN DOTDOT CPAREN { $$ = mkenttypeall($1); }
+ | tycon OPAREN cons CPAREN
+ { $$ = mkenttypecons($1,$3);
+ /* should be a datatype with cons representing all constructors */
+ }
+ | tycon OPAREN vars CPAREN
+ { $$ = mkentclass($1,$3);
+ /* should be a class with vars representing all Class operations */
+ }
+ | tycon OPAREN CPAREN
+ { $$ = mkentclass($1,Lnil);
+ /* "tycon" should be a class with no operations */
+ }
+ ;
+
+
+pragmas:
+ pragma { $$ = lsing($1); }
+ | pragmas pragma { $$ = lapp($1,$2); }
+ | /* empty */ { $$ = Lnil; }
+ ;
+
+pragma:
+ ARITY_PRAGMA var EQUAL INTEGER END_PRAGMA
+ { $$ = mkarity_pragma($2,$4); }
+
+ | SPECIALIZE_PRAGMA var EQUAL ivarsd END_PRAGMA
+ { $$ = mkspecialize_pragma($2, $4); }
+
+ | STRICTNESS_PRAGMA var EQUAL STRING pragmas END_PRAGMA
+ { $$ = mkstrictness_pragma($2, $4, $5); }
+
+ | UPDATE_PRAGMA var EQUAL INTEGER END_PRAGMA
+ { $$ = mkupdate_pragma($2, $4); }
+ ;
+
+
+readprelude :
+ {
+ if ( implicitPrelude ) {
+ find_module_on_imports_dirlist("Prelude",TRUE,interface_filename);
+ } else {
+ find_module_on_imports_dirlist("PreludeNull_",TRUE,interface_filename);
+ }
+ setyyin(interface_filename);
+ enteriscope();
+ }
+ readinterface
+ {
+ binding prelude = mkimport(installid(iface_name),Lnil,Lnil,$2,xstrdup(interface_filename),hsplineno);
+ prelude_imports = implicitPrelude? lsing(prelude): Lnil;
+ }
+ ;
+
+maybeimpdecls : /* empty */ { $$ = Lnil; }
+ | impdecls SEMI { $$ = $1; }
+ ;
+
+impdecls: impdecl { $$ = $1; }
+ | impdecls SEMI impdecl { $$ = lconc($1,$3); }
+ ;
+
+impdecl : IMPORT modid
+ { /* filename returned in "interface_filename" */
+ char *module_name = id_to_string($2);
+ find_module_on_imports_dirlist(module_name,FALSE,interface_filename);
+ setyyin(interface_filename);
+ enteriscope();
+ if(strcmp(module_name,"Prelude")==0)
+ prelude_imports = Lnil;
+ }
+ impdecl_rest
+ {
+ if (hidden)
+ $4->tag = hiding;
+ $$ = lsing($4);
+ }
+
+impdecl_rest:
+ readinterface maybeimpspec
+ { $$ = mkimport(installid(iface_name),$2,Lnil,$1,xstrdup(interface_filename),hsplineno); }
+ /* WDP: uncertain about those hsplinenos */
+ | readinterface maybeimpspec RENAMING renamings
+ { $$ = mkimport(installid(iface_name),$2,$4,$1,xstrdup(interface_filename),hsplineno); }
+ ;
+
+readinterface:
+ interface LEOF
+ {
+ exposeis(); /* partain: expose infix ops at level i+1 to level i */
+ $$ = $1;
+ }
+ ;
+
+renamings: OPAREN renaming_list CPAREN { $$ = $2; }
+ ;
+
+renaming_list: renaming { $$ = lsing($1); }
+ | renaming_list COMMA renaming { $$ = lapp($1,$3); }
+ ;
+
+renaming: var TO var { $$ = ldub($1,$3); }
+ | con TO con { $$ = ldub($1,$3); }
+ ;
+
+maybeiimports : /* empty */ { $$ = mknullbind(); }
+ | iimports SEMI { $$ = $1; }
+ ;
+
+iimports : iimports SEMI iimport { $$ = mkabind($1,$3); }
+ | iimport { $$ = $1; }
+ ;
+
+iimport : importkey modid OPAREN import_list CPAREN
+ { $$ = mkmbind($2,$4,Lnil,startlineno); }
+ | importkey modid OPAREN import_list CPAREN RENAMING renamings
+ { $$ = mkmbind($2,$4,$7,startlineno); }
+ ;
+
+
+interface:
+ INTERFACE modid
+ { fixlist = Lnil;
+ strcpy(iface_name, id_to_string($2));
+ }
+ WHERE ibody
+ {
+ /* WDP: not only do we not check the module name
+ but we take the one in the interface to be what we really want
+ -- we need this for Prelude jiggery-pokery. (Blech. KH)
+ ToDo: possibly revert....
+ checkmodname(modname,id_to_string($2));
+ */
+ $$ = $5;
+ }
+ ;
+
+
+ibody : ocurly maybeiimports maybefixes itopdecls ccurly
+ {
+ $$ = mkabind($2,$4);
+ }
+ | ocurly iimports ccurly
+ {
+ $$ = $2;
+ }
+ | vocurly maybeiimports maybefixes itopdecls vccurly
+ {
+ $$ = mkabind($2,$4);
+ }
+ | vocurly iimports vccurly
+ {
+ $$ = $2;
+ }
+ ;
+
+maybefixes: /* empty */
+ | fixes SEMI
+ ;
+
+
+fixes : fixes SEMI fix
+ | fix
+ ;
+
+fix : INFIXL INTEGER
+ { Precedence = checkfixity($2); Fixity = INFIXL; }
+ ops
+ | INFIXR INTEGER
+ { Precedence = checkfixity($2); Fixity = INFIXR; }
+ ops
+ | INFIX INTEGER
+ { Precedence = checkfixity($2); Fixity = INFIX; }
+ ops
+ | INFIXL
+ { Fixity = INFIXL; Precedence = 9; }
+ ops
+ | INFIXR
+ { Fixity = INFIXR; Precedence = 9; }
+ ops
+ | INFIX
+ { Fixity = INFIX; Precedence = 9; }
+ ops
+ ;
+
+ops : op { makeinfix(id_to_string($1),Fixity,Precedence); }
+ | ops COMMA op { makeinfix(id_to_string($3),Fixity,Precedence); }
+ ;
+
+topdecls: topdecls SEMI topdecl
+ {
+ if($1 != NULL)
+ if($3 != NULL)
+ if(SAMEFN)
+ {
+ extendfn($1,$3);
+ $$ = $1;
+ }
+ else
+ $$ = mkabind($1,$3);
+ else
+ $$ = $1;
+ else
+ $$ = $3;
+ SAMEFN = 0;
+ }
+ | topdecl
+ ;
+
+topdecl : typed { $$ = $1; }
+ | datad { $$ = $1; }
+ | classd { $$ = $1; }
+ | instd { $$ = $1; }
+ | defaultd { $$ = $1; }
+ | decl { $$ = $1; }
+ ;
+
+typed : typekey simple EQUAL type { $$ = mknbind($2,$4,startlineno,mkno_pramga()); }
+ ;
+
+
+datad : datakey context DARROW simple EQUAL constrs
+ { $$ = mktbind($2,$4,$6,all,startlineno,mkno_pragma()); }
+ | datakey simple EQUAL constrs
+ { $$ = mktbind(Lnil,$2,$4,all,startlineno,mkno_pragma()); }
+ | datakey context DARROW simple EQUAL constrs DERIVING tyclses
+ { $$ = mktbind($2,$4,$6,$8,startlineno,mkno_pragma()); }
+ | datakey simple EQUAL constrs DERIVING tyclses
+ { $$ = mktbind(Lnil,$2,$4,$6,startlineno,mkno_pragma()); }
+ ;
+
+classd : classkey context DARROW class cbody { $$ = mkcbind($2,$4,$5,startlineno,Lnil); }
+ | classkey class cbody { $$ = mkcbind(Lnil,$2,$3,startlineno,Lnil); }
+ ;
+
+cbody : /* empty */ { $$ = mknullbind(); }
+ | WHERE ocurly decls ccurly { checkorder($3); $$ = $3; }
+ | WHERE vocurly decls vccurly { checkorder($3); $$ =$3; }
+ ;
+
+
+instd : instkey context DARROW tycls inst rinst { $$ = mkibind($2,$4,$5,$6,startlineno,Lnil); }
+ | instkey tycls inst rinst { $$ = mkibind(Lnil,$2,$3,$4,startlineno,Lnil); }
+ ;
+
+rinst : /* empty */ { $$ = mknullbind(); }
+ | WHERE ocurly valdefs ccurly { $$ = $3; }
+ | WHERE vocurly valdefs vccurly { $$ = $3; }
+ ;
+
+inst : tycon { $$ = mktname($1,Lnil); }
+ | OPAREN simple_long CPAREN { $$ = $2; }
+ /* partain?: "simple" requires k >= 0, not k > 0 (hence "simple_long" hack) */
+ | OPAREN tyvar_list CPAREN { $$ = mkttuple($2); }
+ | OPAREN CPAREN { $$ = mkttuple(Lnil); }
+ | OBRACK tyvar CBRACK { $$ = mktllist($2); }
+ | OPAREN tyvar RARROW tyvar CPAREN { $$ = mktfun($2,$4); }
+ | OPOD tyvar CPOD { $$ = mktpod($2); }
+ | OPROC tyvar_pids SEMI tyvar CPROC { $$ = mktproc($2,$4); }
+ | OPOD tyvar_pids SEMI tyvar CPOD { $$ = mktpod(mktproc($2,$4));}
+ | OPOD OPROC tyvar_pids SEMI tyvar CPROC CPOD
+ { $$ = mktpod(mktproc($3,$5)); }
+ ;
+
+/* Note (hilly) : Similar to tyvar_list except k>=1 not k>=2 */
+
+tyvar_pids : tyvar COMMA tyvar_pids { $$ = mklcons($1,$3); }
+ | tyvar { $$ = lsing($1); }
+ ;
+
+defaultd: defaultkey dtypes
+ {
+ $$ = mkdbind($2,startlineno);
+ }
+ ;
+
+dtypes : OPAREN type COMMA types CPAREN { $$ = mklcons($2,$4); }
+ | ttype { $$ = lsing($1); }
+/* Omitting this forces () to be the *type* (), which never defaults. This is a KLUDGE */
+/* | OPAREN CPAREN { $$ = Lnil; }*/
+ ;
+
+decls : decls SEMI decl
+ {
+ if(SAMEFN)
+ {
+ extendfn($1,$3);
+ $$ = $1;
+ }
+ else
+ $$ = mkabind($1,$3);
+ }
+ | decl
+ ;
+
+/* partain: this "DCOLON context" vs "DCOLON type" is a problem,
+ because you can't distinguish between
+
+ foo :: (Baz a, Baz a)
+ bar :: (Baz a, Baz a) => [a] -> [a] -> [a]
+
+ with one token of lookahead. The HACK is to have "DCOLON ttype"
+ [tuple type] in the first case, then check that it has the right
+ form C a, or (C1 a, C2 b, ... Cn z) and convert it into a
+ context. Blaach!
+ (FIXED 90/06/06)
+*/
+
+decl : vars DCOLON type DARROW type iclasop_pragma
+ { /* type2context.c for code */
+ $$ = mksbind($1,mkcontext(type2context($3),$5),startlineno,$6);
+ PREVPATT = NULL;
+ FN = NULL;
+ SAMEFN = 0;
+ }
+ | sign
+ | valdef
+ | /* empty */ { $$ = mknullbind(); PREVPATT = NULL; FN = NULL; SAMEFN = 0; }
+ ;
+
+sign : vars DCOLON type iclasop_pragma
+ {
+ $$ = mksbind($1,$3,startlineno,$4);
+ PREVPATT = NULL;
+ FN = NULL;
+ SAMEFN = 0;
+ }
+ ;
+
+
+
+itopdecls : itopdecls SEMI itopdecl { $$ = mkabind($1,$3); }
+ | itopdecl { $$ = $1; }
+ ;
+
+itopdecl: ityped { $$ = $1; }
+ | idatad { $$ = $1; }
+ | iclassd { $$ = $1; }
+ | iinstd { $$ = $1; }
+ | ivarsd { $$ = $1; }
+ | /* empty */ { $$ = mknullbind(); }
+ ;
+
+ /* partain: see comment elsewhere about why "type", not "context" */
+ivarsd : vars DCOLON type DARROW type ival_pragma
+ { $$ = mksbind($1,mkcontext(type2context($3),$5),startlineno,$6); }
+ | vars DCOLON type ival_pragma
+ { $$ = mksbind($1,$3,startlineno,$4); }
+ ;
+
+ityped : typekey simple EQUAL type itype_pragma { $$ = mknbind($2,$4,startlineno,$5); }
+ ;
+
+idatad : datakey context DARROW simple idata_pragma { $$ = mktbind($2,$4,Lnil,Lnil,startlineno,$5); }
+ | datakey simple idata_pragma { $$ = mktbind(Lnil,$2,Lnil,Lnil,startlineno,$3); }
+ | datakey context DARROW simple EQUAL constrs { $$ = mktbind($2,$4,$6,Lnil,startlineno,mk_nopragma()); }
+ | datakey simple EQUAL constrs { $$ = mktbind(Lnil,$2,$4,Lnil,startlineno,mk_nopragma()); }
+ | datakey context DARROW simple EQUAL constrs DERIVING tyclses { $$ = mktbind($2,$4,$6,$8,startlineno,mk_nopragma()); }
+ | datakey simple EQUAL constrs DERIVING tyclses { $$ = mktbind(Lnil,$2,$4,$6,startlineno,mk_nopragma()); }
+ ;
+
+
+iclassd : classkey context DARROW class cbody pragmas
+ { $$ = mkcbind($2,$4,$5,startlineno,$6); }
+ | classkey class cbody pragmas
+ { $$ = mkcbind(Lnil,$2,$3,startlineno,$4); }
+ ;
+
+iinstd : instkey context DARROW tycls inst pragmas
+ { $$ = mkibind($2,$4,$5,mknullbind(),startlineno,$6); }
+ | instkey tycls inst pragmas
+ { $$ = mkibind(Lnil,$2,$3,mknullbind(),startlineno,$4); }
+ ;
+
+
+/* obsolete: "(C a, ...)" cause r/r conflict, resolved in favour of context rather than type */
+
+class : tycon tyvar { $$ = mktname($1,lsing($2)); }
+ /* partain: changed "tycls" to "tycon" */
+ ;
+
+types : types COMMA type { $$ = lapp($1,$3); }
+ | type { $$ = lsing($1); }
+ ;
+
+type : btype { $$ = $1; }
+ | btype RARROW type { $$ = mktfun($1,$3); }
+
+btype : atype { $$ = $1; }
+ | tycon atypes { $$ = mktname($1,$2); }
+ ;
+
+atypes : atypes atype { $$ = lapp($1,$2); }
+ | atype { $$ = lsing($1); }
+ ;
+
+/* The split with ntatype allows us to use the same syntax for defaults as for types */
+ttype : ntatype { $$ = $1; }
+ | btype RARROW type { $$ = mktfun($1,$3); }
+ | tycon atypes { $$ = mktname($1,$2); }
+ ;
+
+atype : ntatype
+ | OPAREN type COMMA types CPAREN { $$ = mkttuple(mklcons($2,$4)); }
+ ;
+
+ntatype : tyvar { $$ = $1; }
+ | tycon { $$ = mktname($1,Lnil); }
+ | OPAREN CPAREN { $$ = mkttuple(Lnil); }
+ | OPAREN type CPAREN { $$ = $2; }
+ | OBRACK type CBRACK { $$ = mktllist($2); }
+ | OPOD type CPOD { $$ = mktpod($2); }
+ | OPROC types SEMI type CPROC { $$ = mktproc($2,$4); }
+ | OPOD types SEMI type CPOD { $$ = mktpod(mktproc($2,$4));}
+ ;
+
+
+simple : tycon { $$ = mktname($1,Lnil); }
+ | tycon tyvars { $$ = mktname($1,$2); }
+ ;
+
+
+simple_long : tycon tyvars { $$ = mktname($1,$2); }
+ ; /* partain: see comment in "inst" */
+
+
+constrs : constrs VBAR constr { $$ = lapp($1,$3); }
+ | constr { $$ = lsing($1); }
+ ;
+
+/* Using tycon rather than con avoids 5 S/R errors */
+constr : tycon atypes { $$ = mkatc($1,$2,hsplineno); }
+ | OPAREN consym CPAREN atypes { $$ = mkatc($2,$4,hsplineno); }
+ | tycon { $$ = mkatc($1,Lnil,hsplineno); }
+ | OPAREN consym CPAREN { $$ = mkatc($2,Lnil,hsplineno); }
+ | btype conop btype { $$ = mkatc($2, ldub($1,$3), hsplineno); }
+ ;
+
+tyclses : OPAREN tycls_list CPAREN { $$ = $2; }
+ | OPAREN CPAREN { $$ = Lnil; }
+ | tycls { $$ = lsing($1); }
+ ;
+
+tycls_list: tycls COMMA tycls_list { $$ = mklcons($1,$3); }
+ | tycls { $$ = lsing($1); }
+ ;
+
+context : OPAREN context_list CPAREN { $$ = $2; }
+ | class { $$ = lsing($1); }
+ ;
+
+context_list: class COMMA context_list { $$ = mklcons($1,$3); }
+ | class { $$ = lsing($1); }
+ ;
+
+valdefs : valdefs SEMI valdef
+ {
+ if(SAMEFN)
+ {
+ extendfn($1,$3);
+ $$ = $1;
+ }
+ else
+ $$ = mkabind($1,$3);
+ }
+ | valdef { $$ = $1; }
+ | /* empty */ { $$ = mknullbind(); }
+ ;
+
+
+vars : vark COMMA varsrest { $$ = mklcons($1,$3); }
+ | vark { $$ = lsing($1); }
+ ;
+
+varsrest: varsrest COMMA var { $$ = lapp($1,$3); }
+ | var { $$ = lsing($1); }
+ ;
+
+cons : cons COMMA con { $$ = lapp($1,$3); }
+ | con { $$ = lsing($1); }
+ ;
+
+
+valdef : opatk
+ {
+ tree fn = function($1);
+
+ PREVPATT = $1;
+
+ if(ttree(fn) == ident)
+ {
+ checksamefn(gident(fn));
+ FN = fn;
+ }
+
+ else if (ttree(fn) == tinfixop && ttree(ginfun((struct Sap *) fn)) == ident)
+ {
+ checksamefn(gident(ginfun((struct Sap *) fn)));
+ FN = ginfun((struct Sap *) fn);
+ }
+
+ else if(etags)
+ printf("%u\n",startlineno);
+ }
+ valrhs
+ {
+ if(ispatt($1,TRUE))
+ {
+ $$ = mkpbind($3, startlineno);
+ FN = NULL;
+ SAMEFN = 0;
+ }
+ else
+ $$ = mkfbind($3,startlineno);
+
+ PREVPATT = NULL;
+ }
+ ;
+
+valrhs : valrhs1 maybe_where { $$ = lsing(createpat($1, $2)); }
+ ;
+
+valrhs1 : gdrhs
+ | EQUAL exp { $$ = lsing(mktruecase($2)); }
+ ;
+
+gdrhs : gd EQUAL exp { $$ = lsing(ldub($1,$3)); }
+ | gd EQUAL exp gdrhs { $$ = mklcons(ldub($1,$3),$4); }
+ ;
+
+maybe_where:
+ WHERE ocurly decls ccurly { $$ = $3; }
+ | WHERE vocurly decls vccurly { $$ = $3; }
+ | /* empty */ { $$ = mknullbind(); }
+ ;
+
+gd : VBAR oexp { $$ = $2; }
+ ;
+
+
+lampats : apat lampats { $$ = mklcons($1,$2); }
+ | apat { $$ = lsing($1); }
+ ;
+
+
+/*
+ Changed as above to allow for contexts!
+ KH@21/12/92
+*/
+
+
+exp : oexp DCOLON type DARROW type { $$ = mkrestr($1,mkcontext(type2context($3),$5)); }
+ | oexp DCOLON type { $$ = mkrestr($1,$3); }
+ | oexp
+ ;
+
+/*
+ Operators must be left-associative at the same precedence
+ for prec. parsing to work.
+*/
+
+ /* Infix operator application */
+oexp : dexp
+ | oexp op oexp %prec PLUS
+ { $$ = mkinfixop($2,$1,$3); precparse($$); }
+ ;
+
+/*
+ This comes here because of the funny precedence rules concerning
+ prefix minus.
+*/
+
+
+dexp : MINUS kexp { $$ = mknegate($2); }
+ | kexp
+ ;
+
+/*
+ let/if/lambda/case have higher precedence than infix operators.
+*/
+
+kexp : LAMBDA
+ { /* enteriscope(); /? I don't understand this -- KH */
+ hsincindent(); /* added by partain; push new context for */
+ /* FN = NULL; not actually concerned about */
+ FN = NULL; /* indenting */
+ $<uint>$ = hsplineno; /* remember current line number */
+ }
+ lampats
+ { hsendindent(); /* added by partain */
+ /* exitiscope(); /? Also not understood */
+ }
+ RARROW exp /* lambda abstraction */
+ {
+ $$ = mklambda($3, $6, $<uint>2);
+ }
+
+ /* Let Expression */
+ | LET ocurly decls ccurly IN exp { $$ = mklet($3,$6); }
+ | LET vocurly decls vccurly IN exp { $$ = mklet($3,$6); }
+
+ /* If Expression */
+ | IF exp THEN exp ELSE exp { $$ = mkife($2,$4,$6); }
+
+ /* Case Expression */
+ | CASE exp OF ocurly alts ccurly { $$ = mkcasee($2,$5); }
+ | CASE exp OF vocurly alts vccurly { $$ = mkcasee($2,$5); }
+
+ /* CCALL/CASM Expression */
+ | CCALL ccallid cexp { $$ = mkccall($2,installid("n"),$3); }
+ | CCALL ccallid { $$ = mkccall($2,installid("n"),Lnil); }
+ | CCALL_DANGEROUS ccallid cexp { $$ = mkccall($2,installid("p"),$3); }
+ | CCALL_DANGEROUS ccallid { $$ = mkccall($2,installid("p"),Lnil); }
+ | CASM CLITLIT cexp { $$ = mkccall($2,installid("N"),$3); }
+ | CASM CLITLIT { $$ = mkccall($2,installid("N"),Lnil); }
+ | CASM_DANGEROUS CLITLIT cexp { $$ = mkccall($2,installid("P"),$3); }
+ | CASM_DANGEROUS CLITLIT { $$ = mkccall($2,installid("P"),Lnil); }
+
+ /* SCC Expression */
+ | SCC STRING exp
+ { extern BOOLEAN ignoreSCC;
+ extern BOOLEAN warnSCC;
+ extern char * input_filename;
+
+ if (ignoreSCC) {
+ if (warnSCC)
+ fprintf(stderr,
+ "\"%s\", line %d: scc (`set [profiling] cost centre') ignored\n",
+ input_filename, hsplineno);
+ $$ = $3;
+ } else {
+ $$ = mkscc($2, $3);
+ }
+ }
+ | fexp
+ ;
+
+
+
+ /* Function application */
+fexp : fexp aexp { $$ = mkap($1,$2); }
+ | aexp
+ ;
+
+cexp : cexp aexp { $$ = lapp($1,$2); }
+ | aexp { $$ = lsing($1); }
+ ;
+
+
+/*
+ The mkpars are so that infix parsing doesn't get confused.
+
+ KH.
+*/
+
+ /* Simple Expressions */
+aexp : var { $$ = mkident($1); }
+ | con { $$ = mkident($1); }
+ | literal
+ | OPAREN exp CPAREN { $$ = mkpar($2); }
+ | OPAREN oexp op CPAREN { checkprec($2,$3,FALSE); $$ = mklsection($2,$3); }
+ | OPAREN op1 oexp CPAREN { checkprec($3,$2,TRUE); $$ = mkrsection($2,$3); }
+
+ /* structures */
+ | tuple
+ | list { $$ = mkpar($1); }
+ | sequence { $$ = mkpar($1); }
+ | comprehension { $$ = mkpar($1); }
+ | OPOD exp VBAR parquals CPOD { $$ = mkparzf($2,$4); }
+ | OPOD exps CPOD { $$ = mkpod($2); }
+ | processor { $$ = mkpar($1); }
+
+ /* These only occur in patterns */
+ | var AT aexp { checkinpat(); $$ = mkas($1,$3); }
+ | WILDCARD { checkinpat(); $$ = mkwildp(); }
+ | LAZY aexp { checkinpat(); $$ = mklazyp($2); }
+ ;
+
+
+processor : OPROC exps SEMI exp CPROC { $$ = mkproc($2,$4); }
+ ;
+
+parquals : parquals COMMA parqual { $$ = lapp($1,$3); }
+ | parqual { $$ = lsing($1); }
+ ;
+
+parqual : exp { $$ = mkparfilt($1); }
+ | processor DRAWNFROM exp
+ { $$ = mkpardgen($1,$3);
+ checkpatt($1);
+ }
+ | processor INDEXFROM exp
+ { $$ = mkparigen($1,$3);
+ checkpatt(gprocdata($1));
+ }
+ ;
+
+
+/*
+ LHS patterns are parsed in a similar way to
+ expressions. This avoids the horrible non-LRness
+ which occurs with the 1.1 syntax.
+
+ The xpatk business is to do with accurately recording
+ the starting line for definitions.
+*/
+
+/*TESTTEST
+bind : opatk
+ | vark lampats
+ { $$ = mkap($1,$2); }
+ | opatk varop opat %prec PLUS
+ {
+ $$ = mkinfixop($2,$1,$3);
+ }
+ ;
+
+opatk : dpatk
+ | opatk conop opat %prec PLUS
+ {
+ $$ = mkinfixop($2,$1,$3);
+ precparse($$);
+ }
+ ;
+
+*/
+
+opatk : dpatk
+ | opatk op opat %prec PLUS
+ {
+ $$ = mkinfixop($2,$1,$3);
+
+ if(isconstr(id_to_string($2)))
+ precparse($$);
+ else
+ {
+ checkprec($1,$2,FALSE); /* Check the precedence of the left pattern */
+ checkprec($3,$2,TRUE); /* then check the right pattern */
+ }
+ }
+ ;
+
+opat : dpat
+ | opat op opat %prec PLUS
+ {
+ $$ = mkinfixop($2,$1,$3);
+
+ if(isconstr(id_to_string($2)))
+ precparse($$);
+ else
+ {
+ checkprec($1,$2,FALSE); /* Check the precedence of the left pattern */
+ checkprec($3,$2,TRUE); /* then check the right pattern */
+ }
+ }
+ ;
+
+/*
+ This comes here because of the funny precedence rules concerning
+ prefix minus.
+*/
+
+
+dpat : MINUS fpat { $$ = mknegate($2); }
+ | fpat
+ ;
+
+ /* Function application */
+fpat : fpat aapat { $$ = mkap($1,$2); }
+ | aapat
+ ;
+
+dpatk : minuskey fpat { $$ = mknegate($2); }
+ | fpatk
+ ;
+
+ /* Function application */
+fpatk : fpatk aapat { $$ = mkap($1,$2); }
+ | aapatk
+ ;
+
+aapat : con { $$ = mkident($1); }
+ | var { $$ = mkident($1); }
+ | var AT apat { $$ = mkas($1,$3); }
+ | literal { $$ = $1; }
+ | WILDCARD { $$ = mkwildp(); }
+ | OPAREN CPAREN { $$ = mktuple(Lnil); }
+ | OPAREN var PLUS INTEGER CPAREN { $$ = mkplusp(mkident($2),mkinteger($4)); }
+ | OPAREN WILDCARD PLUS INTEGER CPAREN { $$ = mkplusp(mkwildp(),mkinteger($4)); }
+ | OPAREN opat CPAREN { $$ = mkpar($2); }
+ | OPAREN opat COMMA pats CPAREN { $$ = mktuple(mklcons($2,$4)); }
+ | OBRACK pats CBRACK { $$ = mkllist($2); }
+ | OBRACK CBRACK { $$ = mkllist(Lnil); }
+ | LAZY apat { $$ = mklazyp($2); }
+ | OPROC pats SEMI apat CPROC { $$ = mkproc($2,$4); }
+ ;
+
+aapatk : conk { $$ = mkident($1); }
+ | vark { $$ = mkident($1); }
+ | vark AT apat { $$ = mkas($1,$3); }
+ | literal { $$ = $1; setstartlineno(); }
+ | WILDCARD { $$ = mkwildp(); setstartlineno(); }
+ | oparenkey CPAREN { $$ = mktuple(Lnil); }
+ | oparenkey var PLUS INTEGER CPAREN { $$ = mkplusp(mkident($2),mkinteger($4)); }
+ | oparenkey WILDCARD PLUS INTEGER CPAREN { $$ = mkplusp(mkwildp(),mkinteger($4)); }
+ | oparenkey opat CPAREN { $$ = mkpar($2); }
+ | oparenkey opat COMMA pats CPAREN { $$ = mktuple(mklcons($2,$4)); }
+ | obrackkey pats CBRACK { $$ = mkllist($2); }
+ | obrackkey CBRACK { $$ = mkllist(Lnil); }
+ | lazykey apat { $$ = mklazyp($2); }
+ | oprockey pats SEMI opat CPROC { $$ = mkproc($2,$4); }
+ ;
+
+
+/*
+ The mkpars are so that infix parsing doesn't get confused.
+
+ KH.
+*/
+
+tuple : OPAREN exp COMMA texps CPAREN
+ { if (ttree($4) == tuple)
+ $$ = mktuple(mklcons($2, gtuplelist($4)));
+ else
+ $$ = mktuple(ldub($2, $4));
+ }
+ | OPAREN CPAREN
+ { $$ = mktuple(Lnil); }
+ ;
+
+texps : exp COMMA texps
+ { if (ttree($3) == tuple)
+ $$ = mktuple(mklcons($1, gtuplelist($3)));
+ else
+ $$ = mktuple(ldub($1, $3));
+ }
+ | exp { $$ = mkpar($1); }
+ ;
+
+
+list : OBRACK CBRACK { $$ = mkllist(Lnil); }
+ | OBRACK exps CBRACK { $$ = mkllist($2); }
+ ;
+
+exps : exp COMMA exps { $$ = mklcons($1,$3); }
+ | exp { $$ = lsing($1); }
+ ;
+
+
+sequence: OBRACK exp COMMA exp DOTDOT upto CBRACK {$$ = mkeenum($2,lsing($4),$6);}
+ | OBRACK exp DOTDOT upto CBRACK { $$ = mkeenum($2,Lnil,$4); }
+ ;
+
+comprehension: OBRACK exp VBAR quals CBRACK { $$ = mkcomprh($2,$4); }
+ ;
+
+quals : quals COMMA qual { $$ = lapp($1,$3); }
+ | qual { $$ = lsing($1); }
+ ;
+
+qual : { inpat = TRUE; } exp { inpat = FALSE; } qualrest
+ { if ($4 == NULL)
+ $$ = mkguard($2);
+ else
+ {
+ checkpatt($2);
+ if(ttree($4)==def)
+ {
+ tree prevpatt_save = PREVPATT;
+ PREVPATT = $2;
+ $$ = mkdef(mkpbind(lsing(createpat(lsing(mktruecase((tree)(ggdef($4)))),mknullbind())),hsplineno));
+ PREVPATT = prevpatt_save;
+ }
+ else
+ $$ = mkqual($2,$4);
+ }
+ }
+ ;
+
+qualrest: LARROW exp { $$ = $2; }
+/* OLD:
+ | EQUAL exp
+ { if(nonstandardFlag)
+ $$ = mkdef($2);
+ else
+ hsperror("Definitions in comprehensions are not standard Haskell");
+ }
+*/
+ | /* empty */ { $$ = NULL; }
+ ;
+
+
+alts : alts SEMI alt { $$ = lconc($1,$3); }
+ | alt { $$ = $1; }
+ ;
+
+alt : pat
+ { PREVPATT = $1; }
+ altrest
+ { $$ = $3;
+ PREVPATT = NULL;
+ }
+ | /* empty */ { $$ = Lnil; }
+ ;
+
+altrest : gdpat maybe_where { $$ = lsing(createpat($1,$2)); }
+ | RARROW exp maybe_where { $$ = lsing(createpat(lsing(mktruecase($2)),$3)); }
+ ;
+
+gdpat : gd RARROW exp gdpat { $$ = mklcons(ldub($1,$3),$4); }
+ | gd RARROW exp { $$ = lsing(ldub($1,$3)); }
+ ;
+
+upto : /* empty */ { $$ = Lnil; }
+ | exp { $$ = lsing($1); }
+ ;
+
+pats : pat COMMA pats { $$ = mklcons($1,$3); }
+ | pat { $$ = lsing($1); }
+ ;
+
+pat : bpat
+ | pat conop bpat { $$ = mkinfixop($2,$1,$3); precparse($$); }
+ ;
+
+bpat : apatc
+ | conpat
+ | MINUS INTEGER { $$ = mkinteger(ineg($2)); }
+ | MINUS FLOAT { $$ = mkfloatr(ineg($2)); }
+ ;
+
+conpat : con { $$ = mkident($1); }
+ | conpat apat { $$ = mkap($1,$2); }
+ ;
+
+apat : con { $$ = mkident($1); }
+ | apatc
+ ;
+
+apatc : var { $$ = mkident($1); }
+ | var AT apat { $$ = mkas($1,$3); }
+ | literal { $$ = $1; }
+ | WILDCARD { $$ = mkwildp(); }
+ | OPAREN CPAREN { $$ = mktuple(Lnil); }
+ | OPAREN var PLUS INTEGER CPAREN { $$ = mkplusp(mkident($2),mkinteger($4)); }
+ | OPAREN WILDCARD PLUS INTEGER CPAREN { $$ = mkplusp(mkwildp(),mkinteger($4)); }
+ | OPAREN pat CPAREN { $$ = mkpar($2); }
+ | OPAREN pat COMMA pats CPAREN { $$ = mktuple(mklcons($2,$4)); }
+ | OBRACK pats CBRACK { $$ = mkllist($2); }
+ | OBRACK CBRACK { $$ = mkllist(Lnil); }
+ | LAZY apat { $$ = mklazyp($2); }
+ | OPROC pats SEMI apat CPROC { $$ = mkproc($2,$4); }
+ ;
+
+/*
+patk : bpatk
+ | patk conop bpat { $$ = mkinfixop($2,$1,$3); precparse($$); }
+ ;
+
+bpatk : apatck
+ | conpatk
+ | minuskey INTEGER { $$ = mkinteger(ineg($2)); }
+ | minuskey FLOAT { $$ = mkfloatr(ineg($2)); }
+ ;
+
+conpatk : conk { $$ = mkident($1); }
+ | conpatk apat { $$ = mkap($1,$2); }
+ ;
+
+apatck : vark { $$ = mkident($1); }
+ | vark AT apat { $$ = mkas($1,$3); }
+ | literal { $$ = $1; setstartlineno(); }
+ | WILDCARD { $$ = mkwildp(); setstartlineno(); }
+ | oparenkey CPAREN { $$ = mktuple(Lnil); }
+ | oparenkey var PLUS INTEGER CPAREN { $$ = mkplusp(mkident($2),mkinteger($4)); }
+ | oparenkey WILDCARD PLUS INTEGER CPAREN { $$ = mkplusp(mkwildp(),mkinteger($4)); }
+ | oparenkey pat CPAREN { $$ = mkpar($2); }
+ | oparenkey pat COMMA pats CPAREN { $$ = mktuple(mklcons($2,$4)); }
+ | obrackkey pats CBRACK { $$ = mkllist($2); }
+ | obrackkey CBRACK { $$ = mkllist(Lnil); }
+ | lazykey apat { $$ = mklazyp($2); }
+ | oprockey pats SEMI opat CPROC { $$ = mkproc($2,$4); }
+ ;
+*/
+
+literal : INTEGER { $$ = mkinteger($1); }
+ | FLOAT { $$ = mkfloatr($1); }
+ | CHAR { $$ = mkcharr($1); }
+ | STRING { $$ = mkstring($1); }
+ | CHARPRIM { $$ = mkcharprim($1); }
+ | INTPRIM { $$ = mkintprim($1); }
+ | FLOATPRIM { $$ = mkfloatprim($1); }
+ | DOUBLEPRIM { $$ = mkdoubleprim($1); }
+ | CLITLIT { $$ = mkclitlit($1); }
+ | VOIDPRIM { $$ = mkvoidprim(); }
+ ;
+
+
+/* Keywords which record the line start */
+
+importkey: IMPORT { setstartlineno(); }
+ ;
+
+datakey : DATA { setstartlineno();
+ if(etags)
+ printf("%u\n",startlineno);
+ }
+ ;
+
+typekey : TYPE { setstartlineno();
+ if(etags)
+ printf("%u\n",startlineno);
+ }
+ ;
+
+instkey : INSTANCE { setstartlineno();
+ if(etags)
+ printf("%u\n",startlineno);
+ }
+ ;
+
+defaultkey: DEFAULT { setstartlineno(); }
+ ;
+
+classkey: CLASS { setstartlineno();
+ if(etags)
+ printf("%u\n",startlineno);
+ }
+ ;
+
+minuskey: MINUS { setstartlineno(); }
+ ;
+
+oparenkey: OPAREN { setstartlineno(); }
+ ;
+
+obrackkey: OBRACK { setstartlineno(); }
+ ;
+
+lazykey : LAZY { setstartlineno(); }
+ ;
+
+oprockey: OPROC { setstartlineno(); }
+ ;
+
+
+/* Non "-" op, used in right sections -- KH */
+op1 : conop
+ | varop1
+ ;
+
+op : conop
+ | varop
+ ;
+
+varop : varsym
+ | BQUOTE varid BQUOTE { $$ = $2; }
+ ;
+
+/* Non-minus varop, used in right sections */
+varop1 : VARSYM
+ | plus
+ | BQUOTE varid BQUOTE { $$ = $2; }
+ ;
+
+conop : consym
+ | BQUOTE conid BQUOTE { $$ = $2; }
+ ;
+
+consym : CONSYM
+ ;
+
+varsym : VARSYM
+ | plus
+ | minus
+ ;
+
+minus : MINUS { $$ = install_literal("-"); }
+ ;
+
+plus : PLUS { $$ = install_literal("+"); }
+ ;
+
+var : VARID
+ | OPAREN varsym CPAREN { $$ = $2; }
+ ;
+
+vark : VARID { setstartlineno(); $$ = $1; }
+ | oparenkey varsym CPAREN { $$ = $2; }
+ ;
+
+/* tycon used here to eliminate 11 spurious R/R errors -- KH */
+con : tycon
+ | OPAREN consym CPAREN { $$ = $2; }
+ ;
+
+conk : tycon { setstartlineno(); $$ = $1; }
+ | oparenkey consym CPAREN { $$ = $2; }
+ ;
+
+varid : VARID
+ ;
+
+conid : CONID
+ ;
+
+ccallid : varid
+ | conid
+ ;
+
+/* partain: "tyvar_list" must be at least 2 elements long (defn of "inst") */
+tyvar_list: tyvar COMMA tyvar_list { $$ = mklcons($1,$3); }
+ | tyvar COMMA tyvar { $$ = mklcons($1,lsing($3)); }
+ ;
+
+tyvars : tyvar tyvars { $$ = mklcons($1,$2); }
+ | tyvar { $$ = lsing($1); }
+ ;
+
+tyvar : VARID { $$ = mknamedtvar($1); }
+ ;
+
+tycls : tycon
+ /* partain: "aconid"->"tycon" got rid of a r/r conflict
+ (and introduced >= 2 s/r's ...)
+ */
+ ;
+
+tycon : conid
+ ;
+
+modid : CONID
+ ;
+
+
+ocurly : layout OCURLY { hsincindent(); }
+
+vocurly : layout { hssetindent(); }
+ ;
+
+layout : { hsindentoff(); }
+ ;
+
+ccurly :
+ CCURLY
+ {
+ FN = NULL; SAMEFN = 0; PREVPATT = NULL;
+ hsendindent();
+ }
+ ;
+
+vccurly : { expect_ccurly = 1; } vccurly1 { expect_ccurly = 0; }
+ ;
+
+vccurly1:
+ VCCURLY
+ {
+ FN = NULL; SAMEFN = 0; PREVPATT = NULL;
+ hsendindent();
+ }
+ | error
+ {
+ yyerrok;
+ FN = NULL; SAMEFN = 0; PREVPATT = NULL;
+ hsendindent();
+ }
+ ;
+
+%%
projects / ghc-hetmet.git / blobdiff