Changeset 7 for src/Lexer.hs

Show
Ignore:
Timestamp:
02/09/05 06:00:26 (4 years ago)
Author:
autrijus
svk:copy_cache_prev:
1041
Message:

* This be 6.0.2

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • src/Lexer.hs

    r5 r7  
    1919          , P.commentLine    = "#" 
    2020          , P.nestedComments = False 
    21           , P.identStart     = letter <|> oneOf "_:$@%&" 
    22           , P.identLetter    = alphaNum <|> oneOf "_:" 
     21          , P.identStart     = letter <|> char '_' 
     22          , P.identLetter    = alphaNum <|> oneOf "_" 
    2323          , P.reservedNames  = words $ 
    2424                "if then else do while skip" 
    … …  
    4646float      = P.float perl6Lexer 
    4747lexeme     = P.lexeme perl6Lexer 
     48identifier = P.identifier perl6Lexer 
     49braces     = P.braces perl6Lexer 
     50brackets   = P.brackets perl6Lexer 
    4851stringLiteral = choice 
    4952    [ P.stringLiteral  perl6Lexer 
    … …  
    5154    ] 
    5255 
    53 naturalOrFloat  = lexeme (natFloat) <?> "number" 
     56naturalOrRat  = do 
     57        b <- lexeme sign 
     58        n <- lexeme natRat 
     59        return $ if b 
     60            then n 
     61            else case n of 
     62                Left x -> Left $ -x 
     63                Right y -> Right $ -y 
     64    <?> "number" 
    5465    where 
    55     natFloat        = do{ char '0' 
    56                         ; zeroNumFloat 
    57                         } 
    58                       <|> decimalFloat 
     66    natRat = do 
     67            char '0' 
     68            zeroNumRat 
     69        <|> decimalRat 
    5970                       
    60     zeroNumFloat    =  do{ n <- hexadecimal <|> octal <|> binary 
    61                          ; return (Left n) 
    62                          } 
    63                     <|> decimalFloat 
    64                     <|> fractFloat 0 
    65                     <|> return (Left 0)                   
     71    zeroNumRat = do 
     72            n <- hexadecimal <|> octal <|> binary 
     73            return (Left n) 
     74        <|> decimalRat 
     75        <|> fractRat 0 
     76        <|> return (Left 0)                   
    6677                       
    67     decimalFloat    = do{ n <- decimal 
    68                         ; option (Left n)  
    69                                  (try $ fractFloat n) 
    70                         } 
     78    decimalRat = do 
     79        n <- decimal 
     80        option (Left n) (try $ fractRat n) 
    7181 
    72     fractFloat n    = do{ f <- fractExponent n 
    73                         ; return (Right f) 
    74                         } 
    75                          
    76     fractExponent n = do{ fract <- fraction 
    77                         ; expo  <- option 1.0 exponent' 
    78                         ; return ((fromInteger n + fract)*expo) 
    79                         } 
    80                     <|> 
    81                       do{ expo <- exponent' 
    82                         ; return ((fromInteger n)*expo) 
    83                         } 
     82    fractRat n = do 
     83            fract <- try fraction 
     84            expo  <- option (1%1) expo 
     85            return (Right $ ((n % 1) + fract) * expo) -- Right is Rat 
     86        <|> do 
     87            expo <- expo 
     88            if expo < 1 
     89                then return (Left  $ n * numerator expo) 
     90                else return (Right $ (n % 1) * expo) 
    8491 
    85     fraction        = do{ char '.' 
    86                         ; digits <- many digit <?> "fraction" 
    87                         ; return (foldr op 0.0 digits) 
    88                         } 
    89                       <?> "fraction" 
    90                     where 
    91                       op d f    = (f + fromIntegral (digitToInt d))/10.0 
    92                          
    93     exponent'       = do{ oneOf "eE" 
    94                         ; f <- sign 
    95                         ; e <- decimal <?> "exponent" 
    96                         ; return (power (f e)) 
    97                         } 
    98                       <?> "exponent" 
    99                     where 
    100                        power e  | e < 0      = 1.0/power(-e) 
    101                                 | otherwise  = fromInteger (10^e) 
     92    fraction = do 
     93            char '.' 
     94            try $ do { char '.'; unexpected "dotdot" } <|> return () 
     95            digits <- many digit <?> "fraction" 
     96            return (digitsToRat digits) 
     97        <?> "fraction" 
     98        where 
     99        digitsToRat d = digitsNum d % (10 ^ length d) 
     100        digitsNum d = foldl (\x y -> x * 10 + (toInteger $ digitToInt y)) 0 d  
    102101 
     102    expo :: GenParser Char st Rational 
     103    expo = do 
     104            oneOf "eE" 
     105            f <- sign 
     106            e <- decimal <?> "exponent" 
     107            return (power (if f then e else -e)) 
     108        <?> "exponent" 
     109        where 
     110        power e | e < 0      = 1 % (10^e) 
     111                | otherwise  = (10^e) % 1 
    103112 
    104     -- integers and naturals 
    105     int             = do{ f <- lexeme sign 
    106                         ; n <- nat 
    107                         ; return (f n) 
    108                         } 
    109                          
    110113    -- sign            :: CharParser st (Integer -> Integer) 
    111     sign            =   (char '-' >> return negate)  
    112                     <|> (char '+' >> return id)      
    113                     <|> return id 
     114    sign            =   (char '-' >> return False)  
     115                    <|> (char '+' >> return True) 
     116                    <|> return True 
    114117 
    115118    nat             = zeroNumber <|> decimal