X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fparser%2FParser.y;h=9269c59fc02f631eed86f1bf247906dcbd411f6c;hb=9097c4392e0f95f8dcbde07a1997680ec2a02d46;hp=8894a000245ec5d690ce444be60fec9dfba8b551;hpb=2f4b06256b28a4b0a41441e7f6962a8dddbd7729;p=ghc-hetmet.git diff --git a/ghc/compiler/parser/Parser.y b/ghc/compiler/parser/Parser.y index 8894a00..9269c59 100644 --- a/ghc/compiler/parser/Parser.y +++ b/ghc/compiler/parser/Parser.y @@ -1,6 +1,6 @@ {- ----------------------------------------------------------------------------- -$Id: Parser.y,v 1.60 2001/05/07 14:38:15 simonmar Exp $ +$Id: Parser.y,v 1.68 2001/06/13 15:50:57 rrt Exp $ Haskell grammar. @@ -21,16 +21,21 @@ import RdrName import PrelNames ( mAIN_Name, unitTyCon_RDR, funTyCon_RDR, listTyCon_RDR, tupleTyCon_RDR, unitCon_RDR, nilCon_RDR, tupleCon_RDR ) +import ForeignCall ( Safety(..), CExportSpec(..), CCallSpec(..), + CCallConv(..), CCallTarget(..), defaultCCallConv, + DNCallSpec(..) ) import OccName ( UserFS, varName, tcName, dataName, tcClsName, tvName ) import SrcLoc ( SrcLoc ) import Module -import CallConv +import Demand ( StrictnessMark(..) ) import CmdLineOpts ( opt_SccProfilingOn ) import BasicTypes ( Boxity(..), Fixity(..), FixityDirection(..), NewOrData(..) ) import Panic import GlaExts +import CStrings ( CLabelString ) import FastString ( tailFS ) +import Maybes ( orElse ) import Outputable #include "HsVersions.h" @@ -101,10 +106,11 @@ Conflicts: 14 shift/reduce 'with' { ITwith } 'stdcall' { ITstdcallconv } 'ccall' { ITccallconv } - '_ccall_' { ITccall (False, False, False) } - '_ccall_GC_' { ITccall (False, False, True) } - '_casm_' { ITccall (False, True, False) } - '_casm_GC_' { ITccall (False, True, True) } + 'dotnet' { ITdotnet } + '_ccall_' { ITccall (False, False, PlayRisky) } + '_ccall_GC_' { ITccall (False, False, PlaySafe) } + '_casm_' { ITccall (False, True, PlayRisky) } + '_casm_GC_' { ITccall (False, True, PlaySafe) } '{-# SPECIALISE' { ITspecialise_prag } '{-# SOURCE' { ITsource_prag } @@ -335,10 +341,10 @@ topdecl :: { RdrBinding } -- Instead we just say b is out of scope { RdrHsDecl (TyClD (TySynonym (fst $3) (snd $3) $5 $1)) } - | srcloc 'data' ctype '=' constrs deriving + | srcloc 'data' ctype constrs deriving {% checkDataHeader $3 `thenP` \(cs,c,ts) -> returnP (RdrHsDecl (TyClD - (mkTyData DataType cs c ts (reverse $5) (length $5) $6 $1))) } + (mkTyData DataType cs c ts (reverse $4) (length $4) $5 $1))) } | srcloc 'newtype' ctype '=' newconstr deriving {% checkDataHeader $3 `thenP` \(cs,c,ts) -> @@ -359,23 +365,45 @@ topdecl :: { RdrBinding } (groupBindings $4) in RdrHsDecl (InstD (InstDecl $3 binds sigs Nothing $1)) } - | srcloc 'default' '(' types0 ')' - { RdrHsDecl (DefD (DefaultDecl $4 $1)) } + | srcloc 'default' '(' types0 ')' { RdrHsDecl (DefD (DefaultDecl $4 $1)) } + | 'foreign' fordecl { RdrHsDecl $2 } + | '{-# DEPRECATED' deprecations '#-}' { $2 } + | '{-# RULES' rules '#-}' { $2 } + | decl { $1 } - | srcloc 'foreign' 'import' callconv ext_name - unsafe_flag varid_no_unsafe '::' sigtype - { RdrHsDecl (ForD (ForeignDecl $7 (FoImport $6) $9 (mkExtName $5 $7) $4 $1)) } +fordecl :: { RdrNameHsDecl } +fordecl : srcloc 'label' ext_name varid '::' sigtype + { ForD (ForeignImport $4 $6 (LblImport ($3 `orElse` mkExtName $4)) $1) } - | srcloc 'foreign' 'export' callconv ext_name varid '::' sigtype - { RdrHsDecl (ForD (ForeignDecl $6 FoExport $8 (mkExtName $5 $6) $4 $1)) } - | srcloc 'foreign' 'label' ext_name varid '::' sigtype - { RdrHsDecl (ForD (ForeignDecl $5 FoLabel $7 (mkExtName $4 $5) - defaultCallConv $1)) } + ----------- ccall/stdcall decls ------------ + | srcloc 'import' ccallconv ext_name unsafe_flag varid_no_unsafe '::' sigtype + { let + call_spec = CCallSpec (StaticTarget ($4 `orElse` mkExtName $6)) $3 $5 + in + ForD (ForeignImport $6 $8 (CImport call_spec) $1) + } - | '{-# DEPRECATED' deprecations '#-}' { $2 } - | '{-# RULES' rules '#-}' { $2 } - | decl { $1 } + | srcloc 'import' ccallconv 'dynamic' unsafe_flag varid_no_unsafe '::' sigtype + { let + call_spec = CCallSpec DynamicTarget $3 $5 + in + ForD (ForeignImport $6 $8 (CImport call_spec) $1) + } + + | srcloc 'export' ccallconv ext_name varid '::' sigtype + { ForD (ForeignExport $5 $7 (CExport (CExportStatic ($4 `orElse` mkExtName $5) $3)) $1) } + + | srcloc 'export' ccallconv 'dynamic' varid '::' sigtype + { ForD (ForeignImport $5 $7 (CDynImport $3) $1) } + + + ----------- .NET decls ------------ + | srcloc 'import' 'dotnet' ext_name varid '::' sigtype + { ForD (ForeignImport $5 $7 (DNImport (DNCallSpec ($4 `orElse` mkExtName $5))) $1) } + + | srcloc 'import' 'dotnet' 'type' ext_name tycon + { TyClD (ForeignType $6 $5 DNType $1) } decls :: { [RdrBinding] } : decls ';' decl { $3 : $1 } @@ -461,19 +489,17 @@ deprecation :: { RdrBinding } ----------------------------------------------------------------------------- -- Foreign import/export -callconv :: { Int } - : 'stdcall' { stdCallConv } - | 'ccall' { cCallConv } - | {- empty -} { defaultCallConv } +ccallconv :: { CCallConv } + : 'stdcall' { StdCallConv } + | 'ccall' { CCallConv } + | {- empty -} { defaultCCallConv } -unsafe_flag :: { Bool } - : 'unsafe' { True } - | {- empty -} { False } +unsafe_flag :: { Safety } + : 'unsafe' { PlayRisky } + | {- empty -} { PlaySafe } -ext_name :: { Maybe ExtName } - : 'dynamic' { Just Dynamic } - | STRING { Just (ExtName $1 Nothing) } - | STRING STRING { Just (ExtName $2 (Just $1)) } +ext_name :: { Maybe CLabelString } + : STRING { Just $1 } | {- empty -} { Nothing } @@ -574,12 +600,16 @@ varids0 :: { [RdrName] } -- Datatype declarations newconstr :: { RdrNameConDecl } - : srcloc conid atype { mkConDecl $2 [] [] (VanillaCon [Unbanged $3]) $1 } + : srcloc conid atype { mkConDecl $2 [] [] (VanillaCon [unbangedType $3]) $1 } | srcloc conid '{' var '::' type '}' - { mkConDecl $2 [] [] (RecCon [([$4], Unbanged $6)]) $1 } + { mkConDecl $2 [] [] (RecCon [([$4], unbangedType $6)]) $1 } constrs :: { [RdrNameConDecl] } - : constrs '|' constr { $3 : $1 } + : {- empty; a GHC extension -} { [] } + | '=' constrs1 { $2 } + +constrs1 :: { [RdrNameConDecl] } + : constrs1 '|' constr { $3 : $1 } | constr { [$1] } constr :: { RdrNameConDecl } @@ -597,18 +627,18 @@ context :: { RdrNameContext } constr_stuff :: { (RdrName, RdrNameConDetails) } : btype {% mkVanillaCon $1 [] } - | btype '!' atype satypes {% mkVanillaCon $1 (Banged $3 : $4) } + | btype '!' atype satypes {% mkVanillaCon $1 (BangType MarkedUserStrict $3 : $4) } | gtycon '{' fielddecls '}' {% mkRecCon $1 $3 } | sbtype conop sbtype { ($2, InfixCon $1 $3) } satypes :: { [RdrNameBangType] } - : atype satypes { Unbanged $1 : $2 } - | '!' atype satypes { Banged $2 : $3 } + : atype satypes { unbangedType $1 : $2 } + | '!' atype satypes { BangType MarkedUserStrict $2 : $3 } | {- empty -} { [] } sbtype :: { RdrNameBangType } - : btype { Unbanged $1 } - | '!' atype { Banged $2 } + : btype { unbangedType $1 } + | '!' atype { BangType MarkedUserStrict $2 } fielddecls :: { [([RdrName],RdrNameBangType)] } : fielddecl ',' fielddecls { $1 : $3 } @@ -618,8 +648,8 @@ fielddecl :: { ([RdrName],RdrNameBangType) } : sig_vars '::' stype { (reverse $1, $3) } stype :: { RdrNameBangType } - : ctype { Unbanged $1 } - | '!' atype { Banged $2 } + : ctype { unbangedType $1 } + | '!' atype { BangType MarkedUserStrict $2 } deriving :: { Maybe [RdrName] } : {- empty -} { Nothing } @@ -672,7 +702,7 @@ gdrhs :: { [RdrNameGRHS] } | gdrh { [$1] } gdrh :: { RdrNameGRHS } - : '|' srcloc quals '=' exp { GRHS (reverse (ExprStmt $5 $2 : $3)) $2 } + : '|' srcloc quals '=' exp { GRHS (reverse (ResultStmt $5 $2 : $3)) $2 } ----------------------------------------------------------------------------- -- Expressions @@ -697,12 +727,13 @@ exp10 :: { RdrNameHsExpr } | '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 { HsDo DoExpr $3 $1 } + | srcloc 'do' stmtlist {% checkDo $3 `thenP` \ stmts -> + returnP (HsDo DoExpr stmts $1) } - | '_ccall_' ccallid aexps0 { HsCCall $2 $3 False False cbot } - | '_ccall_GC_' ccallid aexps0 { HsCCall $2 $3 True False cbot } - | '_casm_' CLITLIT aexps0 { HsCCall $2 $3 False True cbot } - | '_casm_GC_' CLITLIT aexps0 { HsCCall $2 $3 True True cbot } + | '_ccall_' ccallid aexps0 { HsCCall $2 $3 PlayRisky False cbot } + | '_ccall_GC_' ccallid aexps0 { HsCCall $2 $3 PlaySafe False cbot } + | '_casm_' CLITLIT aexps0 { HsCCall $2 $3 PlayRisky True cbot } + | '_casm_GC_' CLITLIT aexps0 { HsCCall $2 $3 PlaySafe True cbot } | scc_annot exp { if opt_SccProfilingOn then HsSCC $1 $2 @@ -777,7 +808,7 @@ list :: { RdrNameHsExpr } body qss = [ParStmt (map reverse qss)] } in returnP ( HsDo ListComp - (reverse (ExprStmt $1 $2 : body $3)) + (reverse (ResultStmt $1 $2 : body $3)) $2 ) } @@ -820,7 +851,7 @@ alt :: { RdrNameMatch } (GRHSs $4 $5 Nothing)) )} ralt :: { [RdrNameGRHS] } - : '->' srcloc exp { [GRHS [ExprStmt $3 $2] $2] } + : '->' srcloc exp { [GRHS [ResultStmt $3 $2] $2] } | gdpats { (reverse $1) } gdpats :: { [RdrNameGRHS] } @@ -828,30 +859,31 @@ gdpats :: { [RdrNameGRHS] } | gdpat { [$1] } gdpat :: { RdrNameGRHS } - : srcloc '|' quals '->' exp { GRHS (reverse (ExprStmt $5 $1:$3)) $1} + : srcloc '|' quals '->' exp { GRHS (reverse (ResultStmt $5 $1:$3)) $1} ----------------------------------------------------------------------------- -- Statement sequences stmtlist :: { [RdrNameStmt] } - : '{' stmts '}' { reverse $2 } - | layout_on_for_do stmts close { reverse $2 } - --- Stmt list should really end in an expression, but it's not --- convenient to enforce this here, so we throw out erroneous --- statement sequences in the renamer instead. - + : '{' stmts '}' { $2 } + | layout_on_for_do stmts close { $2 } + +-- do { ;; s ; s ; ; s ;; } +-- The last Stmt should be a ResultStmt, but that's hard to enforce +-- here, because we need too much lookahead if we see do { e ; } +-- So we use ExprStmts throughout, and switch the last one over +-- in ParseUtils.checkDo instead stmts :: { [RdrNameStmt] } - : ';' stmts1 { $2 } - | stmts1 { $1 } + : stmt stmts_help { $1 : $2 } + | ';' stmts { $2 } + | {- empty -} { [] } -stmts1 :: { [RdrNameStmt] } - : stmts1 ';' stmt { $3 : $1 } - | stmts1 ';' { $1 } - | stmt { [$1] } +stmts_help :: { [RdrNameStmt] } + : ';' stmts { $2 } + | {- empty -} { [] } --- for typing stmts at the GHCi prompt, where the input may consist of --- just comments. +-- For typing stmts at the GHCi prompt, where +-- the input may consist of just comments. maybe_stmt :: { Maybe RdrNameStmt } : stmt { Just $1 } | {- nothing -} { Nothing }