{-
-----------------------------------------------------------------------------
-$Id: Parser.y,v 1.64 2001/05/18 08:46:20 simonpj Exp $
+$Id: Parser.y,v 1.73 2001/08/20 10:19:47 simonmar Exp $
Haskell grammar.
-}
{
-module Parser ( parseModule, parseStmt ) where
+module Parser ( parseModule, parseStmt, parseIdentifier ) where
import HsSyn
import HsTypes ( mkHsTupCon )
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 BasicTypes ( Boxity(..), Fixity(..), FixityDirection(..), NewOrData(..), StrictnessMark(..) )
import Panic
import GlaExts
-import FastString ( tailFS )
+import CStrings ( CLabelString )
+import FastString
+import Maybes ( orElse )
import Outputable
#include "HsVersions.h"
'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 }
%lexer { lexer } { ITeof }
%name parseModule module
%name parseStmt maybe_stmt
+%name parseIdentifier identifier
%tokentype { Token }
%%
| {- empty -} { [] }
importdecl :: { RdrNameImportDecl }
- : 'import' srcloc maybe_src optqualified CONID maybeas maybeimpspec
- { ImportDecl (mkModuleNameFS $5) $3 $4 $6 $7 $2 }
+ : 'import' srcloc maybe_src optqualified modid maybeas maybeimpspec
+ { ImportDecl $5 $3 $4 $6 $7 $2 }
maybe_src :: { WhereFrom }
: '{-# SOURCE' '#-}' { ImportByUserSource }
-- 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) ->
(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 }
-----------------------------------------------------------------------------
-- 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 }
{ 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 }
rhs :: { RdrNameGRHSs }
- : '=' srcloc exp wherebinds { (GRHSs (unguardedRHS $3 $2)
- $4 Nothing)}
- | gdrhs wherebinds { GRHSs (reverse $1) $2 Nothing }
+ : '=' srcloc exp wherebinds { (GRHSs (unguardedRHS $3 $2) $4 placeHolderType)}
+ | gdrhs wherebinds { GRHSs (reverse $1) $2 placeHolderType }
gdrhs :: { [RdrNameGRHS] }
: gdrhs gdrh { $2 : $1 }
{% checkPatterns $2 ($3 : reverse $4) `thenP` \ ps ->
returnP (HsLam (Match [] ps $5
(GRHSs (unguardedRHS $8 $7)
- EmptyBinds Nothing))) }
+ EmptyBinds placeHolderType))) }
| 'let' declbinds '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 }
| 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 placeHolderType }
+ | '_ccall_GC_' ccallid aexps0 { HsCCall $2 $3 PlaySafe False placeHolderType }
+ | '_casm_' CLITLIT aexps0 { HsCCall $2 $3 PlayRisky True placeHolderType }
+ | '_casm_GC_' CLITLIT aexps0 { HsCCall $2 $3 PlaySafe True placeHolderType }
| scc_annot exp { if opt_SccProfilingOn
then HsSCC $1 $2
: ipvar { HsIPVar $1 }
| var_or_con { $1 }
| literal { HsLit $1 }
- | INTEGER { HsOverLit (HsIntegral $1) }
- | RATIONAL { HsOverLit (HsFractional $1) }
+ | INTEGER { HsOverLit (mkHsIntegral $1) }
+ | RATIONAL { HsOverLit (mkHsFractional $1) }
| '(' exp ')' { HsPar $2 }
| '(' exp ',' texps ')' { ExplicitTuple ($2 : reverse $4) Boxed}
| '(#' texps '#)' { ExplicitTuple (reverse $2) Unboxed }
-- avoiding another shift/reduce-conflict.
list :: { RdrNameHsExpr }
- : exp { ExplicitList [$1] }
- | lexps { ExplicitList (reverse $1) }
+ : exp { ExplicitList placeHolderType [$1] }
+ | lexps { ExplicitList placeHolderType (reverse $1) }
| exp '..' { ArithSeqIn (From $1) }
| exp ',' exp '..' { ArithSeqIn (FromThen $1 $3) }
| exp '..' exp { ArithSeqIn (FromTo $1 $3) }
: srcloc infixexp opt_sig ralt wherebinds
{% (checkPattern $1 $2 `thenP` \p ->
returnP (Match [] [p] $3
- (GRHSs $4 $5 Nothing)) )}
+ (GRHSs $4 $5 placeHolderType)) )}
ralt :: { [RdrNameGRHS] }
: '->' srcloc exp { [GRHS [ResultStmt $3 $2] $2] }
stmt :: { RdrNameStmt }
: srcloc infixexp '<-' exp {% checkPattern $1 $2 `thenP` \p ->
returnP (BindStmt p $4 $1) }
- | srcloc exp { ExprStmt $2 $1 }
+ | srcloc exp { ExprStmt $2 placeHolderType $1 }
| srcloc 'let' declbinds { LetStmt $3 }
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
-- Variables, Constructors and Operators.
+identifier :: { RdrName }
+ : qvar { $1 }
+ | gcon { $1 }
+ | qop { $1 }
+
depreclist :: { [RdrName] }
depreclist : deprec_var { [$1] }
| deprec_var ',' depreclist { $1 : $3 }
| PRIMSTRING { HsStringPrim $1 }
| PRIMFLOAT { HsFloatPrim $1 }
| PRIMDOUBLE { HsDoublePrim $1 }
- | CLITLIT { HsLitLit $1 (error "Parser.y: CLITLIT") }
+ | CLITLIT { HsLitLit $1 placeHolderType }
srcloc :: { SrcLoc } : {% getSrcLocP }
modid :: { ModuleName }
: CONID { mkModuleNameFS $1 }
+ | QCONID { mkModuleNameFS
+ (mkFastString
+ (unpackFS (fst $1) ++
+ '.':unpackFS (snd $1)))
+ }
tycon :: { RdrName }
: CONID { mkUnqual tcClsName $1 }
projects / ghc-hetmet.git / blobdiff