{
-#include "HsVersions.h"
-
-module ParseIface ( parseIface ) where
-
-IMP_Ubiq(){-uitous-}
+module ParseIface ( parseIface, IfaceStuff(..) ) where
-import CmdLineOpts ( opt_IgnoreIfacePragmas )
+#include "HsVersions.h"
import HsSyn -- quite a bit of stuff
import RdrHsSyn -- oodles of synonyms
-import HsDecls ( HsIdInfo(..) )
+import HsDecls ( HsIdInfo(..), HsStrictnessInfo(..) )
import HsTypes ( mkHsForAllTy )
import HsCore
import Literal
-import HsPragmas ( noGenPragmas, noDataPragmas, noClassPragmas, noClassOpPragmas, noInstancePragmas )
-import IdInfo ( exactArity, mkStrictnessInfo, mkBottomStrictnessInfo,
- ArgUsageInfo, FBTypeInfo
- )
-import Kind ( Kind, mkArrowKind, mkTypeKind )
+import BasicTypes ( IfaceFlavour(..), Fixity(..), FixityDirection(..), NewOrData(..), Version(..) )
+import HsPragmas ( noDataPragmas, noClassPragmas )
+import Kind ( Kind, mkArrowKind, mkBoxedTypeKind, mkTypeKind )
+import IdInfo ( ArgUsageInfo, FBTypeInfo, ArityInfo, exactArity )
+import PrimRep ( decodePrimRep )
import Lex
-import RnMonad ( SYN_IE(ImportVersion), SYN_IE(LocalVersion), ParsedIface(..),
- SYN_IE(RdrNamePragma), SYN_IE(ExportItem)
+import RnMonad ( ImportVersion, LocalVersion, ParsedIface(..), WhatsImported(..),
+ RdrNamePragma, ExportItem, RdrAvailInfo, GenAvailInfo(..)
)
import Bag ( emptyBag, unitBag, snocBag )
import FiniteMap ( emptyFM, unitFM, addToFM, plusFM, bagToFM, FiniteMap )
-import Name ( OccName(..), Provenance )
-import SrcLoc ( mkIfaceSrcLoc )
-import Util ( panic{-, pprPanic ToDo:rm-} )
-
-
------------------------------------------------------------------
+import Name ( OccName(..), isTCOcc, Provenance, SYN_IE(Module) )
+import SrcLoc ( SrcLoc )
+import Maybes
+import Outputable
-parseIface = parseIToks . lexIface
-
------------------------------------------------------------------
}
-%name parseIToks
+%name parseIface
%tokentype { IfaceToken }
%monad { IfM }{ thenIf }{ returnIf }
+%lexer { lexIface } { ITeof }
%token
INTERFACE { ITinterface }
FIXITIES_PART { ITfixities }
DECLARATIONS_PART { ITdeclarations }
PRAGMAS_PART { ITpragmas }
- BANG { ITbang }
- CBRACK { ITcbrack }
- CCURLY { ITccurly }
+ DATA { ITdata }
+ TYPE { ITtype }
+ NEWTYPE { ITnewtype }
+ DERIVING { ITderiving }
CLASS { ITclass }
+ WHERE { ITwhere }
+ INSTANCE { ITinstance }
+ INFIXL { ITinfixl }
+ INFIXR { ITinfixr }
+ INFIX { ITinfix }
+ FORALL { ITforall }
+ BANG { ITbang }
+ VBAR { ITvbar }
+ DCOLON { ITdcolon }
COMMA { ITcomma }
- CPAREN { ITcparen }
DARROW { ITdarrow }
- DATA { ITdata }
- DCOLON { ITdcolon }
- DERIVING { ITderiving }
DOTDOT { ITdotdot }
EQUAL { ITequal }
- FORALL { ITforall }
- INFIX { ITinfix }
- INFIXL { ITinfixl }
- INFIXR { ITinfixr }
- INSTANCE { ITinstance }
- NEWTYPE { ITnewtype }
- OBRACK { ITobrack }
OCURLY { ITocurly }
+ OBRACK { ITobrack }
OPAREN { IToparen }
RARROW { ITrarrow }
+ CCURLY { ITccurly }
+ CBRACK { ITcbrack }
+ CPAREN { ITcparen }
SEMI { ITsemi }
- TYPE { ITtype }
- VBAR { ITvbar }
- WHERE { ITwhere }
- INTEGER { ITinteger $$ }
+
VARID { ITvarid $$ }
CONID { ITconid $$ }
VARSYM { ITvarsym $$ }
QVARSYM { ITqvarsym $$ }
QCONSYM { ITqconsym $$ }
+ STRICT_PART { ITstrict $$ }
+ TYPE_PART { ITtysig _ _ }
ARITY_PART { ITarity }
- STRICT_PART { ITstrict }
- UNFOLD_PART { ITunfold }
- DEMAND { ITdemand $$ }
+ UNFOLD_PART { ITunfold $$ }
+ SPECIALISE { ITspecialise }
BOTTOM { ITbottom }
LAM { ITlam }
BIGLAM { ITbiglam }
CASE { ITcase }
PRIM_CASE { ITprim_case }
- OF { ITof }
LET { ITlet }
LETREC { ITletrec }
IN { ITin }
+ OF { ITof }
+ COERCE { ITcoerce }
ATSIGN { ITatsign }
- COERCE_IN { ITcoerce_in }
- COERCE_OUT { ITcoerce_out }
+ CCALL { ITccall $$ }
+ SCC { ITscc $$ }
+ INLINE_CALL { ITinline }
+
CHAR { ITchar $$ }
STRING { ITstring $$ }
+ INTEGER { ITinteger $$ }
DOUBLE { ITdouble $$ }
+
INTEGER_LIT { ITinteger_lit }
- STRING_LIT { ITstring_lit }
FLOAT_LIT { ITfloat_lit }
RATIONAL_LIT { ITrational_lit }
ADDR_LIT { ITaddr_lit }
LIT_LIT { ITlit_lit }
- CCALL { ITccall $$ }
+ STRING_LIT { ITstring_lit }
+
+ UNKNOWN { ITunknown $$ }
%%
+-- iface_stuff is the main production.
+-- It recognises (a) a whole interface file
+-- (b) a type (so that type sigs can be parsed lazily)
+-- (c) the IdInfo part of a signature (same reason)
+
+iface_stuff :: { IfaceStuff }
+iface_stuff : iface { PIface $1 }
+ | type { PType $1 }
+ | id_info { PIdInfo $1 }
+
+
iface :: { ParsedIface }
-iface : INTERFACE CONID INTEGER
+iface : INTERFACE CONID INTEGER checkVersion
inst_modules_part
usages_part
exports_part fixities_part
{ ParsedIface
$2 -- Module name
(fromInteger $3) -- Module version
- $5 -- Usages
- $6 -- Exports
- $4 -- Instance modules
- $7 -- Fixities
- $9 -- Decls
- $8 -- Local instances
+ $6 -- Usages
+ $7 -- Exports
+ $5 -- Instance modules
+ $8 -- Fixities
+ $10 -- Decls
+ $9 -- Local instances
}
| module_stuff_pair module_stuff_pairs { $1 : $2 }
module_stuff_pair :: { ImportVersion OccName }
-module_stuff_pair : mod_name INTEGER DCOLON name_version_pairs SEMI
- { ($1, fromInteger $2, $4) }
+module_stuff_pair : mod_name opt_bang INTEGER DCOLON whats_imported SEMI
+ { ($1, $2, fromInteger $3, $5) }
+
+whats_imported :: { WhatsImported OccName }
+whats_imported : { Everything }
+ | name_version_pair name_version_pairs { Specifically ($1:$2) }
versions_part :: { [LocalVersion OccName] }
versions_part : VERSIONS_PART name_version_pairs { $2 }
export_items :: { [ExportItem] }
export_items : { [] }
- | mod_name entities SEMI export_items { ($1,$2) : $4 }
+ | opt_bang mod_name entities SEMI export_items { ($2,$1,$3) : $5 }
+
+opt_bang :: { IfaceFlavour }
+opt_bang : { HiFile }
+ | BANG { HiBootFile }
-entities :: { [(OccName, [OccName])] }
+entities :: { [RdrAvailInfo] }
entities : { [] }
| entity entities { $1 : $2 }
-entity :: { (OccName, [OccName]) }
-entity : entity_occ maybe_inside { ($1, $2) }
+entity :: { RdrAvailInfo }
+entity : entity_occ { if isTCOcc $1
+ then AvailTC $1 [$1]
+ else Avail $1 }
+ | entity_occ stuff_inside { AvailTC $1 ($1:$2) }
+ | entity_occ VBAR stuff_inside { AvailTC $1 $3 }
-maybe_inside :: { [OccName] }
-maybe_inside : { [] }
- | OPAREN val_occs CPAREN { $2
+stuff_inside :: { [OccName] }
+stuff_inside : OPAREN val_occs1 CPAREN { $2
--------------------------------------------------------------------------
- }
+ }
inst_modules_part :: { [Module] }
inst_modules_part : { [] }
version : INTEGER { fromInteger $1 }
topdecl :: { RdrNameHsDecl }
-topdecl : TYPE tc_name tv_bndrs EQUAL type SEMI
- { TyD (TySynonym $2 $3 $5 mkIfaceSrcLoc) }
- | DATA decl_context tc_name tv_bndrs EQUAL constrs deriving SEMI
- { TyD (TyData $2 $3 $4 $6 $7 noDataPragmas mkIfaceSrcLoc) }
- | NEWTYPE decl_context tc_name tv_bndrs EQUAL constr1 deriving SEMI
- { TyD (TyNew $2 $3 $4 $6 $7 noDataPragmas mkIfaceSrcLoc) }
- | CLASS decl_context tc_name tv_bndr csigs SEMI
- { ClD (ClassDecl $2 $3 $4 $5 EmptyMonoBinds noClassPragmas mkIfaceSrcLoc) }
- | var_name DCOLON type id_info SEMI SEMI
- { {- Double semicolon allows easy pragma discard in lexer -}
- let
- id_info = if opt_IgnoreIfacePragmas then [] else $4
- in
- SigD (IfaceSig $1 $3 id_info mkIfaceSrcLoc) }
+topdecl : src_loc TYPE tc_name tv_bndrs EQUAL type SEMI
+ { TyD (TySynonym $3 $4 $6 $1) }
+ | src_loc DATA decl_context tc_name tv_bndrs constrs deriving SEMI
+ { TyD (TyData DataType $3 $4 $5 $6 $7 noDataPragmas $1) }
+ | src_loc NEWTYPE decl_context tc_name tv_bndrs newtype_constr deriving SEMI
+ { TyD (TyData NewType $3 $4 $5 $6 $7 noDataPragmas $1) }
+ | src_loc CLASS decl_context tc_name tv_bndrs csigs SEMI
+ { ClD (mkClassDecl $3 $4 $5 $6 EmptyMonoBinds noClassPragmas $1) }
+ | src_loc var_name TYPE_PART
+ {
+ case $3 of
+ ITtysig sig idinfo_part -> -- Parse type and idinfo lazily
+ let info =
+ case idinfo_part of
+ Nothing -> []
+ Just s -> case parseIface s $1 of
+ Succeeded (PIdInfo id_info) -> id_info
+ other -> pprPanic "IdInfo parse failed"
+ (ppr $2)
+
+ tp = case parseIface sig $1 of
+ Succeeded (PType tp) -> tp
+ other -> pprPanic "Id type parse failed"
+ (ppr $2)
+ in
+ SigD (IfaceSig $2 tp info $1) }
decl_context :: { RdrNameContext }
decl_context : { [] }
| OCURLY context_list1 CCURLY DARROW { $2 }
+
csigs :: { [RdrNameSig] }
csigs : { [] }
| WHERE OCURLY csigs1 CCURLY { $3 }
| csig SEMI csigs1 { $1 : $3 }
csig :: { RdrNameSig }
-csig : var_name DCOLON type { ClassOpSig $1 $3 noClassOpPragmas mkIfaceSrcLoc
+csig : src_loc var_name DCOLON type { ClassOpSig $2 Nothing $4 $1 }
+ | src_loc var_name EQUAL DCOLON type { ClassOpSig $2
+ (Just (error "Un-filled-in default method"))
+ $5 $1 }
----------------------------------------------------------------
- }
-constrs :: { [RdrNameConDecl] }
-constrs : constr { [$1] }
- | constr VBAR constrs { $1 : $3 }
+
+constrs :: { [RdrNameConDecl] {- empty for handwritten abstract -} }
+ : { [] }
+ | EQUAL constrs1 { $2 }
+
+constrs1 :: { [RdrNameConDecl] }
+constrs1 : constr { [$1] }
+ | constr VBAR constrs1 { $1 : $3 }
constr :: { RdrNameConDecl }
-constr : data_name batypes { ConDecl $1 $2 mkIfaceSrcLoc }
- | data_name OCURLY fields1 CCURLY { RecConDecl $1 $3 mkIfaceSrcLoc }
+constr : src_loc data_name batypes { ConDecl $2 [] (VanillaCon $3) $1 }
+ | src_loc data_name OCURLY fields1 CCURLY { ConDecl $2 [] (RecCon $4) $1 }
-constr1 :: { RdrNameConDecl {- For a newtype -} }
-constr1 : data_name atype { NewConDecl $1 $2 mkIfaceSrcLoc }
+newtype_constr :: { [RdrNameConDecl] {- Empty if handwritten abstract -} }
+newtype_constr : { [] }
+ | src_loc EQUAL data_name atype { [ConDecl $3 [] (NewCon $4) $1] }
deriving :: { Maybe [RdrName] }
: { Nothing }
- | DERIVING OPAREN qtc_names1 CPAREN { Just $3 }
+ | DERIVING OPAREN tc_names1 CPAREN { Just $3 }
batypes :: { [RdrNameBangType] }
batypes : { [] }
field :: { ([RdrName], RdrNameBangType) }
field : var_names1 DCOLON type { ($1, Unbanged $3) }
- | var_names1 DCOLON BANG type { ($1, Banged $4)
+ | var_names1 DCOLON BANG type { ($1, Banged $4) }
--------------------------------------------------------------------------
- }
+
+type :: { RdrNameHsType }
+type : FORALL forall context DARROW type { mkHsForAllTy $2 $3 $5 }
+ | btype RARROW type { MonoFunTy $1 $3 }
+ | btype { $1 }
forall :: { [HsTyVar RdrName] }
forall : OBRACK tv_bndrs CBRACK { $2 }
context_list1 : class { [$1] }
| class COMMA context_list1 { $1 : $3 }
-class :: { (RdrName, RdrNameHsType) }
-class : qtc_name atype { ($1, $2) }
-
-type :: { RdrNameHsType }
-type : FORALL forall context DARROW type { mkHsForAllTy $2 $3 $5 }
- | tautype { $1 }
-
-tautype :: { RdrNameHsType }
-tautype : btype { $1 }
- | btype RARROW tautype { MonoFunTy $1 $3 }
+class :: { (RdrName, [RdrNameHsType]) }
+class : tc_name atypes { ($1, $2) }
types2 :: { [RdrNameHsType] {- Two or more -} }
types2 : type COMMA type { [$1,$3] }
| btype atype { MonoTyApp $1 $2 }
atype :: { RdrNameHsType }
-atype : qtc_name { MonoTyVar $1 }
+atype : tc_name { MonoTyVar $1 }
| tv_name { MonoTyVar $1 }
| OPAREN types2 CPAREN { MonoTupleTy dummyRdrTcName $2 }
| OBRACK type CBRACK { MonoListTy dummyRdrTcName $2 }
- | OCURLY qtc_name atype CCURLY { MonoDictTy $2 $3 }
+ | OCURLY tc_name atypes CCURLY { MonoDictTy $2 $3 }
| OPAREN type CPAREN { $2 }
atypes :: { [RdrNameHsType] {- Zero or more -} }
atypes : { [] }
- | atype atypes { $1 : $2
+ | atype atypes { $1 : $2 }
---------------------------------------------------------------------
- }
mod_name :: { Module }
: CONID { $1 }
| CONID { VarOcc $1 }
| CONSYM { VarOcc $1 }
-val_occs :: { [OccName] }
- : { [] }
- | val_occ val_occs { $1 : $2 }
-
+val_occs1 :: { [OccName] }
+ : val_occ { [$1] }
+ | val_occ val_occs1 { $1 : $2 }
-qvar_name :: { RdrName }
- : QVARID { varQual $1 }
- | QVARSYM { varQual $1 }
var_name :: { RdrName }
var_name : var_occ { Unqual $1 }
-var_names1 :: { [RdrName] }
-var_names1 : var_name { [$1] }
- | var_name var_names1 { $1 : $2 }
+qvar_name :: { RdrName }
+qvar_name : var_name { $1 }
+ | QVARID { lexVarQual $1 }
+ | QVARSYM { lexVarQual $1 }
-any_var_name :: {RdrName}
-any_var_name : var_name { $1 }
- | qvar_name { $1 }
+var_names :: { [RdrName] }
+var_names : { [] }
+ | var_name var_names { $1 : $2 }
-qdata_name :: { RdrName }
-qdata_name : QCONID { varQual $1 }
- | QCONSYM { varQual $1 }
+var_names1 :: { [RdrName] }
+var_names1 : var_name var_names { $1 : $2 }
data_name :: { RdrName }
data_name : CONID { Unqual (VarOcc $1) }
| CONSYM { Unqual (VarOcc $1) }
-
-qtc_name :: { RdrName }
-qtc_name : QCONID { tcQual $1 }
-
-qtc_names1 :: { [RdrName] }
- : qtc_name { [$1] }
- | qtc_name COMMA qtc_names1 { $1 : $3 }
+qdata_name :: { RdrName }
+qdata_name : data_name { $1 }
+ | QCONID { lexVarQual $1 }
+ | QCONSYM { lexVarQual $1 }
+
+qdata_names :: { [RdrName] }
+qdata_names : { [] }
+ | qdata_name qdata_names { $1 : $2 }
tc_name :: { RdrName }
tc_name : tc_occ { Unqual $1 }
+ | QCONID { lexTcQual $1 }
+ | QCONSYM { lexTcQual $1 }
+
+tc_names1 :: { [RdrName] }
+ : tc_name { [$1] }
+ | tc_name COMMA tc_names1 { $1 : $3 }
tv_name :: { RdrName }
tv_name : VARID { Unqual (TvOcc $1) }
+ | VARSYM { Unqual (TvOcc $1) {- Allow t2 as a tyvar -} }
tv_names :: { [RdrName] }
: { [] }
| akind RARROW kind { mkArrowKind $1 $3 }
akind :: { Kind }
- : VARSYM { mkTypeKind {- ToDo: check that it's "*" -} }
- | OPAREN kind CPAREN { $2
---------------------------------------------------------------------------
+ : VARSYM { if $1 == SLIT("*") then
+ mkBoxedTypeKind
+ else if $1 == SLIT("**") then
+ mkTypeKind
+ else panic "ParseInterface: akind"
}
+ | OPAREN kind CPAREN { $2 }
+--------------------------------------------------------------------------
instances_part :: { [RdrNameInstDecl] }
| instd instdecls { $1 : $2 }
instd :: { RdrNameInstDecl }
-instd : INSTANCE type EQUAL var_name SEMI
- { InstDecl $2
+instd : src_loc INSTANCE type EQUAL var_name SEMI
+ { InstDecl $3
EmptyMonoBinds {- No bindings -}
[] {- No user pragmas -}
- (Just $4) {- Dfun id -}
- mkIfaceSrcLoc
---------------------------------------------------------------------------
+ (Just $5) {- Dfun id -}
+ $1
}
+--------------------------------------------------------------------------
id_info :: { [HsIdInfo RdrName] }
id_info : { [] }
id_info_item :: { HsIdInfo RdrName }
id_info_item : ARITY_PART arity_info { HsArity $2 }
- | STRICT_PART strict_info { HsStrictness $2 }
- | BOTTOM { HsStrictness mkBottomStrictnessInfo }
- | UNFOLD_PART core_expr { HsUnfold $2 }
+ | strict_info { HsStrictness $1 }
+ | BOTTOM { HsStrictness HsBottom }
+ | UNFOLD_PART core_expr { HsUnfold $1 $2 }
+ | SPECIALISE spec_tvs
+ atypes EQUAL core_expr { HsSpecialise $2 $3 $5 }
+
+
+spec_tvs :: { [HsTyVar RdrName] }
+spec_tvs : OBRACK tv_bndrs CBRACK { $2 }
+
arity_info :: { ArityInfo }
arity_info : INTEGER { exactArity (fromInteger $1) }
-strict_info :: { StrictnessInfo RdrName }
-strict_info : DEMAND any_var_name { mkStrictnessInfo $1 (Just $2) }
- | DEMAND { mkStrictnessInfo $1 Nothing }
+strict_info :: { HsStrictnessInfo RdrName }
+strict_info : STRICT_PART qvar_name OCURLY qdata_names CCURLY { HsStrictnessInfo $1 (Just ($2,$4)) }
+ | STRICT_PART qvar_name { HsStrictnessInfo $1 (Just ($2,[])) }
+ | STRICT_PART { HsStrictnessInfo $1 Nothing }
core_expr :: { UfExpr RdrName }
-core_expr : any_var_name { UfVar $1 }
+core_expr : qvar_name { UfVar $1 }
| qdata_name { UfVar $1 }
| core_lit { UfLit $1 }
| OPAREN core_expr CPAREN { $2 }
+ | qdata_name OCURLY data_args CCURLY { UfCon $1 $3 }
| core_expr ATSIGN atype { UfApp $1 (UfTyArg $3) }
| core_expr core_arg { UfApp $1 $2 }
- | LAM core_val_bndrs RARROW core_expr { foldr UfLam $4 $2 }
+ | LAM core_val_bndrs RARROW core_expr { foldr UfLam $4 $2 }
| BIGLAM core_tv_bndrs RARROW core_expr { foldr UfLam $4 $2 }
| CASE core_expr OF
| LETREC OCURLY rec_binds CCURLY
IN core_expr { UfLet (UfRec $3) $6 }
- | coerce atype core_expr { UfCoerce $1 $2 $3 }
-
| CCALL ccall_string
OBRACK atype atypes CBRACK core_args { let
(is_casm, may_gc) = $1
UfPrim (UfCCallOp $2 is_casm may_gc $5 $4)
$7
}
+ | INLINE_CALL core_expr { UfNote UfInlineCall $2 }
+ | COERCE atype core_expr { UfNote (UfCoerce $2) $3 }
+ | SCC core_expr { UfNote (UfSCC $1) $2 }
rec_binds :: { [(UfBinder RdrName, UfExpr RdrName)] }
: { [] }
| core_val_bndr EQUAL core_expr SEMI rec_binds { ($1,$3) : $5 }
-coerce :: { UfCoercion RdrName }
-coerce : COERCE_IN qdata_name { UfIn $2 }
- | COERCE_OUT qdata_name { UfOut $2 }
-
prim_alts :: { [(Literal,UfExpr RdrName)] }
: { [] }
| core_lit RARROW core_expr SEMI prim_alts { ($1,$3) : $5 }
-alg_alts :: { [(RdrName, [UfBinder RdrName], UfExpr RdrName)] }
+alg_alts :: { [(RdrName, [RdrName], UfExpr RdrName)] }
: { [] }
- | qdata_name core_val_bndrs RARROW
+ | qdata_name var_names RARROW
core_expr SEMI alg_alts { ($1,$2,$4) : $6 }
core_default :: { UfDefault RdrName }
: { UfNoDefault }
- | core_val_bndr RARROW core_expr SEMI { UfBindDefault $1 $3 }
+ | var_name RARROW core_expr SEMI { UfBindDefault $1 $3 }
core_arg :: { UfArg RdrName }
- : var_name { UfVarArg $1 }
- | qvar_name { UfVarArg $1 }
+ : qvar_name { UfVarArg $1 }
| qdata_name { UfVarArg $1 }
| core_lit { UfLitArg $1 }
: { [] }
| core_arg core_args { $1 : $2 }
+data_args :: { [UfArg RdrName] }
+ : { [] }
+ | ATSIGN atype data_args { UfTyArg $2 : $3 }
+ | core_arg data_args { $1 : $2 }
+
core_lit :: { Literal }
core_lit : INTEGER { MachInt $1 True }
| CHAR { MachChar $1 }
}
| ADDR_LIT INTEGER { MachAddr $2 }
- | LIT_LIT STRING { MachLitLit $2 (panic "ParseIface.y: ToDo: need PrimRep on LitLits in ifaces") }
+ | LIT_LIT prim_rep STRING { MachLitLit $3 (decodePrimRep $2) }
core_val_bndr :: { UfBinder RdrName }
core_val_bndr : var_name DCOLON atype { UfValBinder $1 $3 }
core_tv_bndr :: { UfBinder RdrName }
core_tv_bndr : tv_name DCOLON akind { UfTyBinder $1 $3 }
- | tv_name { UfTyBinder $1 mkTypeKind }
+ | tv_name { UfTyBinder $1 mkBoxedTypeKind }
core_tv_bndrs :: { [UfBinder RdrName] }
core_tv_bndrs : { [] }
: STRING { $1 }
| VARID { $1 }
| CONID { $1 }
+
+prim_rep :: { Char }
+ : VARID { head (_UNPK_ $1) }
+ | CONID { head (_UNPK_ $1) }
+
+-------------------------------------------------------------------
+
+src_loc :: { SrcLoc }
+src_loc : {% getSrcLocIf }
+
+checkVersion :: { () }
+ : {-empty-} {% checkVersion Nothing }
+ | INTEGER {% checkVersion (Just (fromInteger $1)) }
+
+-------------------------------------------------------------------
+
+-- Haskell code
+{
+
+data IfaceStuff = PIface ParsedIface
+ | PIdInfo [HsIdInfo RdrName]
+ | PType RdrNameHsType
+
+}
projects / ghc-hetmet.git / blobdiff