{-
-----------------------------------------------------------------------------
-$Id: Parser.y,v 1.46 2000/10/31 17:30:17 simonpj Exp $
+$Id: Parser.y,v 1.54 2001/02/20 15:36:55 simonpj Exp $
Haskell grammar.
-}
{
-module Parser ( parse ) where
+module Parser ( parseModule, parseExpr ) where
import HsSyn
import HsTypes ( mkHsTupCon )
-import HsPat ( InPat(..) )
import RdrHsSyn
import Lex
import ParseUtil
import RdrName
-import PrelNames
-import OccName ( UserFS, varName, ipName, tcName, dataName, tcClsName, tvName )
+import PrelNames ( mAIN_Name, unitTyCon_RDR, funTyCon_RDR, listTyCon_RDR,
+ tupleTyCon_RDR, unitCon_RDR, nilCon_RDR, tupleCon_RDR
+ )
+import OccName ( UserFS, varName, tcName, dataName, tcClsName, tvName )
import SrcLoc ( SrcLoc )
import Module
import CallConv
'then' { ITthen }
'type' { ITtype }
'where' { ITwhere }
- '_scc_' { ITscc }
+ '_scc_' { ITscc } -- ToDo: remove
'forall' { ITforall } -- GHC extension keywords
'foreign' { ITforeign }
'{-# INLINE' { ITinline_prag }
'{-# NOINLINE' { ITnoinline_prag }
'{-# RULES' { ITrules_prag }
+ '{-# SCC' { ITscc_prag }
'{-# DEPRECATED' { ITdeprecated_prag }
'#-}' { ITclose_prag }
%monad { P } { thenP } { returnP }
%lexer { lexer } { ITeof }
-%name parse
+%name parseModule module
+%name parseExpr exp
%tokentype { Token }
%%
(binds,sigs) = cvMonoBindsAndSigs cvClassOpSig (groupBindings $5)
in
returnP (RdrHsDecl (TyClD
- (mkClassDecl cs c ts $4 sigs binds $1))) }
+ (mkClassDecl cs c ts $4 sigs (Just binds) $1))) }
| srcloc 'instance' inst_type where
{ let (binds,sigs)
: ctype {% checkInstType $1 }
types0 :: { [RdrNameHsType] }
- : types { $1 }
+ : types { reverse $1 }
| {- empty -} { [] }
types :: { [RdrNameHsType] }
| '_casm_' CLITLIT aexps0 { HsCCall $2 $3 False True cbot }
| '_casm_GC_' CLITLIT aexps0 { HsCCall $2 $3 True True cbot }
- | '_scc_' STRING exp { if opt_SccProfilingOn
- then HsSCC $2 $3
- else HsPar $3 }
+ | scc_annot exp { if opt_SccProfilingOn
+ then HsSCC $1 $2
+ else HsPar $2 }
| fexp { $1 }
+scc_annot :: { FAST_STRING }
+ : '_scc_' STRING { $2 }
+ | '{-# SCC' STRING '#-}' { $2 }
+
ccallid :: { FAST_STRING }
: VARID { $1 }
| CONID { $1 }
: ipvar { HsIPVar $1 }
| var_or_con { $1 }
| literal { HsLit $1 }
- | INTEGER { HsOverLit (HsIntegral $1 fromInteger_RDR) }
- | RATIONAL { HsOverLit (HsFractional $1 fromRational_RDR) }
+ | INTEGER { HsOverLit (HsIntegral $1) }
+ | RATIONAL { HsOverLit (HsFractional $1) }
| '(' exp ')' { HsPar $2 }
| '(' exp ',' texps ')' { ExplicitTuple ($2 : reverse $4) Boxed}
| '(#' texps '#)' { ExplicitTuple (reverse $2) Unboxed }
| exp ',' exp '..' { ArithSeqIn (FromThen $1 $3) }
| exp '..' exp { ArithSeqIn (FromTo $1 $3) }
| exp ',' exp '..' exp { ArithSeqIn (FromThenTo $1 $3 $5) }
- | exp srcloc '|' quals { HsDo ListComp (reverse
- (ReturnStmt $1 : $4)) $2 }
+ | exp srcloc pquals {% let { body [qs] = qs;
+ body qss = [ParStmt (map reverse qss)] }
+ in
+ returnP ( HsDo ListComp
+ (reverse (ReturnStmt $1 : body $3))
+ $2
+ )
+ }
lexps :: { [RdrNameHsExpr] }
: lexps ',' exp { $3 : $1 }
-----------------------------------------------------------------------------
-- List Comprehensions
+pquals :: { [[RdrNameStmt]] }
+ : pquals '|' quals { $3 : $1 }
+ | '|' quals { [$2] }
+
quals :: { [RdrNameStmt] }
: quals ',' qual { $3 : $1 }
| qual { [$1] }
-- *after* we see the close paren.
ipvar :: { RdrName }
- : IPVARID { (mkUnqual ipName (tailFS $1)) }
+ : IPVARID { (mkUnqual varName (tailFS $1)) }
qcon :: { RdrName }
: qconid { $1 }