Columns now start at 1, as lines already did

[ghc-hetmet.git] / compiler / cmm / CmmLex.x

diff --git a/compiler/cmm/CmmLex.x b/compiler/cmm/CmmLex.x
index fb1179f..bfc18c1 100644 (file)
--- a/compiler/cmm/CmmLex.x
+++ b/compiler/cmm/CmmLex.x
@@ -11,6 +11,13 @@
 -----------------------------------------------------------------------------
 
 {
+{-# OPTIONS -Wwarn -w #-}
+-- The above -Wwarn supression flag is a temporary kludge.
+-- While working on this module you are encouraged to remove it and fix
+-- any warnings in the module. See
+--     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
+-- for details
+
 module CmmLex (
    CmmToken(..), cmmlex,
   ) where
@@ -29,24 +36,24 @@ import Util
 --import TRACE
 }
 
-$whitechar   = [\ \t\n\r\f\v\xa0]
+$whitechar   = [\ \t\n\r\f\v\xa0] -- \xa0 is Unicode no-break space
 $white_no_nl = $whitechar # \n
 
 $ascdigit  = 0-9
-$unidigit  = \x01
+$unidigit  = \x01 -- Trick Alex into handling Unicode. See alexGetChar.
 $digit     = [$ascdigit $unidigit]
 $octit    = 0-7
 $hexit     = [$digit A-F a-f]
 
-$unilarge  = \x03
+$unilarge  = \x03 -- Trick Alex into handling Unicode. See alexGetChar.
 $asclarge  = [A-Z \xc0-\xd6 \xd8-\xde]
 $large     = [$asclarge $unilarge]
 
-$unismall  = \x04
+$unismall  = \x04 -- Trick Alex into handling Unicode. See alexGetChar.
 $ascsmall  = [a-z \xdf-\xf6 \xf8-\xff]
 $small     = [$ascsmall $unismall \_]
 
-$namebegin = [$large $small \_ \. \$ \@]
+$namebegin = [$large $small \. \$ \@]
 $namechar  = [$namebegin $digit]
 
 @decimal     = $digit+
@@ -56,7 +63,7 @@ $namechar  = [$namebegin $digit]
 
 @floating_point = @decimal \. @decimal @exponent? | @decimal @exponent
 
-@escape      = \\ ([abfnrt\\\'\"\?] | x @hexadecimal | @octal)
+@escape      = \\ ([abfnrt\\\'\"\?] | x $hexit{1,2} | $octit{1,3})
 @strchar     = ($printable # [\"\\]) | @escape
 
 cmm :-
@@ -88,7 +95,8 @@ $white_no_nl+         ;
   "&&"                 { kw CmmT_BoolAnd }
   "||"                 { kw CmmT_BoolOr }
   
-  R@decimal            { global_regN VanillaReg }
+  P@decimal            { global_regN (\n -> VanillaReg n VGcPtr) }
+  R@decimal            { global_regN (\n -> VanillaReg n VNonGcPtr) }
   F@decimal            { global_regN FloatReg }
   D@decimal            { global_regN DoubleReg }
   L@decimal            { global_regN LongReg }
@@ -138,7 +146,10 @@ data CmmToken
   | CmmT_if
   | CmmT_jump
   | CmmT_foreign
+  | CmmT_never
   | CmmT_prim
+  | CmmT_return
+  | CmmT_returns
   | CmmT_import
   | CmmT_switch
   | CmmT_case
@@ -149,6 +160,7 @@ data CmmToken
   | CmmT_bits64
   | CmmT_float32
   | CmmT_float64
+  | CmmT_gcptr
   | CmmT_GlobalReg GlobalReg
   | CmmT_Name     FastString
   | CmmT_String           String
@@ -180,7 +192,7 @@ global_regN :: (Int -> GlobalReg) -> Action
 global_regN con span buf len 
   = return (L span (CmmT_GlobalReg (con (fromIntegral n))))
   where buf' = stepOn buf
-       n = parseInteger buf' (len-1) 10 octDecDigit
+       n = parseUnsignedInteger buf' (len-1) 10 octDecDigit
 
 global_reg :: GlobalReg -> Action
 global_reg r span buf len = return (L span (CmmT_GlobalReg r))
@@ -213,7 +225,10 @@ reservedWordsFM = listToUFM $
        ( "if",                 CmmT_if ),
        ( "jump",               CmmT_jump ),
        ( "foreign",            CmmT_foreign ),
+       ( "never",              CmmT_never ),
        ( "prim",               CmmT_prim ),
+       ( "return",             CmmT_return ),
+       ( "returns",            CmmT_returns ),
        ( "import",             CmmT_import ),
        ( "switch",             CmmT_switch ),
        ( "case",               CmmT_case ),
@@ -223,17 +238,25 @@ reservedWordsFM = listToUFM $
        ( "bits32",             CmmT_bits32 ),
        ( "bits64",             CmmT_bits64 ),
        ( "float32",            CmmT_float32 ),
-       ( "float64",            CmmT_float64 )
+       ( "float64",            CmmT_float64 ),
+-- New forms
+       ( "b8",                 CmmT_bits8 ),
+       ( "b16",                CmmT_bits16 ),
+       ( "b32",                CmmT_bits32 ),
+       ( "b64",                CmmT_bits64 ),
+       ( "f32",                CmmT_float32 ),
+       ( "f64",                CmmT_float64 ),
+       ( "gcptr",              CmmT_gcptr )
        ]
 
 tok_decimal span buf len 
-  = return (L span (CmmT_Int  $! parseInteger buf len 10 octDecDigit))
+  = return (L span (CmmT_Int  $! parseUnsignedInteger buf len 10 octDecDigit))
 
 tok_octal span buf len 
-  = return (L span (CmmT_Int  $! parseInteger (offsetBytes 1 buf) (len-1) 8 octDecDigit))
+  = return (L span (CmmT_Int  $! parseUnsignedInteger (offsetBytes 1 buf) (len-1) 8 octDecDigit))
 
 tok_hexadecimal span buf len 
-  = return (L span (CmmT_Int  $! parseInteger (offsetBytes 2 buf) (len-2) 16 hexDigit))
+  = return (L span (CmmT_Int  $! parseUnsignedInteger (offsetBytes 2 buf) (len-2) 16 hexDigit))
 
 tok_float str = CmmT_Float $! readRational str
 
@@ -245,8 +268,8 @@ tok_string str = CmmT_String (read str)
 
 setLine :: Int -> Action
 setLine code span buf len = do
-  let line = parseInteger buf len 10 octDecDigit
-  setSrcLoc (mkSrcLoc (srcSpanFile span) (fromIntegral line - 1) 0)
+  let line = parseUnsignedInteger buf len 10 octDecDigit
+  setSrcLoc (mkSrcLoc (srcSpanFile span) (fromIntegral line - 1) 1)
        -- subtract one: the line number refers to the *following* line
   -- trace ("setLine "  ++ show line) $ do
   popLexState