X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;ds=sidebyside;f=ghc%2Fcompiler%2Fparser%2FParser.y;h=907c929a78589089314510a1fc47e268677d4331;hb=b3ecf49e3a19b241630641f715854847190e494e;hp=6daeba9d38f057a2ddca36cbc31426787814f453;hpb=9d14163136f08c71a11a62b0ae9516bfe6f326d2;p=ghc-hetmet.git diff --git a/ghc/compiler/parser/Parser.y b/ghc/compiler/parser/Parser.y index 6daeba9..907c929 100644 --- a/ghc/compiler/parser/Parser.y +++ b/ghc/compiler/parser/Parser.y @@ -1,6 +1,6 @@ {- -*-haskell-*- ----------------------------------------------------------------------------- -$Id: Parser.y,v 1.103 2002/09/19 12:31:09 simonmar Exp $ +$Id: Parser.y,v 1.114 2002/12/10 16:28:48 igloo Exp $ Haskell grammar. @@ -17,9 +17,8 @@ import HsSyn import HsTypes ( mkHsTupCon ) import RdrHsSyn -import HscTypes ( ParsedIface(..), IsBootInterface ) +import HscTypes ( ParsedIface(..), IsBootInterface, noDependencies ) import Lex -import ParseUtil import RdrName import PrelNames ( mAIN_Name, funTyConName, listTyConName, parrTyConName, consDataConName, nilDataConName ) @@ -126,6 +125,7 @@ Conflicts: 29 shift/reduce, [SDM 19/9/2002] 'threadsafe' { ITthreadsafe } 'unsafe' { ITunsafe } 'with' { ITwith } + 'mdo' { ITmdo } 'stdcall' { ITstdcallconv } 'ccall' { ITccallconv } 'dotnet' { ITdotnet } @@ -236,8 +236,11 @@ Conflicts: 29 shift/reduce, [SDM 19/9/2002] '[t|' { ITopenTypQuote } '[d|' { ITopenDecQuote } '|]' { ITcloseQuote } -ID_SPLICE { ITidEscape $$ } -- $x -'$(' { ITparenEscape } -- $( exp ) +ID_SPLICE { ITidEscape $$ } -- $x +'$(' { ITparenEscape } -- $( exp ) +REIFY_TYPE { ITreifyType } +REIFY_DECL { ITreifyDecl } +REIFY_FIXITY { ITreifyFixity } %monad { P } { thenP } { returnP } %lexer { lexer } { ITeof } @@ -279,7 +282,7 @@ top :: { ([RdrNameImportDecl], [RdrNameHsDecl]) } | cvtopdecls { ([],$1) } cvtopdecls :: { [RdrNameHsDecl] } - : topdecls { cvTopDecls (groupBindings $1)} + : topdecls { cvTopDecls $1 } ----------------------------------------------------------------------------- -- Interfaces (.hi-boot files) @@ -292,6 +295,7 @@ iface :: { ParsedIface } pi_vers = 1, -- Module version pi_orphan = False, pi_exports = (1,[($2,mkIfaceExports $4)]), + pi_deps = noDependencies, pi_usages = [], pi_fixity = [], pi_insts = [], @@ -306,30 +310,14 @@ ifacebody :: { [RdrNameTyClDecl] } | layout_on ifacedecls close { $2 } ifacedecls :: { [RdrNameTyClDecl] } - : ifacedecl ';' ifacedecls { $1 : $3 } - | ';' ifacedecls { $2 } - | ifacedecl { [$1] } - | {- empty -} { [] } + : ifacedecl ';' ifacedecls { $1 : $3 } + | ';' ifacedecls { $2 } + | ifacedecl { [$1] } + | {- empty -} { [] } ifacedecl :: { RdrNameTyClDecl } - : srcloc 'data' tycl_hdr constrs - { mkTyData DataType $3 (DataCons (reverse $4)) Nothing $1 } - - | srcloc 'newtype' tycl_hdr '=' newconstr - { mkTyData NewType $3 (DataCons [$5]) Nothing $1 } - - | srcloc 'class' tycl_hdr fds where - { let - (binds,sigs) = cvMonoBindsAndSigs cvClassOpSig - (groupBindings $5) - in - mkClassDecl $3 $4 sigs (Just binds) $1 } - - | srcloc 'type' tycon tv_bndrs '=' ctype - { TySynonym $3 $4 $6 $1 } - - | srcloc var '::' sigtype - { IfaceSig $2 $4 [] $1 } + : tycl_decl { $1 } + | srcloc var '::' sigtype { IfaceSig $2 $4 [] $1 } ----------------------------------------------------------------------------- -- The Export List @@ -403,8 +391,7 @@ impspec :: { (Bool, [RdrNameIE]) } prec :: { Int } : {- empty -} { 9 } - | INTEGER {% checkPrec $1 `thenP_` - returnP (fromInteger $1) } + | INTEGER {% checkPrecP (fromInteger $1) } infix :: { FixityDirection } : 'infix' { InfixN } @@ -418,48 +405,43 @@ ops :: { [RdrName] } ----------------------------------------------------------------------------- -- Top-Level Declarations -topdecls :: { [RdrBinding] } - : topdecls ';' topdecl { ($3 : $1) } +topdecls :: { [RdrBinding] } -- Reversed + : topdecls ';' topdecl { $3 : $1 } | topdecls ';' { $1 } | topdecl { [$1] } topdecl :: { RdrBinding } + : tycl_decl { RdrHsDecl (TyClD $1) } + | srcloc 'instance' inst_type where + { let (binds,sigs) = cvMonoBindsAndSigs $4 + in RdrHsDecl (InstD (InstDecl $3 binds sigs Nothing $1)) } + | srcloc 'default' '(' comma_types0 ')' { RdrHsDecl (DefD (DefaultDecl $4 $1)) } + | 'foreign' fdecl { RdrHsDecl $2 } + | '{-# DEPRECATED' deprecations '#-}' { RdrBindings (reverse $2) } + | '{-# RULES' rules '#-}' { RdrBindings (reverse $2) } + | srcloc '$(' exp ')' { RdrHsDecl (SpliceD (SpliceDecl $3 $1)) } + | decl { $1 } + +tycl_decl :: { RdrNameTyClDecl } : srcloc 'type' syn_hdr '=' ctype -- Note ctype, not sigtype. -- We allow an explicit for-all but we don't insert one -- in type Foo a = (b,b) -- Instead we just say b is out of scope - { let (tc,tvs) = $3 - in RdrHsDecl (TyClD (TySynonym tc tvs $5 $1)) } + { let (tc,tvs) = $3 in TySynonym tc tvs $5 $1 } | srcloc 'data' tycl_hdr constrs deriving - {% returnP (RdrHsDecl (TyClD - (mkTyData DataType $3 (DataCons (reverse $4)) $5 $1))) } + { mkTyData DataType $3 (DataCons (reverse $4)) $5 $1 } | srcloc 'newtype' tycl_hdr '=' newconstr deriving - {% returnP (RdrHsDecl (TyClD - (mkTyData NewType $3 (DataCons [$5]) $6 $1))) } + { mkTyData NewType $3 (DataCons [$5]) $6 $1 } | srcloc 'class' tycl_hdr fds where - {% let - (binds,sigs) = cvMonoBindsAndSigs cvClassOpSig (groupBindings $5) - in - returnP (RdrHsDecl (TyClD - (mkClassDecl $3 $4 sigs (Just binds) $1))) } - - | srcloc 'instance' inst_type where - { let (binds,sigs) - = cvMonoBindsAndSigs cvInstDeclSig - (groupBindings $4) - in RdrHsDecl (InstD (InstDecl $3 binds sigs Nothing $1)) } - - | srcloc 'default' '(' comma_types0 ')' { RdrHsDecl (DefD (DefaultDecl $4 $1)) } - | 'foreign' fdecl { RdrHsDecl $2 } - | '{-# DEPRECATED' deprecations '#-}' { $2 } - | '{-# RULES' rules '#-}' { $2 } - | '$(' exp ')' { RdrHsDecl (SpliceD $2) } - | decl { $1 } + { let + (binds,sigs) = cvMonoBindsAndSigs $5 + in + mkClassDecl $3 $4 (map cvClassOpSig sigs) (Just binds) $1 } syn_hdr :: { (RdrName, [RdrNameHsTyVar]) } -- We don't retain the syntax of an infix -- type synonym declaration. Oh well. @@ -478,94 +460,44 @@ tycl_hdr :: { (RdrNameContext, RdrName, [RdrNameHsTyVar]) } | type {% checkTyClHdr $1 `thenP` \ (tc,tvs) -> returnP ([], tc, tvs) } -{- - : '(' comma_types1 ')' '=>' gtycon tv_bndrs - {% mapP checkPred $2 `thenP` \ cxt -> - returnP (cxt, $5, $6) } - - | '(' ')' '=>' gtycon tv_bndrs - { ([], $4, $5) } - - -- qtycon for the class below name would lead to many s/r conflicts - -- FIXME: does the renamer pick up all wrong forms and raise an - -- error - | gtycon atypes1 '=>' gtycon atypes0 - {% checkTyVars $5 `thenP` \ tvs -> - returnP ([HsClassP $1 $2], $4, tvs) } - - | gtycon atypes0 - {% checkTyVars $2 `thenP` \ tvs -> - returnP ([], $1, tvs) } - -- We have to have qtycon in this production to avoid s/r - -- conflicts with the previous one. The renamer will complain - -- if we use a qualified tycon. - -- - -- Using a `gtycon' throughout. This enables special syntax, - -- such as "[]" for tycons as well as tycon ops in - -- parentheses. This is beyond H98, but used repeatedly in - -- the Prelude modules. (So, it would be a good idea to raise - -- an error in the renamer if some non-H98 form is used and - -- -fglasgow-exts is not given.) -=chak - -atypes0 :: { [RdrNameHsType] } - : atypes1 { $1 } - | {- empty -} { [] } - -atypes1 :: { [RdrNameHsType] } - : atype { [$1] } - | atype atypes1 { $1 : $2 } --} +----------------------------------------------------------------------------- +-- Nested declarations -decls :: { [RdrBinding] } +decls :: { [RdrBinding] } -- Reversed : decls ';' decl { $3 : $1 } | decls ';' { $1 } | decl { [$1] } | {- empty -} { [] } -decl :: { RdrBinding } - : fixdecl { $1 } - | valdef { $1 } - | '{-# INLINE' srcloc activation qvar '#-}' { RdrSig (InlineSig True $4 $3 $2) } - | '{-# NOINLINE' srcloc inverse_activation qvar '#-}' { RdrSig (InlineSig False $4 $3 $2) } - | '{-# SPECIALISE' srcloc qvar '::' sigtypes '#-}' - { foldr1 RdrAndBindings - (map (\t -> RdrSig (SpecSig $3 t $2)) $5) } - | '{-# SPECIALISE' srcloc 'instance' inst_type '#-}' - { RdrSig (SpecInstSig $4 $2) } -wherebinds :: { RdrNameHsBinds } - : where { cvBinds cvValSig (groupBindings $1) } +decllist :: { [RdrBinding] } -- Reversed + : '{' decls '}' { $2 } + | layout_on decls close { $2 } -where :: { [RdrBinding] } +where :: { [RdrBinding] } -- Reversed + -- No implicit parameters : 'where' decllist { $2 } | {- empty -} { [] } -declbinds :: { RdrNameHsBinds } - : decllist { cvBinds cvValSig (groupBindings $1) } +binds :: { RdrNameHsBinds } -- May have implicit parameters + : decllist { cvBinds $1 } + | '{' dbinds '}' { IPBinds $2 False{-not with-} } + | layout_on dbinds close { IPBinds $2 False{-not with-} } -decllist :: { [RdrBinding] } - : '{' decls '}' { $2 } - | layout_on decls close { $2 } +wherebinds :: { RdrNameHsBinds } -- May have implicit parameters + : 'where' binds { $2 } + | {- empty -} { EmptyBinds } -letbinds :: { RdrNameHsExpr -> RdrNameHsExpr } - : decllist { HsLet (cvBinds cvValSig (groupBindings $1)) } - | '{' dbinds '}' { \e -> HsWith e $2 False{-not with-} } - | layout_on dbinds close { \e -> HsWith e $2 False{-not with-} } -fixdecl :: { RdrBinding } - : srcloc infix prec ops { foldr1 RdrAndBindings - [ RdrSig (FixSig (FixitySig n - (Fixity $3 $2) $1)) - | n <- $4 ] } ----------------------------------------------------------------------------- -- Transformation Rules -rules :: { RdrBinding } - : rules ';' rule { $1 `RdrAndBindings` $3 } +rules :: { [RdrBinding] } -- Reversed + : rules ';' rule { $3 : $1 } | rules ';' { $1 } - | rule { $1 } - | {- empty -} { RdrNullBind } + | rule { [$1] } + | {- empty -} { [] } rule :: { RdrBinding } : STRING activation rule_forall infixexp '=' srcloc exp @@ -596,18 +528,18 @@ rule_var :: { RdrNameRuleBndr } | '(' varid '::' ctype ')' { RuleBndrSig $2 $4 } ----------------------------------------------------------------------------- --- Deprecations +-- Deprecations (c.f. rules) -deprecations :: { RdrBinding } - : deprecations ';' deprecation { $1 `RdrAndBindings` $3 } - | deprecations ';' { $1 } - | deprecation { $1 } - | {- empty -} { RdrNullBind } +deprecations :: { [RdrBinding] } -- Reversed + : deprecations ';' deprecation { $3 : $1 } + | deprecations ';' { $1 } + | deprecation { [$1] } + | {- empty -} { [] } -- SUP: TEMPORARY HACK, not checking for `module Foo' deprecation :: { RdrBinding } : srcloc depreclist STRING - { foldr RdrAndBindings RdrNullBind + { RdrBindings [ RdrHsDecl (DeprecD (Deprecation n $3 $1)) | n <- $2 ] } @@ -746,8 +678,8 @@ safety1 :: { Safety } -- only needed to avoid conflicts with the DEPRECATED rules fspec :: { (FastString, RdrName, RdrNameHsType) } - : STRING varid '::' sigtype { ($1 , $2, $4) } - | varid '::' sigtype { (nilFS, $1, $3) } + : STRING var '::' sigtype { ($1 , $2, $4) } + | var '::' sigtype { (nilFS, $1, $3) } -- if the entity string is missing, it defaults to the empty string; -- the meaning of an empty entity string depends on the calling -- convention @@ -956,16 +888,13 @@ deriving :: { Maybe RdrNameContext } We can't tell whether to reduce var to qvar until after we've read the signatures. -} -valdef :: { RdrBinding } - : infixexp srcloc opt_sig rhs {% (checkValDef $1 $3 $4 $2) } - | infixexp srcloc '::' sigtype {% (checkValSig $1 $4 $2) } - | var ',' sig_vars srcloc '::' sigtype { foldr1 RdrAndBindings - [ RdrSig (Sig n $6 $4) | n <- $1:$3 ] - } +decl :: { RdrBinding } + : sigdecl { $1 } + | infixexp srcloc opt_sig rhs {% checkValDef $1 $3 $4 $2 } rhs :: { RdrNameGRHSs } - : '=' srcloc exp wherebinds { (GRHSs (unguardedRHS $3 $2) $4 placeHolderType)} - | gdrhs wherebinds { GRHSs (reverse $1) $2 placeHolderType } + : '=' srcloc exp wherebinds { GRHSs (unguardedRHS $3 $2) $4 placeHolderType } + | gdrhs wherebinds { GRHSs (reverse $1) $2 placeHolderType } gdrhs :: { [RdrNameGRHS] } : gdrhs gdrh { $2 : $1 } @@ -974,12 +903,29 @@ gdrhs :: { [RdrNameGRHS] } gdrh :: { RdrNameGRHS } : '|' srcloc quals '=' exp { GRHS (reverse (ResultStmt $5 $2 : $3)) $2 } +sigdecl :: { RdrBinding } + : infixexp srcloc '::' sigtype + {% checkValSig $1 $4 $2 } + -- See the above notes for why we need infixexp here + | var ',' sig_vars srcloc '::' sigtype + { mkSigDecls [ Sig n $6 $4 | n <- $1:$3 ] } + | srcloc infix prec ops { mkSigDecls [ FixSig (FixitySig n (Fixity $3 $2) $1) + | n <- $4 ] } + | '{-# INLINE' srcloc activation qvar '#-}' + { RdrHsDecl (SigD (InlineSig True $4 $3 $2)) } + | '{-# NOINLINE' srcloc inverse_activation qvar '#-}' + { RdrHsDecl (SigD (InlineSig False $4 $3 $2)) } + | '{-# SPECIALISE' srcloc qvar '::' sigtypes '#-}' + { mkSigDecls [ SpecSig $3 t $2 | t <- $5] } + | '{-# SPECIALISE' srcloc 'instance' inst_type '#-}' + { RdrHsDecl (SigD (SpecInstSig $4 $2)) } + ----------------------------------------------------------------------------- -- Expressions exp :: { RdrNameHsExpr } - : infixexp '::' sigtype { (ExprWithTySig $1 $3) } - | infixexp 'with' dbinding { HsWith $1 $3 True{-not a let-} } + : infixexp '::' sigtype { ExprWithTySig $1 $3 } + | infixexp 'with' dbinding { HsLet (IPBinds $3 True{-not a let-}) $1 } | infixexp { $1 } infixexp :: { RdrNameHsExpr } @@ -993,12 +939,14 @@ exp10 :: { RdrNameHsExpr } returnP (HsLam (Match ps $5 (GRHSs (unguardedRHS $8 $7) EmptyBinds placeHolderType))) } - | 'let' letbinds 'in' exp { $2 $4 } + | 'let' binds 'in' exp { HsLet $2 $4 } | 'if' srcloc exp 'then' exp 'else' exp { HsIf $3 $5 $7 $2 } | 'case' srcloc exp 'of' altslist { HsCase $3 $5 $2 } | '-' fexp { mkHsNegApp $2 } | srcloc 'do' stmtlist {% checkDo $3 `thenP` \ stmts -> returnP (mkHsDo DoExpr stmts $1) } + | srcloc 'mdo' stmtlist {% checkMDo $3 `thenP` \ stmts -> + returnP (mkHsDo MDoExpr stmts $1) } | '_ccall_' ccallid aexps0 { HsCCall $2 $3 PlayRisky False placeHolderType } | '_ccall_GC_' ccallid aexps0 { HsCCall $2 $3 (PlaySafe False) False placeHolderType } @@ -1009,6 +957,7 @@ exp10 :: { RdrNameHsExpr } then HsSCC $1 $2 else HsPar $2 } + | reifyexp { HsReify $1 } | fexp { $1 } scc_annot :: { FastString } @@ -1023,6 +972,12 @@ fexp :: { RdrNameHsExpr } : fexp aexp { (HsApp $1 $2) } | aexp { $1 } +reifyexp :: { HsReify RdrName } + : REIFY_DECL gtycon { Reify ReifyDecl $2 } + | REIFY_DECL qvar { Reify ReifyDecl $2 } + | REIFY_TYPE qcname { Reify ReifyType $2 } + | REIFY_FIXITY qcname { Reify ReifyFixity $2 } + aexps0 :: { [RdrNameHsExpr] } : aexps { reverse $1 } @@ -1060,14 +1015,17 @@ aexp2 :: { RdrNameHsExpr } | '_' { EWildPat } -- MetaHaskell Extension - | ID_SPLICE { mkHsSplice (HsVar (mkUnqual varName $1))} -- $x - | '$(' exp ')' { mkHsSplice $2 } -- $( exp ) - | '[|' exp '|]' { HsBracket (ExpBr $2) } - | '[t|' ctype '|]' { HsBracket (TypBr $2) } - | '[p|' srcloc infixexp '|]' {% checkPattern $2 $3 `thenP` \p -> - returnP (HsBracket (PatBr p)) } - | '[d|' cvtopdecls '|]' { HsBracket (DecBr $2) } - + | srcloc ID_SPLICE { mkHsSplice (HsVar (mkUnqual varName $2)) $1 } -- $x + | srcloc '$(' exp ')' { mkHsSplice $3 $1 } -- $( exp ) + | srcloc '[|' exp '|]' { HsBracket (ExpBr $3) $1 } + | srcloc '[t|' ctype '|]' { HsBracket (TypBr $3) $1 } + | srcloc '[p|' infixexp '|]' {% checkPattern $1 $3 `thenP` \p -> + returnP (HsBracket (PatBr p) $1) } + | srcloc '[d|' cvtopbody '|]' { HsBracket (DecBr (mkGroup $3)) $1 } + +cvtopbody :: { [RdrNameHsDecl] } + : '{' cvtopdecls '}' { $2 } + | layout_on cvtopdecls close { $2 } texps :: { [RdrNameHsExpr] } : texps ',' exp { $3 : $1 } @@ -1204,7 +1162,7 @@ stmt :: { RdrNameStmt } : srcloc infixexp '<-' exp {% checkPattern $1 $2 `thenP` \p -> returnP (BindStmt p $4 $1) } | srcloc exp { ExprStmt $2 placeHolderType $1 } - | srcloc 'let' declbinds { LetStmt $3 } + | srcloc 'let' binds { LetStmt $3 } ----------------------------------------------------------------------------- -- Record Field Update/Construction