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