home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Moscow ML 1.42 / src / compiler / Parser.grm < prev    next >
Encoding:
Text File  |  1997-08-18  |  17.1 KB  |  692 lines  |  [TEXT/R*ch]
  1. %{
  2.  
  3. open Fnlib Config Mixture Const Globals Location Types Asynt Asyntfn;
  4.  
  5. %}
  6.  
  7. %token ABSTRACTION ABSTYPE AND ANDALSO AS CASE DATATYPE DO ELSE END
  8. %token EQTYPE EXCEPTION
  9. %token FN FUN HANDLE IF IN INFIX INFIXR LET LOCAL
  10. %token NONFIX OF OP ORELSE RAISE REC SIG SIGNATURE STRUCT STRUCTURE
  11. %token THEN TYPE VAL WHILE WITH WITHTYPE
  12.  
  13. %token EQUALS
  14. %token COMMA ARROW DARROW BAR STAR HASH
  15. %token LBRACE RBRACE HASHLBRACKET LBRACKET RBRACKET LPAREN RPAREN
  16. %token COLON COLONGT SEMICOLON UNDERBAR DOTDOTDOT
  17.  
  18. %token OPEN PRIM_VAL PRIM_TYPE PRIM_EQTYPE PRIM_REFTYPE
  19.  
  20. %token <string> ID
  21. %token <Const.QualifiedIdent> QUAL_ID QUAL_STAR
  22.  
  23. %token <int> ZDIGIT NZDIGIT ZPOSINT2 NZPOSINT2 NEGINT
  24. %token <word> WORD
  25. %token <char> CHAR
  26. %token <real> REAL
  27. %token <string> STRING
  28.  
  29. %token QUOTEL
  30. %token <string> QUOTER QUOTEM
  31.  
  32. %token <string> TYVAR
  33.  
  34. %token EOF
  35.  
  36. %right    AND
  37. %nonassoc DARROW
  38. %nonassoc BAR
  39. %nonassoc ELSE
  40. %nonassoc DO
  41. %nonassoc RAISE
  42. %right    HANDLE
  43. %right    ORELSE
  44. %right    ANDALSO
  45. %right    AS
  46.  
  47. %nonassoc COLON
  48. %right    ARROW
  49. %nonassoc ID EQUALS
  50. %right    STAR
  51.  
  52. %start ToplevelPhrase
  53. %type <Asynt.Dec * bool> ToplevelPhrase
  54.  
  55. %start SigFile
  56. %type <Asynt.Sig> SigFile
  57.  
  58. %start StructFile
  59. %type <Asynt.Struct> StructFile
  60.  
  61. %type <bool> EOPh
  62. %type <string> Ident EqIdent UnitName
  63. %type <Location.Location * string> IdentWithLoc LocUnitName
  64. %type <Asynt.IdInfo> OpIdent TypeIdent LongTypeIdent
  65. %type <Asynt.IdInfo> LongIdent LongOpIdent LongOpEqIdent
  66. %type <Asynt.TyVar> TyVar
  67. %type <string list> EqIdent_seq1 UnitName_seq1
  68. %type <int> DIGIT_opt Integer NumLabel Arity
  69. %type <unit> SemiEof
  70. %type <Mixture.Lab> Label
  71. %type <Const.SCon> SCon
  72. %type <Asynt.Dec> Dec KWDec_seq1 KWDec
  73. %type <Asynt.Dec list> KWDec_seq
  74. %type <Asynt.ValBind list * Asynt.ValBind list> ValBind AndValBind_opt
  75. %type <Asynt.PrimValBind list> PrimValBind AndPrimValBind_opt
  76. %type <Asynt.ValBind list> FnValBind AndFnValBind_opt
  77. %type <Asynt.TypBind list> TypBind AndTypBind_opt
  78. %type <Asynt.TypDesc list> TypDesc AndTypDesc_opt
  79. %type <Asynt.DatBind list> DatBind AndDatBind_opt
  80. %type <Asynt.ConBind list> ConBind BarConBind_opt
  81. %type <Asynt.TypBind list option> WithType_opt
  82. %type <Asynt.ExBind list> ExBind AndExBind_opt
  83. %type <Asynt.ExDesc list> ExDesc AndExDesc_opt
  84. %type <Asynt.Ty option> OfTy_opt ColonTy_opt
  85. %type <Asynt.FValBind list> FValBind AndFValBind_opt
  86. %type <Asynt.FValBind> FClauseWithLoc
  87. %type <Asynt.FClause list> FClause BarFClause_opt
  88. %type <Asynt.Exp> AtExp Exp
  89. %type <Asynt.Exp list> ExpComma_seq0 ExpComma_seq1 ExpComma_seq2
  90.     QuoteTail ExpQuoteTail 
  91. %type <Asynt.Exp list> ExpSemicolon_seq2
  92. %type <Asynt.Exp list> AtExp_seq1
  93. %type <Asynt.Exp Mixture.Row> ExpRow_opt ExpRow CommaExpRow_opt
  94. %type <Asynt.Match> Match
  95. %type <Location.Location * Asynt.Match> MatchWithLoc
  96. %type <Asynt.MRule> MRule
  97. %type <Asynt.Pat> Pat AtPat
  98. %type <Asynt.Pat list> AtPat_seq1
  99. %type <Asynt.Pat list> PatComma_seq0 PatComma_seq1 PatComma_seq2
  100. %type <Asynt.Pat Mixture.Row * bool> PatRow_opt PatRow CommaPatRow_opt
  101. %type <Asynt.Pat option> AsPat_opt
  102. %type <Asynt.Ty> Ty Ty_sans_STAR AtomicTy
  103. %type <Asynt.Ty list> TupleTy TyComma_seq2
  104. %type <Asynt.Ty Mixture.Row> TyRow_opt TyRow CommaTyRow_opt
  105. %type <Asynt.TyVar list> TyVarSeq TyVarSeq1 TyVarComma_seq1
  106.  
  107. %type <Asynt.Spec> Spec KWSpec
  108. %type <Asynt.Spec list> KWSpec_seq
  109. %type <Asynt.ValDesc list> ValDesc AndValDesc_opt
  110.  
  111. %%
  112.  
  113. Ident :
  114.     ID          { $1 }
  115.   | STAR        { "*" }
  116. ;
  117.  
  118. IdentWithLoc :
  119.     Ident       { mkLoc($1) }
  120. ;
  121.  
  122. OpIdent :
  123.     Ident       { mkIdInfo (mkLoc { qual="", id=$1 }) false }
  124.   | OP Ident    { mkIdInfo (mkLoc { qual="", id=$2 }) true }
  125. ;
  126.  
  127. EqIdent :
  128.     Ident       { $1 }
  129.   | EQUALS      { "=" }
  130. ;
  131.  
  132. LocUnitName :
  133.     UnitName    { mkLoc($1) }
  134. ;
  135.  
  136. UnitName :
  137.     Ident       { normalizedUnitName $1 }
  138.   | EQUALS      { "=" }
  139. ;
  140.  
  141. TypeIdent :
  142.     ID          { mkIdInfo (mkLoc { qual="", id=$1 }) false }
  143. ;
  144.  
  145. LongTypeIdent :
  146.     TypeIdent   { $1 }
  147.   | QUAL_ID     { mkIdInfo (mkLoc $1) false }
  148. ;
  149.  
  150. LongIdent :
  151.     Ident       { mkIdInfo (mkLoc { qual="", id=$1 }) false }
  152.   | QUAL_ID     { mkIdInfo (mkLoc $1) false }
  153.   | QUAL_STAR   { mkIdInfo (mkLoc $1) false }
  154. ;
  155.  
  156. LongOpIdent :
  157.     LongIdent      { $1 }
  158.   | OP Ident       { mkIdInfo (mkLoc { qual="", id=$2 }) true }
  159.   | OP QUAL_ID     { mkIdInfo (mkLoc $2) true }
  160.   | OP QUAL_STAR   { mkIdInfo (mkLoc $2) true }
  161. ;
  162.  
  163. LongOpEqIdent :
  164.     LongOpIdent    { $1 }
  165.   | EQUALS         { mkIdInfo (mkLoc { qual="", id="=" }) false }
  166.   | OP EQUALS      { mkIdInfo (mkLoc { qual="", id="=" }) true }
  167. ;
  168.  
  169. TyVar :
  170.     TYVAR    { mkIdInfo (mkLoc { qual="", id=$1 }) false }
  171. ;
  172.  
  173. EqIdent_seq1 :
  174.     EqIdent EqIdent_seq1        { $1 :: $2 }
  175.   | EqIdent                     { [$1] }
  176. ;
  177.  
  178. UnitName_seq1 :
  179.     UnitName UnitName_seq1      { $1 :: $2 }
  180.   | UnitName                    { [$1] }
  181. ;
  182.  
  183. DIGIT_opt :
  184.     ZDIGIT      { $1 }
  185.   | NZDIGIT     { $1 }
  186.   | /* */       { 0 }
  187. ;
  188.  
  189. Integer :
  190.     ZPOSINT2    { $1 }
  191.   | NZPOSINT2   { $1 }
  192.   | NEGINT      { $1 }
  193.   | ZDIGIT      { $1 }
  194.   | NZDIGIT     { $1 }
  195. ;
  196.  
  197. NumLabel :
  198.     NZPOSINT2   { $1 }
  199.   | NZDIGIT     { $1 }
  200. ;
  201.  
  202. Label :
  203.     Ident       { STRINGlab $1 }
  204.   | NumLabel    { INTlab $1 }
  205. ;
  206.  
  207. Arity :
  208.     ZPOSINT2    { $1 }
  209.   | NZPOSINT2   { $1 }
  210.   | ZDIGIT      { $1 }
  211.   | NZDIGIT     { $1 }
  212. ;
  213.  
  214. ToplevelPhrase :
  215.     Exp EOPh                    { (mkValIt $1, $2) }
  216.   | KWDec_seq1 EOPh             { ($1, $2) }
  217.   | EOPh                        { (mkLoc(EMPTYdec), $1) }
  218. ;
  219.  
  220. EOPh :
  221.     SEMICOLON        { false }
  222.   | EOF            { true }
  223. ;
  224.  
  225. SemiEof :
  226.     SEMICOLON SemiEof   { }
  227.   | EOF            { }
  228. ;
  229.  
  230. Dec :
  231.     KWDec Dec           { mkLoc(SEQdec($1, $2)) }
  232.   | SEMICOLON Dec       { $2 }
  233.   | /* */               { mkLoc(EMPTYdec) }
  234. ;
  235.  
  236. KWDec_seq1 :
  237.     KWDec KWDec_seq1    { mkLoc(SEQdec($1,$2)) }
  238.   | KWDec               { $1 }
  239. ;
  240.  
  241. StructFile :
  242.     STRUCTURE LocUnitName EQUALS STRUCT KWDec_seq END SemiEof
  243.         { NamedStruct{locstrid = $2, locsigid = NONE, decs = $5} }
  244.   | STRUCTURE LocUnitName COLONGT LocUnitName EQUALS 
  245.                                           STRUCT KWDec_seq END SemiEof
  246.         { Abstraction{locstrid = $2, locsigid = $4, decs = $7} }
  247.   | ABSTRACTION LocUnitName COLON LocUnitName EQUALS 
  248.                                           STRUCT KWDec_seq END SemiEof
  249.         { Abstraction{locstrid = $2, locsigid = $4, decs = $7} }
  250.   | KWDec_seq EOF
  251.         { AnonStruct $1 }
  252. ;
  253.  
  254. KWDec_seq :
  255.     KWDec KWDec_seq        { $1 :: $2 }
  256.   | SEMICOLON KWDec_seq        { $2 }
  257.   | /* */            { [] }
  258. ;
  259.  
  260. KWDec :
  261.     VAL ValBind                 { mkLoc(VALdec ([], $2)) }
  262.   | VAL TyVarSeq1 ValBind       { mkLoc(VALdec ($2, $3)) }
  263.   | PRIM_VAL PrimValBind        { mkLoc(PRIM_VALdec $2) }
  264.   | FUN FValBind                { mkLoc(FUNdec ([], $2)) }
  265.   | FUN TyVarSeq1 FValBind      { mkLoc(FUNdec ($2, $3)) }
  266.   | TYPE TypBind                { mkLoc(TYPEdec $2) }
  267.   | PRIM_TYPE TypDesc           { mkLoc(PRIM_TYPEdec(FALSEequ, $2)) }
  268.   | PRIM_EQTYPE TypDesc         { mkLoc(PRIM_TYPEdec(TRUEequ, $2)) }
  269.   | PRIM_REFTYPE TypDesc        { mkLoc(PRIM_TYPEdec(REFequ, $2)) }
  270.   | DATATYPE DatBind WithType_opt
  271.                                 { mkLoc(DATATYPEdec($2,$3)) }
  272.   | ABSTYPE DatBind WithType_opt WITH Dec END
  273.                                 { mkLoc(ABSTYPEdec($2,$3,$5)) }
  274.   | EXCEPTION ExBind            { mkLoc(EXCEPTIONdec $2) }
  275.   | LOCAL Dec IN Dec END        { mkLoc(LOCALdec($2,$4)) }
  276.   | OPEN UnitName_seq1          { mkLoc(OPENdec $2) }
  277.   | INFIX DIGIT_opt EqIdent_seq1
  278.                                 { mkLoc(FIXITYdec(INFIXst $2, $3)) }
  279.   | INFIXR DIGIT_opt EqIdent_seq1
  280.                                 { mkLoc(FIXITYdec(INFIXRst $2, $3)) }
  281.   | NONFIX EqIdent_seq1
  282.                                 { mkLoc(FIXITYdec(NONFIXst, $2)) }
  283. ;
  284.  
  285. ValBind :
  286.     Pat EQUALS Exp AndValBind_opt
  287.                 { let val (pvbs, rvbs) = $4
  288.                   in (ValBind($1, $3)::pvbs, rvbs) end }
  289.   | REC FnValBind
  290.                 { ([], $2) }
  291. ;
  292.  
  293. AndValBind_opt :
  294.     AND ValBind         { $2 }
  295.   | /* */               { ([], []) }
  296. ;
  297.  
  298. PrimValBind :
  299.     OpIdent COLON Ty EQUALS Arity STRING AndPrimValBind_opt
  300.                         { ($1, $3, $5, $6) :: $7 }
  301. ;
  302.  
  303. AndPrimValBind_opt :
  304.     AND PrimValBind     { $2 }
  305.   | /* */               { [] }
  306. ;
  307.  
  308. FnValBind :
  309.     Pat EQUALS Exp AndFnValBind_opt
  310.                         { ValBind($1, $3) :: $4 }
  311.   | REC FnValBind       { $2 }
  312. ;
  313.  
  314. AndFnValBind_opt :
  315.     AND FnValBind       { $2 }
  316.   | /* */               { [] }
  317. ;
  318.  
  319. TypBind :
  320.     TyVarSeq TypeIdent  EQUALS Ty AndTypBind_opt
  321.                         { ($1, $2, $4) :: $5 }
  322. ;
  323.  
  324. AndTypBind_opt :
  325.     AND TypBind         { $2 }
  326.   | /* */               { [] }
  327. ;
  328.  
  329. DatBind :
  330.     TyVarSeq TypeIdent EQUALS ConBind AndDatBind_opt
  331.                         { ($1, $2, $4) :: $5 }
  332. ;
  333.  
  334. AndDatBind_opt :
  335.     AND DatBind         { $2 }
  336.   | /* */               { [] }
  337. ;
  338.  
  339. ConBind :
  340.     OpIdent OfTy_opt BarConBind_opt     { ConBind($1, $2) :: $3 }
  341. ;
  342.  
  343. BarConBind_opt :
  344.     BAR ConBind         { $2 }
  345.   | /* */               { [] }
  346. ;
  347.  
  348. WithType_opt :
  349.     WITHTYPE TypBind    { SOME $2 }
  350.   | /* */               { NONE }
  351.  
  352. ExBind :
  353.     OpIdent OfTy_opt AndExBind_opt              { EXDECexbind($1,$2) :: $3 }
  354.   | OpIdent EQUALS LongOpEqIdent AndExBind_opt  { EXEQUALexbind($1,$3) :: $4 }
  355. ;
  356.  
  357. AndExBind_opt :
  358.     AND ExBind          { $2 }
  359.   | /* */               { [] }
  360. ;
  361.  
  362. ExDesc :
  363.     OpIdent OfTy_opt AndExDesc_opt              { ($1,$2) :: $3 }
  364. ;
  365.  
  366. AndExDesc_opt :
  367.     AND ExDesc          { $2 }
  368.   | /* */               { [] }
  369. ;
  370.  
  371. ColonTy_opt :
  372.     COLON Ty    { SOME $2 }
  373.   | /* */       { NONE }
  374.  
  375. OfTy_opt :
  376.     OF Ty       { SOME $2 }
  377.   | /* */       { NONE }
  378. ;
  379.  
  380. FValBind :
  381.     FClauseWithLoc AndFValBind_opt     { $1 :: $2 }
  382. ;
  383.  
  384. AndFValBind_opt :
  385.     AND FValBind        { $2 }
  386.   | /* */               { [] }
  387. ;
  388.  
  389. FClauseWithLoc :
  390.     FClause             { mkLoc $1 }
  391. ;
  392.  
  393. FClause :
  394.     AtPat_seq1 ColonTy_opt EQUALS Exp BarFClause_opt
  395.         { let val rhs = (case $2 of
  396.                              SOME ty => (xxLR ty $4, TYPEDexp($4,ty))
  397.                            | NONE => $4)
  398.           in FClause($1, rhs) :: $5 end }
  399. ;
  400.  
  401. BarFClause_opt :
  402.     BAR FClause         { $2 }
  403.   | /* */               { [] }
  404. ;
  405.  
  406. SCon :
  407.     Integer     { INTscon $1 }
  408.   | WORD        { WORDscon $1 }
  409.   | CHAR        { CHARscon $1 }
  410.   | REAL        { REALscon $1 }
  411.   | STRING      { STRINGscon $1 }
  412. ;
  413.  
  414. AtExp :
  415.     SCon                { mkLoc(SCONexp($1, ref NONE)) }
  416.   | LongOpEqIdent       { mkLoc(VARexp(ref (RESve $1))) }
  417.   | LET Dec IN Exp END  { mkLoc(LETexp($2,$4)) }
  418.   | HASH Label          { hashLabelExp(mkLoc $2) }
  419.   | LPAREN Exp RPAREN   { mkLoc(PARexp $2) }
  420.   | LPAREN RPAREN       { tupleExp(mkLoc []) }
  421.   | LPAREN ExpComma_seq2 RPAREN
  422.                         { tupleExp(mkLoc $2) }
  423.   | LPAREN ExpSemicolon_seq2 RPAREN
  424.                         { seqExp $2 }
  425.   | LBRACE ExpRow_opt RBRACE
  426.                         { mkLoc(RECexp(ref (RECre $2))) }
  427.   | LET Dec IN ExpSemicolon_seq2 END
  428.                         { mkLoc(LETexp($2, seqExp $4)) }
  429.   | LBRACKET ExpComma_seq0 RBRACKET
  430.                         { listExp(mkLoc $2) }
  431.   | HASHLBRACKET ExpComma_seq0 RBRACKET
  432.                         { mkLoc(VECexp $2) }
  433.   | QUOTEL QuoteTail
  434.       { listExp(mkLoc $2) }
  435. ;
  436.  
  437. QuoteTail :
  438.     QUOTER
  439.       { [quoteExp(mkLoc(SCONexp(STRINGscon $1, ref NONE)))] }
  440.   | QUOTEM ExpQuoteTail
  441.       { quoteExp(mkLoc(SCONexp(STRINGscon $1, ref NONE))) :: $2 }
  442. ;
  443.  
  444. ExpQuoteTail :
  445.     Exp QuoteTail       { antiquoteExp($1) :: $2 }
  446. ;
  447.  
  448. ExpComma_seq0 :
  449.     ExpComma_seq1               { $1 }
  450.   | /* */                       { [] }
  451. ;
  452.  
  453. ExpComma_seq1 :
  454.     Exp COMMA ExpComma_seq1     { $1 :: $3 }
  455.   | Exp                         { [$1] }
  456. ;
  457.  
  458. ExpComma_seq2 :
  459.     Exp COMMA ExpComma_seq1     { $1 :: $3 }
  460. ;
  461.  
  462. ExpSemicolon_seq2 :
  463.     Exp SEMICOLON ExpSemicolon_seq2     { $1 :: $3 }
  464.   | Exp SEMICOLON Exp                   { [$1, $3] }
  465.  
  466. AtExp_seq1 :
  467.     AtExp AtExp_seq1            { $1 :: $2 }
  468.   | AtExp                       { [$1] }
  469. ;
  470.  
  471. ExpRow_opt :
  472.     ExpRow      { $1 }
  473.   | /* */       { [] }
  474. ;
  475.  
  476. ExpRow :
  477.     Label EQUALS Exp CommaExpRow_opt    { ($1,$3)::$4 }
  478. ;
  479.  
  480. CommaExpRow_opt :
  481.     COMMA ExpRow        { $2 }
  482.   | /* */               { [] }
  483. ;
  484.  
  485. Exp :
  486.     AtExp_seq1                  { mkLoc(INFIXexp $1) }
  487.   | Exp COLON Ty                { mkLoc(TYPEDexp($1,$3)) }
  488.   | Exp ANDALSO Exp             { mkLoc(ANDALSOexp($1,$3)) }
  489.   | Exp ORELSE Exp              { mkLoc(ORELSEexp($1,$3)) }
  490.   | Exp HANDLE Match            { mkLoc(HANDLEexp($1,$3)) }
  491.   | RAISE Exp                   { mkLoc(RAISEexp $2) }
  492.   | IF Exp THEN Exp ELSE Exp    { mkLoc(IFexp($2,$4,$6)) }
  493.   | WHILE Exp DO Exp            { mkLoc(WHILEexp($2,$4)) }
  494.   | CASE Exp OF MatchWithLoc
  495.         { let val (loc, mrules) = $4
  496.           in mkLoc(APPexp((loc, FNexp mrules), $2)) end }
  497.   | FN Match                    { mkLoc(FNexp $2) }
  498. ;
  499.  
  500. MatchWithLoc :
  501.     Match       { mkLoc $1 }
  502. ;
  503.  
  504. Match :
  505.     MRule BAR Match             { $1 :: $3 }
  506.   | MRule       %prec DARROW    { [$1] }
  507. ;
  508.  
  509. MRule :
  510.     Pat DARROW Exp      { MRule([$1],$3) }
  511. ;
  512.  
  513. Pat :
  514.     AtPat_seq1          { mkLoc(INFIXpat $1) }
  515.   | Pat COLON Ty        { mkLoc(TYPEDpat($1,$3)) }
  516.   | Pat AS Pat          { mkLoc(LAYEREDpat($1,$3)) }
  517. ;
  518.  
  519. AtPat :
  520.     UNDERBAR                    { mkLoc(WILDCARDpat) }
  521.   | SCon                        { mkLoc(SCONpat($1, ref NONE)) }
  522.   | LongOpIdent                 { mkLoc(VARpat $1) }
  523.   | LBRACE PatRow_opt RBRACE
  524.         { let val (fs, flexible) = $2 in
  525.             if flexible then
  526.               mkLoc(RECpat(ref (RECrp(fs, SOME (fresh3DotType())))))
  527.             else
  528.               mkLoc(RECpat(ref (RECrp(fs, NONE))))
  529.           end }
  530.   | LPAREN Pat RPAREN           { mkLoc(PARpat $2) }
  531.   | LPAREN RPAREN               { tuplePat(mkLoc []) }
  532.   | LPAREN PatComma_seq2 RPAREN
  533.                         { tuplePat(mkLoc $2) }
  534.   | LBRACKET PatComma_seq0 RBRACKET
  535.                         { listPat(mkLoc $2) }
  536.   | HASHLBRACKET PatComma_seq0 RBRACKET
  537.                         { mkLoc(VECpat $2) }
  538. ;
  539.  
  540. PatRow_opt :
  541.     PatRow      { $1 }
  542.   | /* */       { ([], false) }
  543. ;
  544.  
  545. PatRow :
  546.     DOTDOTDOT   { ([],true) }
  547.   | Label EQUALS Pat CommaPatRow_opt
  548.         { let val (fs, flexible) = $4
  549.           in (($1,$3)::fs, flexible) end }
  550.   | IdentWithLoc ColonTy_opt AsPat_opt CommaPatRow_opt
  551.         { let val (fs, flexible) = $4
  552.           in (mkLabPatOfId $1 $2 $3::fs, flexible) end }
  553. ;
  554.  
  555. AsPat_opt :
  556.     AS Pat      { SOME $2 }
  557.   | /* */       { NONE }
  558. ;
  559.  
  560. CommaPatRow_opt :
  561.     COMMA PatRow        { $2 }
  562.   | /* */               { ([], false) }
  563. ;
  564.  
  565. AtPat_seq1 :
  566.     AtPat AtPat_seq1            { $1 :: $2 }
  567.   | AtPat                       { [$1] }
  568. ;
  569.  
  570. PatComma_seq0 :
  571.     PatComma_seq1               { $1 }
  572.   | /* */                       { [] }
  573. ;
  574.  
  575. PatComma_seq1 :
  576.     Pat COMMA PatComma_seq1     { $1 :: $3 }
  577.   | Pat                         { [$1] }
  578. ;
  579.  
  580. PatComma_seq2 :
  581.     Pat COMMA PatComma_seq1     { $1 :: $3 }
  582. ;
  583.  
  584. Ty :
  585.     TupleTy ARROW Ty    { mkLoc(FNty( tupleTy $1, $3)) }
  586.   | TupleTy             { tupleTy $1 }
  587. ;
  588.  
  589. TupleTy :
  590.     Ty_sans_STAR                { [$1] }
  591.   | Ty_sans_STAR STAR TupleTy   { $1 :: $3 }
  592. ;
  593.  
  594. Ty_sans_STAR :
  595.     LPAREN TyComma_seq2 RPAREN LongTypeIdent    { mkLoc(CONty($2, $4)) }
  596.   | Ty_sans_STAR LongTypeIdent                  { mkLoc(CONty([$1], $2)) }
  597.   | AtomicTy                                    { $1 }
  598. ;
  599.  
  600. TyComma_seq2 :
  601.     Ty COMMA TyComma_seq2       { $1 :: $3 }
  602.   | Ty COMMA Ty                 { [$1, $3] }
  603. ;
  604.  
  605. AtomicTy :
  606.     LongTypeIdent               { mkLoc(CONty([], $1)) }
  607.   | TyVar                       { mkLoc(TYVARty $1) }
  608.   | LBRACE TyRow_opt RBRACE     { mkLoc(RECty $2) }
  609.   | LPAREN Ty RPAREN            { $2 }
  610. ;
  611.  
  612. TyRow_opt :
  613.     TyRow       { $1 }
  614.   | /* */       { [] }
  615. ;
  616.  
  617. TyRow :
  618.     Label COLON Ty CommaTyRow_opt       { ($1,$3)::$4 }
  619. ;
  620.  
  621. CommaTyRow_opt :
  622.     COMMA TyRow         { $2 }
  623.   | /* */               { [] }
  624. ;
  625.  
  626. TyVarSeq :
  627.     TyVarSeq1                           { $1 }
  628.   | /* */                               { [] }
  629. ;
  630.  
  631. TyVarSeq1 :
  632.     TyVar                               { [$1] }
  633.   | LPAREN TyVarComma_seq1 RPAREN       { $2 }
  634. ;
  635.  
  636. TyVarComma_seq1 :
  637.     TyVar COMMA TyVarComma_seq1         { $1 :: $3 }
  638.   | TyVar                               { [$1] }
  639. ;
  640.  
  641. Spec :
  642.     KWSpec Spec         { mkLoc(SEQspec($1, $2)) }
  643.   | SEMICOLON Spec      { $2 }
  644.   | /* */               { mkLoc(EMPTYspec) }
  645. ;
  646.  
  647. SigFile :
  648.     SIGNATURE LocUnitName EQUALS SIG KWSpec_seq END SemiEof
  649.                         { NamedSig{locsigid = $2, specs = $5 } }
  650.   | KWSpec_seq EOF    { AnonSig $1 }
  651. ;
  652.  
  653. KWSpec_seq :
  654.     KWSpec KWSpec_seq        { $1 :: $2 }
  655.   | SEMICOLON KWSpec_seq    { $2 }
  656.   | /* */            { [] }
  657. ;
  658.  
  659. KWSpec :
  660.     VAL ValDesc                 { mkLoc(VALspec $2) }
  661.   | PRIM_VAL PrimValBind        { mkLoc(PRIM_VALspec $2) }
  662.   | TYPE TypBind                { mkLoc(TYPEspec $2) }
  663.   | TYPE TypDesc                { mkLoc(TYPEDESCspec(FALSEequ, $2)) }
  664.   | EQTYPE TypDesc              { mkLoc(TYPEDESCspec(TRUEequ, $2)) }
  665.   | PRIM_REFTYPE TypDesc        { mkLoc(TYPEDESCspec(REFequ, $2)) }
  666.   | DATATYPE DatBind WithType_opt
  667.                                 { mkLoc(DATATYPEspec($2,$3)) }
  668.   | EXCEPTION ExDesc            { mkLoc(EXCEPTIONspec $2) }
  669.   | LOCAL Spec IN Spec END      { mkLoc(LOCALspec($2,$4)) }
  670.   | OPEN UnitName_seq1          { mkLoc(OPENspec $2) }
  671. ;
  672.  
  673. ValDesc :
  674.     OpIdent COLON Ty AndValDesc_opt
  675.                         { ($1, $3) :: $4 }
  676. ;
  677.  
  678. AndValDesc_opt :
  679.     AND ValDesc         { $2 }
  680.   | /* */               { [] }
  681. ;
  682.  
  683. TypDesc :
  684.     TyVarSeq TypeIdent AndTypDesc_opt
  685.                         { ($1, $2) :: $3 }
  686. ;
  687.  
  688. AndTypDesc_opt :
  689.     AND TypDesc         { $2 }
  690.   | /* */               { [] }
  691. ;
  692.