1 {- Notes about the syntax of interface files -*-haskell-*-
2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5 interface "edison" M 4 6 2 ! 406 Module M, version 4, from package 'edison',
6 Fixities version 6, rules version 2
7 Interface syntax version 406
8 ! means M contains orphans
12 import Foo ; To compile M I used nothing from Foo, but it's
13 below me in the hierarchy
15 import Foo ! @ ; Ditto, but the ! means that Foo contains orphans
16 and the @ means that Foo is a boot interface
18 import Foo :: 3 ; To compile M I used everything from Foo, which has
21 import Foo :: 3 2 6 a 1 b 3 c 7 ; To compile M I used Foo. It had
25 and some specific things besides.
31 module ParseIface ( parseIface, parseType, parseRules, parseIdInfo ) where
33 #include "HsVersions.h"
35 import HsSyn -- quite a bit of stuff
36 import RdrHsSyn -- oodles of synonyms
37 import HsTypes ( mkHsForAllTy, mkHsTupCon )
39 import Literal ( Literal(..), mkMachInt, mkMachInt64, mkMachWord, mkMachWord64 )
40 import BasicTypes ( Fixity(..), FixityDirection(..), StrictnessMark(..),
41 NewOrData(..), Version, initialVersion, Boxity(..),
42 Activation(..), IPName(..)
44 import CostCentre ( CostCentre(..), IsCafCC(..), IsDupdCC(..) )
45 import Type ( Kind, mkArrowKind, liftedTypeKind, openTypeKind, usageTypeKind )
46 import ForeignCall ( ForeignCall(..), CCallConv(..), CCallSpec(..), CCallTarget(..) )
49 import RnMonad ( ParsedIface(..), ExportItem, IfaceDeprecs )
50 import HscTypes ( WhetherHasOrphans, IsBootInterface, GenAvailInfo(..),
51 ImportVersion, WhatsImported(..),
54 import RdrName ( RdrName, mkRdrUnqual, mkIfaceOrig )
55 import Name ( OccName )
56 import OccName ( mkSysOccFS,
57 tcName, varName, dataName, clsName, tvName,
60 import Module ( ModuleName, PackageName, mkSysModuleNameFS )
61 import SrcLoc ( SrcLoc )
62 import CmdLineOpts ( opt_InPackage, opt_IgnoreIfacePragmas )
64 import Class ( DefMeth (..) )
67 import FastString ( tailFS )
70 %name parseIface iface
72 %name parseIdInfo id_info
73 %name parseRules rules_and_deprecs
76 %monad { P }{ thenP }{ returnP }
77 %lexer { lexer } { ITeof }
81 'case' { ITcase } -- Haskell keywords
84 'default' { ITdefault }
85 'deriving' { ITderiving }
95 'instance' { ITinstance }
98 'newtype' { ITnewtype }
100 'qualified' { ITqualified }
105 'forall' { ITforall } -- GHC extension keywords
106 'foreign' { ITforeign }
107 'export' { ITexport }
109 'dynamic' { ITdynamic }
110 'unsafe' { ITunsafe }
112 'stdcall' { ITstdcallconv }
113 'ccall' { ITccallconv }
115 '__interface' { ITinterface } -- interface keywords
116 '__export' { IT__export }
117 '__depends' { ITdepends }
118 '__forall' { IT__forall }
119 '__letrec' { ITletrec }
120 '__coerce' { ITcoerce }
121 '__inline_me' { ITinlineMe }
122 '__inline_call'{ ITinlineCall }
123 '__DEFAULT' { ITdefaultbranch }
125 '__integer' { ITinteger_lit }
126 '__float' { ITfloat_lit }
127 '__word' { ITword_lit }
128 '__int64' { ITint64_lit }
129 '__word64' { ITword64_lit }
130 '__rational' { ITrational_lit }
131 '__addr' { ITaddr_lit }
132 '__label' { ITlabel_lit }
133 '__litlit' { ITlit_lit }
134 '__string' { ITstring_lit }
135 '__ccall' { ITccall $$ }
137 '__sccC' { ITsccAllCafs }
142 '__P' { ITspecialise }
145 '__S' { ITstrict $$ }
148 '__D' { ITdeprecated }
150 '..' { ITdotdot } -- reserved symbols
163 '{' { ITocurly } -- special symbols
165 '{|' { ITocurlybar } -- special symbols
166 '|}' { ITccurlybar } -- special symbols
179 VARID { ITvarid $$ } -- identifiers
181 VARSYM { ITvarsym $$ }
182 CONSYM { ITconsym $$ }
183 QVARID { ITqvarid $$ }
184 QCONID { ITqconid $$ }
185 QVARSYM { ITqvarsym $$ }
186 QCONSYM { ITqconsym $$ }
188 IPDUPVARID { ITdupipvarid $$ } -- GHC extension
189 IPSPLITVARID { ITsplitipvarid $$ } -- GHC extension
191 PRAGMA { ITpragma $$ }
194 STRING { ITstring $$ }
195 INTEGER { ITinteger $$ }
196 RATIONAL { ITrational $$ }
197 CLITLIT { ITlitlit $$ }
199 UNKNOWN { ITunknown $$ }
202 iface :: { ParsedIface }
203 iface : '__interface' package mod_name
205 orphans checkVersion 'where'
211 rules_and_deprecs_part
212 { let (rules,deprecs) = $14 () in
214 pi_mod = $3, -- Module name
215 pi_pkg = $2, -- Package name
216 pi_vers = $4, -- Module version
218 pi_exports = (fst $5, $9), -- Exports
219 pi_usages = $10, -- Usages
220 pi_fixity = $11, -- Fixies
221 pi_insts = $12, -- Local instances
222 pi_decls = $13, -- Decls
223 pi_rules = (snd $5,rules), -- Rules
224 pi_deprecs = deprecs -- Deprecations
227 -- Versions for exports and rules (optional)
228 sub_versions :: { (Version,Version) }
229 : '[' version version ']' { ($2,$3) }
230 | {- empty -} { (initialVersion, initialVersion) }
232 --------------------------------------------------------------------------
234 import_part :: { [ImportVersion OccName] }
236 | import_decl import_part { $1 : $2 }
238 import_decl :: { ImportVersion OccName }
239 import_decl : 'import' mod_name orphans is_boot whats_imported ';'
240 { ({-mkSysModuleNameFS-} $2, $3, $4, $5) }
242 orphans :: { WhetherHasOrphans }
246 is_boot :: { IsBootInterface }
250 whats_imported :: { WhatsImported OccName }
251 whats_imported : { NothingAtAll }
252 | '::' version { Everything $2 }
253 | '::' version version version name_version_pairs { Specifically $2 (Just $3) $5 $4 }
254 | '::' version version name_version_pairs { Specifically $2 Nothing $4 $3 }
256 name_version_pairs :: { [(OccName, Version)] }
257 name_version_pairs : { [] }
258 | name_version_pair name_version_pairs { $1 : $2 }
260 name_version_pair :: { (OccName, Version) }
261 name_version_pair : var_occ version { ($1, $2) }
262 | tc_occ version { ($1, $2) }
265 --------------------------------------------------------------------------
267 exports_part :: { [ExportItem] }
268 exports_part : { [] }
269 | '__export' mod_name entities ';'
270 exports_part { ({-mkSysModuleNameFS-} $2, $3) : $5 }
272 entities :: { [RdrAvailInfo] }
274 | entity entities { $1 : $2 }
276 entity :: { RdrAvailInfo }
277 entity : var_occ { Avail $1 }
278 | tc_occ { AvailTC $1 [$1] }
279 | tc_occ '|' stuff_inside { AvailTC $1 $3 }
280 | tc_occ stuff_inside { AvailTC $1 ($1:$2) }
281 -- Note that the "main name" comes at the beginning
283 stuff_inside :: { [OccName] }
284 stuff_inside : '{' val_occs '}' { $2 }
286 val_occ :: { OccName }
290 val_occs :: { [OccName] }
292 | val_occ val_occs { $1 : $2 }
295 --------------------------------------------------------------------------
297 fix_decl_part :: { [RdrNameFixitySig] }
298 fix_decl_part : {- empty -} { [] }
299 | fix_decls ';' { $1 }
301 fix_decls :: { [RdrNameFixitySig] }
303 | fix_decl fix_decls { $1 : $2 }
305 fix_decl :: { RdrNameFixitySig }
306 fix_decl : src_loc fixity prec var_or_data_name { FixitySig $4 (Fixity $3 $2) $1 }
308 fixity :: { FixityDirection }
309 fixity : 'infixl' { InfixL }
310 | 'infixr' { InfixR }
314 prec : INTEGER { fromInteger $1 }
316 -----------------------------------------------------------------------------
318 csigs :: { [RdrNameSig] }
320 | 'where' '{' csigs1 '}' { $3 }
322 csigs1 :: { [RdrNameSig] }
324 | csig ';' csigs1 { $1 : $3 }
326 csig :: { RdrNameSig }
327 csig : src_loc qvar_name '::' type { ClassOpSig $2 NoDefMeth $4 $1 }
328 | src_loc qvar_name ';' '::' type { ClassOpSig $2 GenDefMeth $5 $1 }
329 | src_loc qvar_name '=' '::' type { mkClassOpSigDM $2 $5 $1 }
331 --------------------------------------------------------------------------
333 instance_decl_part :: { [RdrNameInstDecl] }
334 instance_decl_part : {- empty -} { [] }
335 | instance_decl_part inst_decl { $2 : $1 }
337 inst_decl :: { RdrNameInstDecl }
338 inst_decl : src_loc 'instance' type '=' qvar_name ';'
340 EmptyMonoBinds {- No bindings -}
341 [] {- No user pragmas -}
342 (Just $5) {- Dfun id -}
346 --------------------------------------------------------------------------
348 decls_part :: { [(Version, RdrNameTyClDecl)] }
351 | opt_version decl ';' decls_part { ($1,$2):$4 }
353 decl :: { RdrNameTyClDecl }
354 decl : src_loc qvar_name '::' type maybe_idinfo
355 { IfaceSig $2 $4 ($5 $2) $1 }
356 | src_loc 'type' qtc_name tv_bndrs '=' type
357 { TySynonym $3 $4 $6 $1 }
358 | src_loc 'foreign' 'type' qtc_name
359 { ForeignType $4 Nothing DNType $1 }
360 | src_loc 'data' opt_decl_context qtc_name tv_bndrs constrs
361 { mkTyData DataType $3 $4 $5 $6 (length $6) Nothing $1 }
362 | src_loc 'newtype' opt_decl_context qtc_name tv_bndrs newtype_constr
363 { mkTyData NewType $3 $4 $5 $6 1 Nothing $1 }
364 | src_loc 'class' opt_decl_context qtc_name tv_bndrs fds csigs
365 { mkClassDecl $3 $4 $5 $6 $7 Nothing $1 }
367 maybe_idinfo :: { RdrName -> [HsIdInfo RdrName] }
368 maybe_idinfo : {- empty -} { \_ -> [] }
369 | pragma { \x -> if opt_IgnoreIfacePragmas then []
371 Just (POk _ id_info) -> id_info
372 Just (PFailed err) -> pprPanic "IdInfo parse failed"
376 If a signature decl is being loaded, and opt_IgnoreIfacePragmas is on,
377 we toss away unfolding information.
379 Also, if the signature is loaded from a module we're importing from source,
380 we do the same. This is to avoid situations when compiling a pair of mutually
381 recursive modules, peering at unfolding info in the interface file of the other,
382 e.g., you compile A, it looks at B's interface file and may as a result change
383 its interface file. Hence, B is recompiled, maybe changing its interface file,
384 which will the unfolding info used in A to become invalid. Simple way out is to
385 just ignore unfolding info.
387 [Jan 99: I junked the second test above. If we're importing from an hi-boot
388 file there isn't going to *be* any pragma info. The above comment
389 dates from a time where we picked up a .hi file first if it existed.]
392 pragma :: { Maybe (ParseResult [HsIdInfo RdrName]) }
393 pragma : src_loc PRAGMA { let exts = ExtFlags {glasgowExtsEF = True,
396 Just (parseIdInfo $2 (mkPState $1 exts))
399 -----------------------------------------------------------------------------
401 -- This production is lifted so that it doesn't get eagerly parsed when we
402 -- use happy --strict.
403 rules_and_deprecs_part :: { () -> ([RdrNameRuleDecl], IfaceDeprecs) }
404 rules_and_deprecs_part
405 : {- empty -} { \_ -> ([], Nothing) }
406 | src_loc PRAGMA { \_ -> let exts = ExtFlags {glasgowExtsEF = True,
408 in case parseRules $2 (mkPState $1 exts) of
410 PFailed err -> pprPanic "Rules/Deprecations parse failed" err
413 rules_and_deprecs :: { ([RdrNameRuleDecl], IfaceDeprecs) }
414 rules_and_deprecs : rule_prag deprec_prag { ($1, $2) }
417 -----------------------------------------------------------------------------
419 rule_prag :: { [RdrNameRuleDecl] }
420 rule_prag : {- empty -} { [] }
423 rules :: { [RdrNameRuleDecl] }
425 | rule ';' rules { $1:$3 }
427 rule :: { RdrNameRuleDecl }
428 rule : src_loc STRING activation rule_forall qvar_name
429 core_args '=' core_expr { IfaceRule $2 $3 $4 $5 $6 $8 $1 }
431 activation :: { Activation }
432 activation : {- empty -} { AlwaysActive }
433 | '[' INTEGER ']' { ActiveAfter (fromInteger $2) }
434 | '[' '~' INTEGER ']' { ActiveBefore (fromInteger $3) }
436 rule_forall :: { [UfBinder RdrName] }
437 rule_forall : '__forall' '{' core_bndrs '}' { $3 }
439 -----------------------------------------------------------------------------
441 deprec_prag :: { IfaceDeprecs }
442 deprec_prag : {- empty -} { Nothing }
443 | '__D' deprecs { Just $2 }
445 deprecs :: { Either DeprecTxt [(RdrName,DeprecTxt)] }
446 deprecs : STRING { Left $1 }
447 | deprec_list { Right $1 }
449 deprec_list :: { [(RdrName,DeprecTxt)] }
450 deprec_list : deprec { [$1] }
451 | deprec ';' deprec_list { $1 : $3 }
453 deprec :: { (RdrName,DeprecTxt) }
454 deprec : deprec_name STRING { ($1, $2) }
456 deprec_name :: { RdrName }
460 -----------------------------------------------------------------------------
462 version :: { Version }
463 version : INTEGER { fromInteger $1 }
465 opt_version :: { Version }
466 opt_version : version { $1 }
467 | {- empty -} { initialVersion }
469 opt_decl_context :: { RdrNameContext }
470 opt_decl_context : { [] }
471 | context '=>' { $1 }
473 ----------------------------------------------------------------------------
475 constrs :: { [RdrNameConDecl] {- empty for handwritten abstract -} }
477 | '=' constrs1 { $2 }
479 constrs1 :: { [RdrNameConDecl] }
480 constrs1 : constr { [$1] }
481 | constr '|' constrs1 { $1 : $3 }
483 constr :: { RdrNameConDecl }
484 constr : src_loc ex_stuff qdata_name batypes { mk_con_decl $3 $2 (VanillaCon $4) $1 }
485 | src_loc ex_stuff qdata_name '{' fields1 '}' { mk_con_decl $3 $2 (RecCon $5) $1 }
486 -- We use "data_fs" so as to include ()
488 newtype_constr :: { [RdrNameConDecl] {- Not allowed to be empty -} }
489 newtype_constr : src_loc '=' ex_stuff qdata_name atype { [mk_con_decl $4 $3 (VanillaCon [unbangedType $5]) $1] }
490 | src_loc '=' ex_stuff qdata_name '{' qvar_name '::' atype '}'
491 { [mk_con_decl $4 $3 (RecCon [([$6], unbangedType $8)]) $1] }
493 ex_stuff :: { ([HsTyVarBndr RdrName], RdrNameContext) }
494 ex_stuff : { ([],[]) }
495 | '__forall' tv_bndrs opt_context '=>' { ($2,$3) }
497 batypes :: { [RdrNameBangType] }
499 | batype batypes { $1 : $2 }
501 batype :: { RdrNameBangType }
502 batype : tatype { unbangedType $1 }
503 | '!' tatype { BangType MarkedStrict $2 }
504 | '!' '!' tatype { BangType MarkedUnboxed $3 }
506 fields1 :: { [([RdrName], RdrNameBangType)] }
507 fields1 : field { [$1] }
508 | field ',' fields1 { $1 : $3 }
510 field :: { ([RdrName], RdrNameBangType) }
511 field : qvar_names1 '::' ttype { ($1, unbangedType $3) }
512 | qvar_names1 '::' '!' ttype { ($1, BangType MarkedStrict $4) }
513 | qvar_names1 '::' '!' '!' ttype { ($1, BangType MarkedUnboxed $5) }
515 --------------------------------------------------------------------------
517 type :: { RdrNameHsType }
518 type : '__forall' tv_bndrs
519 opt_context '=>' type { mkHsForAllTy (Just $2) $3 $5 }
520 | btype '->' type { HsFunTy $1 $3 }
523 opt_context :: { RdrNameContext }
527 context :: { RdrNameContext }
528 context : '(' context_list1 ')' { $2 }
529 | '{' context_list1 '}' { $2 } -- Backward compatibility
531 context_list1 :: { RdrNameContext }
532 context_list1 : class { [$1] }
533 | class ',' context_list1 { $1 : $3 }
535 class :: { HsPred RdrName }
536 class : qcls_name atypes { (HsClassP $1 $2) }
537 | ipvar_name '::' type { (HsIParam $1 $3) }
539 types0 :: { [RdrNameHsType] {- Zero or more -} }
540 types0 : {- empty -} { [ ] }
544 types2 :: { [RdrNameHsType] {- Two or more -} }
545 types2 : type ',' type { [$1,$3] }
546 | type ',' types2 { $1 : $3 }
548 btype :: { RdrNameHsType }
550 | btype atype { HsAppTy $1 $2 }
552 atype :: { RdrNameHsType }
553 atype : qtc_name { HsTyVar $1 }
554 | tv_name { HsTyVar $1 }
557 | '(' ')' { HsTupleTy (mkHsTupCon tcName Boxed []) [] }
558 | '(' types2 ')' { HsTupleTy (mkHsTupCon tcName Boxed $2) $2 }
559 | '(#' types0 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
560 | '[' type ']' { HsListTy $2 }
561 | '[:' type ':]' { HsPArrTy $2 }
562 | '{' qcls_name atypes '}' { mkHsDictTy $2 $3 }
563 | '{' ipvar_name '::' type '}' { mkHsIParamTy $2 $4 }
564 | '(' type ')' { $2 }
566 atypes :: { [RdrNameHsType] {- Zero or more -} }
568 | atype atypes { $1 : $2 }
569 --------------------------------------------------------------------------
571 -- versions of type/btype/atype that cant begin with '!' (or '.')
572 -- for use where the kind is definitely known NOT to be '$'
574 ttype :: { RdrNameHsType }
575 ttype : '__forall' tv_bndrs
576 opt_context '=>' type { mkHsForAllTy (Just $2) $3 $5 }
577 | tbtype '->' type { HsFunTy $1 $3 }
580 tbtype :: { RdrNameHsType }
581 tbtype : tatype { $1 }
582 | tbtype atype { HsAppTy $1 $2 }
584 tatype :: { RdrNameHsType }
585 tatype : qtc_name { HsTyVar $1 }
586 | tv_name { HsTyVar $1 }
587 | '(' ')' { HsTupleTy (mkHsTupCon tcName Boxed []) [] }
588 | '(' types2 ')' { HsTupleTy (mkHsTupCon tcName Boxed $2) $2 }
589 | '(#' types0 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
590 | '[' type ']' { HsListTy $2 }
591 | '[:' type ':]' { HsPArrTy $2 }
592 | '{' qcls_name atypes '}' { mkHsDictTy $2 $3 }
593 | '{' ipvar_name '::' type '}' { mkHsIParamTy $2 $4 }
594 | '(' type ')' { $2 }
595 ---------------------------------------------------------------------
597 package :: { PackageName }
599 | {- empty -} { opt_InPackage }
600 -- Useful for .hi-boot files,
601 -- which can omit the package Id
602 -- Module loops are always within a package
604 mod_name :: { ModuleName }
605 : CONID { mkSysModuleNameFS $1 }
608 ---------------------------------------------------
609 var_fs :: { EncodedFS }
611 | 'as' { SLIT("as") }
612 | 'qualified' { SLIT("qualified") }
613 | 'hiding' { SLIT("hiding") }
614 | 'forall' { SLIT("forall") }
615 | 'foreign' { SLIT("foreign") }
616 | 'export' { SLIT("export") }
617 | 'label' { SLIT("label") }
618 | 'dynamic' { SLIT("dynamic") }
619 | 'unsafe' { SLIT("unsafe") }
620 | 'with' { SLIT("with") }
621 | 'ccall' { SLIT("ccall") }
622 | 'stdcall' { SLIT("stdcall") }
624 var_occ :: { OccName }
625 : var_fs { mkSysOccFS varName $1 }
627 var_name :: { RdrName }
628 var_name : var_occ { mkRdrUnqual $1 }
630 qvar_name :: { RdrName }
631 qvar_name : var_name { $1 }
632 | QVARID { mkIfaceOrig varName $1 }
634 ipvar_name :: { IPName RdrName }
635 : IPDUPVARID { Dupable (mkRdrUnqual (mkSysOccFS varName $1)) }
636 | IPSPLITVARID { Linear (mkRdrUnqual (mkSysOccFS varName $1)) }
638 qvar_names1 :: { [RdrName] }
639 qvar_names1 : qvar_name { [$1] }
640 | qvar_name qvar_names1 { $1 : $2 }
642 var_names :: { [RdrName] }
644 | var_name var_names { $1 : $2 }
646 var_names1 :: { [RdrName] }
647 var_names1 : var_name var_names { $1 : $2 }
649 ---------------------------------------------------
651 data_occ :: { OccName }
652 : CONID { mkSysOccFS dataName $1 }
654 qdata_name :: { RdrName }
655 : data_occ { mkRdrUnqual $1 }
656 | QCONID { mkIfaceOrig dataName $1 }
658 var_or_data_name :: { RdrName }
662 ---------------------------------------------------
663 tc_occ :: { OccName }
664 : CONID { mkSysOccFS tcName $1 }
666 qtc_name :: { RdrName }
667 : tc_occ { mkRdrUnqual $1 }
668 | QCONID { mkIfaceOrig tcName $1 }
670 ---------------------------------------------------
671 qcls_name :: { RdrName }
672 : CONID { mkRdrUnqual (mkSysOccFS clsName $1) }
673 | QCONID { mkIfaceOrig clsName $1 }
675 ---------------------------------------------------
676 tv_name :: { RdrName }
677 : var_fs { mkRdrUnqual (mkSysOccFS tvName $1) }
679 tv_bndr :: { HsTyVarBndr RdrName }
680 : tv_name '::' akind { IfaceTyVar $1 $3 }
681 | tv_name { IfaceTyVar $1 liftedTypeKind }
683 tv_bndrs :: { [HsTyVarBndr RdrName] }
685 | '[' tv_bndrs1 ']' { $2 } -- Backward compatibility
687 tv_bndrs1 :: { [HsTyVarBndr RdrName] }
689 | tv_bndr tv_bndrs1 { $1 : $2 }
691 ---------------------------------------------------
692 fds :: { [([RdrName], [RdrName])] }
694 | '|' fds1 { reverse $2 }
696 fds1 :: { [([RdrName], [RdrName])] }
697 : fds1 ',' fd { $3 : $1 }
700 fd :: { ([RdrName], [RdrName]) }
701 : varids0 '->' varids0 { (reverse $1, reverse $3) }
703 varids0 :: { [RdrName] }
705 | varids0 tv_name { $2 : $1 }
707 ---------------------------------------------------
710 | akind '->' kind { mkArrowKind $1 $3 }
713 : VARSYM { if $1 == SLIT("*") then
715 else if $1 == SLIT("?") then
717 else if $1 == SLIT("\36") then
718 usageTypeKind -- dollar
719 else panic "ParseInterface: akind"
721 | '(' kind ')' { $2 }
723 --------------------------------------------------------------------------
725 id_info :: { [HsIdInfo RdrName] }
726 : id_info_item { [$1] }
727 | id_info_item id_info { $1 : $2 }
729 id_info_item :: { HsIdInfo RdrName }
730 : '__A' INTEGER { HsArity (fromInteger $2) }
731 | '__U' activation core_expr { HsUnfold $2 $3 }
732 | '__S' { HsStrictness $1 }
733 | '__C' { HsNoCafRefs }
734 | '__P' qvar_name INTEGER { HsWorker $2 (fromInteger $3) }
736 -------------------------------------------------------
737 core_expr :: { UfExpr RdrName }
738 core_expr : '\\' core_bndrs '->' core_expr { foldr UfLam $4 $2 }
739 | 'case' core_expr 'of' var_name
740 '{' core_alts '}' { UfCase $2 $4 $6 }
742 | 'let' '{' core_val_bndr '=' core_expr
743 '}' 'in' core_expr { UfLet (UfNonRec $3 $5) $8 }
744 | '__letrec' '{' rec_binds '}'
745 'in' core_expr { UfLet (UfRec $3) $6 }
747 | '__litlit' STRING atype { UfLitLit $2 $3 }
751 fexpr :: { UfExpr RdrName }
752 fexpr : fexpr core_arg { UfApp $1 $2 }
753 | scc core_aexpr { UfNote (UfSCC $1) $2 }
754 | '__inline_me' core_aexpr { UfNote UfInlineMe $2 }
755 | '__inline_call' core_aexpr { UfNote UfInlineCall $2 }
756 | '__coerce' atype core_aexpr { UfNote (UfCoerce $2) $3 }
759 core_arg :: { UfExpr RdrName }
760 : '@' atype { UfType $2 }
763 core_args :: { [UfExpr RdrName] }
765 | core_arg core_args { $1 : $2 }
767 core_aexpr :: { UfExpr RdrName } -- Atomic expressions
768 core_aexpr : qvar_name { UfVar $1 }
769 | qdata_name { UfVar $1 }
771 | core_lit { UfLit $1 }
772 | '(' core_expr ')' { $2 }
774 | '(' ')' { UfTuple (mkHsTupCon dataName Boxed []) [] }
775 | '(' comma_exprs2 ')' { UfTuple (mkHsTupCon dataName Boxed $2) $2 }
776 | '(#' comma_exprs0 '#)' { UfTuple (mkHsTupCon dataName Unboxed $2) $2 }
778 | '{' '__ccall' ccall_string type '}'
780 (is_dyn, is_casm, may_gc) = $2
782 target | is_dyn = DynamicTarget
783 | is_casm = CasmTarget $3
784 | otherwise = StaticTarget $3
786 ccall = CCallSpec target CCallConv may_gc
788 UfFCall (CCall ccall) $4
792 comma_exprs0 :: { [UfExpr RdrName] } -- Zero or more
793 comma_exprs0 : {- empty -} { [ ] }
794 | core_expr { [ $1 ] }
795 | comma_exprs2 { $1 }
797 comma_exprs2 :: { [UfExpr RdrName] } -- Two or more
798 comma_exprs2 : core_expr ',' core_expr { [$1,$3] }
799 | core_expr ',' comma_exprs2 { $1 : $3 }
801 rec_binds :: { [(UfBinder RdrName, UfExpr RdrName)] }
803 | core_val_bndr '=' core_expr ';' rec_binds { ($1,$3) : $5 }
805 core_alts :: { [UfAlt RdrName] }
807 | core_alt ';' core_alts { $1 : $3 }
809 core_alt :: { UfAlt RdrName }
810 core_alt : core_pat '->' core_expr { (fst $1, snd $1, $3) }
812 core_pat :: { (UfConAlt RdrName, [RdrName]) }
813 core_pat : core_lit { (UfLitAlt $1, []) }
814 | '__litlit' STRING atype { (UfLitLitAlt $2 $3, []) }
815 | qdata_name core_pat_names { (UfDataAlt $1, $2) }
816 | '(' ')' { (UfTupleAlt (mkHsTupCon dataName Boxed []), []) }
817 | '(' comma_var_names1 ')' { (UfTupleAlt (mkHsTupCon dataName Boxed $2), $2) }
818 | '(#' comma_var_names1 '#)' { (UfTupleAlt (mkHsTupCon dataName Unboxed $2), $2) }
819 | '__DEFAULT' { (UfDefault, []) }
820 | '(' core_pat ')' { $2 }
822 core_pat_names :: { [RdrName] }
823 core_pat_names : { [] }
824 | core_pat_name core_pat_names { $1 : $2 }
826 -- Tyvar names and variable names live in different name spaces
827 -- so they need to be signalled separately. But we don't record
828 -- types or kinds in a pattern; we work that out from the type
829 -- of the case scrutinee
830 core_pat_name :: { RdrName }
831 core_pat_name : var_name { $1 }
834 comma_var_names1 :: { [RdrName] } -- One or more
835 comma_var_names1 : var_name { [$1] }
836 | var_name ',' comma_var_names1 { $1 : $3 }
838 core_lit :: { Literal }
839 core_lit : integer { mkMachInt $1 }
840 | CHAR { MachChar $1 }
841 | STRING { MachStr $1 }
842 | rational { MachDouble $1 }
843 | '__word' integer { mkMachWord $2 }
844 | '__word64' integer { mkMachWord64 $2 }
845 | '__int64' integer { mkMachInt64 $2 }
846 | '__float' rational { MachFloat $2 }
847 | '__addr' integer { MachAddr $2 }
848 | '__label' STRING { MachLabel $2 }
850 integer :: { Integer }
852 | '-' INTEGER { (-$2) }
854 rational :: { Rational }
856 | '-' RATIONAL { (-$2) }
858 core_bndr :: { UfBinder RdrName }
859 core_bndr : core_val_bndr { $1 }
860 | core_tv_bndr { $1 }
862 core_bndrs :: { [UfBinder RdrName] }
864 | core_bndr core_bndrs { $1 : $2 }
866 core_val_bndr :: { UfBinder RdrName }
867 core_val_bndr : var_name '::' atype { UfValBinder $1 $3 }
869 core_tv_bndr :: { UfBinder RdrName }
870 core_tv_bndr : '@' tv_name '::' akind { UfTyBinder $2 $4 }
871 | '@' tv_name { UfTyBinder $2 liftedTypeKind }
873 ccall_string :: { FAST_STRING }
879 ------------------------------------------------------------------------
880 scc :: { CostCentre }
881 : '__sccC' '{' mod_name '}' { AllCafsCC $3 }
882 | '__scc' '{' cc_name mod_name cc_dup cc_caf '}'
883 { NormalCC { cc_name = $3, cc_mod = $4,
884 cc_is_dupd = $5, cc_is_caf = $6 } }
886 cc_name :: { EncodedFS }
890 cc_dup :: { IsDupdCC }
891 cc_dup : { OriginalCC }
894 cc_caf :: { IsCafCC }
898 -------------------------------------------------------------------
900 src_loc :: { SrcLoc }
901 src_loc : {% getSrcLocP }
903 -- Check the project version: this makes sure
904 -- that the project version (e.g. 407) in the interface
905 -- file is the same as that for the compiler that's reading it
906 checkVersion :: { () }
907 : {-empty-} {% checkVersion Nothing }
908 | INTEGER {% checkVersion (Just (fromInteger $1)) }
910 -------------------------------------------------------------------
915 happyError buf PState{ loc = loc } = PFailed (ifaceParseErr buf loc)
917 mk_con_decl name (ex_tvs, ex_ctxt) details loc = mkConDecl name ex_tvs ex_ctxt details loc