[Haskell-cafe] Overlaping Parsec rules

Hauschild, Klaus (EXT) klaus.hauschild.ext at siemens.com
Tue Mar 8 12:30:02 CET 2011


Hi Christian,

my version of parseList works currently strange.
The input "{2\n2}" will be parsed fine, but something like "{ }" or so fails with 'expecting space or "}"'.

The redefinition of space is not necessary, it was copied from another tutorial code. How I write a version of parseGml that get gml token separated by any white space (space, tab, newline)?

Thanks

-----Ursprüngliche Nachricht-----
Von: Christian Maeder [mailto:Christian.Maeder at dfki.de] 
Gesendet: Montag, 7. März 2011 14:18
An: Hauschild, Klaus (EXT)
Cc: haskell-cafe at haskell.org
Betreff: Re: Overlaping Parsec rules

Am 07.03.2011 13:48, schrieb Hauschild, Klaus (EXT):
> Thanks Christian,
> 
> I adapted the "keyword" parser and now "n" <-> "negi" does not occur.
> 
> But there are still other problems to solve. If I activate the parseFunction the parser will answer to fact.gml unexpected end of input, expecting space or "}".

Your redefinition of spaces (= skipMany1 space) is problematic and:

 parseList = sepBy parseGml' spaces

Allow for the original (optional) spaces after parseGml':

  parseGml'' = liftM2 const parseGml' spaces

  parseList = many parseGml''

C.

P.S. why do you call? many (noneOf "")

   manyTill anyChar newline

   or just: many (noneOf "\n")

   (a trailing newline will be skipped by spaces)

> 
> Any ideas?
> 
> 
> -----Ursprüngliche Nachricht-----
> Von: Christian Maeder [mailto:Christian.Maeder at dfki.de] 
> Gesendet: Montag, 7. März 2011 12:23
> An: Hauschild, Klaus (EXT)
> Cc: haskell-cafe at haskell.org
> Betreff: Re: Overlaping Parsec rules
> 
> You should parse keywords using:
> 
> keyword s = try (string s) >> notFollowedBy (letter <|> digit)
> 
> C.
> 
> Am 07.03.2011 11:34, schrieb Hauschild, Klaus (EXT):
>> Hi,
>>  
>> to solve this ICFP task _http://www.cs.cornell.edu/icfp/task.htm_ I'm
>> currnetly working on the parser. With the hint from Thu (reading Phillip
>> Wadlers monadic parser paper) and consulting
>> _http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_Hours/Parsing_
>> I produce a first working version of the parser.
>> After this great moment I completed the token definition and near all
>> parsing rules. For the complete code have a look at
>> _http://code.google.com/p/hgmltracer/source/browse/#svn%2Ftrunk%2FhGmlTracer_
>>  
>> data GmlToken =
>>        
>>         -- structures
>>        
>>         FunctionToken TokenSequence     |
>>        
>>         ArrayToken TokenSequence        |
>>        
>>         -- control operators
>>        
>>         ApplyToken                      |
>>        
>>         IfToken                         |
>>        
>>         -- number operators
>>        
>>         AddiToken                       |
>>        
>>         AddfToken                       |
>>        
>>         ACosToken                       |
>>        
>>         ASinToken                       |
>>        
>>         ClampfToken                     |
>>        
>>         CosToken                        |
>>        
>>         DiviToken                       |
>>        
>>         DivfToken                       |
>>        
>>         EqiToken                        |
>>        
>>         EqfToken                        |
>>        
>>         FloorToken                      |
>>        
>>         FracToken                       |
>>        
>>         LessiToken                      |
>>        
>>         LessfToken                      |
>>        
>>         ModiToken                       |
>>        
>>         MuliToken                       |
>>        
>>         MulfToken                       |
>>        
>>         NegiToken                       |
>>        
>>         NegfToken                       |
>>        
>>         ToRealToken                     |
>>        
>>         SinToken                        |
>>        
>>         SqrtToken                       |
>>        
>>         SubiToken                       |
>>        
>>         SubfToken                       |
>>        
>>         -- points
>>        
>>         GetXToken                       |
>>        
>>         GetYToken                       |
>>        
>>         GetZToken                       |
>>        
>>         PointToken                      |
>>        
>>         -- arrays
>>        
>>         GetToken                        |
>>        
>>         LengthToken                     |
>>        
>>         -- environment
>>        
>>         IdentifierToken String          |
>>        
>>         BinderToken String              |
>>        
>>         -- types
>>        
>>         BoolToken Bool                  |
>>        
>>         IntToken Int                    |
>>        
>>         RealToken Double                |
>>        
>>         StringToken String              deriving Show  
>>  
>> And
>>  
>> parseGml :: String -> [GmlToken]
>>        
>> parseGml input = case parse parseList "gml" input of
>>        
>>     Left err -> error ("Parse error: " ++ (show err))
>>        
>>     Right gml -> gml
>>        
>>
>>        
>> parseList = sepBy parseGml' spaces
>>        
>>
>>        
>> parseGml' =
>>        
>>         -- structures
>>        
>> --        parseFunction
>>        
>> --    <|> parseArray
>>        
>>         -- control operators
>>        
>>         parseControlOperators
>>        
>>         -- number operators
>>        
>>     <|> parseNumberOperators
>>        
>>         -- points
>>        
>>     <|> parsePointOperators
>>        
>>         -- arrays
>>        
>>     <|> parseArrayOperators
>>        
>>         -- types
>>        
>>     <|> parseBool
>>        
>>     <|> parseInteger
>>        
>>     <|> parseString
>>        
>>         -- environment
>>        
>>     <|> parseIdentifier
>>        
>>     <|> parseBinder
>>        
>>
>>        
>> parseArray = parseSequence '[' ']'
>>        
>> parseFunction = parseSequence '{' '}'
>>        
>> parseSequence start end = do char start
>>        
>>                              array <- parseList
>>        
>>                              char end
>>        
>>                              return $ ArrayToken array
>>        
>>
>>        
>> parseControlOperators = parseApply <|> parseIf
>>        
>> parseApply = do string "apply"
>>        
>>                 return $ ApplyToken
>>        
>> parseIf = do string "if"
>>        
>>              return $ IfToken
>>        
>>
>>        
>> parseNumberOperators = do string "addi"
>>        
>>                           return $ AddiToken
>>        
>>                    <|> do string "addf"
>>        
>>                           return $ AddfToken
>>        
>>                    <|> do string "acos"
>>        
>>                           return $ ACosToken
>>        
>>                    <|> do string "asind"
>>        
>>                           return $ ASinToken
>>        
>>                    <|> do string "clampf"
>>        
>>                           return $ ClampfToken
>>        
>>                    <|> do string "cos"
>>        
>>                           return $ CosToken
>>        
>>                    <|> do string "divi"
>>        
>>                           return $ DiviToken
>>        
>>                    <|> do string "divf"
>>        
>>                           return $ DivfToken
>>        
>>                    <|> do string "eqi"
>>        
>>                           return $ EqiToken
>>        
>>                    <|> do string "eqf"
>>        
>>                           return $ EqfToken
>>        
>>                    <|> do string "floor"
>>        
>>                           return $ FloorToken
>>        
>>                    <|> do string "frac"
>>        
>>                           return $ FracToken
>>        
>>                    <|> do string "lessi"
>>        
>>                           return $ LessiToken
>>        
>>                    <|> do string "lessf"
>>        
>>                           return $ LessfToken
>>        
>>                    <|> do string "modi"
>>        
>>                           return $ ModiToken
>>        
>>                    <|> do string "muli"
>>        
>>                           return $ MuliToken
>>        
>>                    <|> do string "mulf"
>>        
>>                           return $ MulfToken
>>        
>>                    <|> do string "negi"
>>        
>>                           return $ NegiToken
>>        
>>                    <|> do string "negf"
>>        
>>                           return $ NegfToken
>>        
>>                    <|> do string "real"
>>        
>>                           return $ ToRealToken
>>        
>>                    <|> do string "sin"
>>        
>>                           return $ SinToken
>>        
>>                    <|> do string "Sqrt"
>>        
>>                           return $ SqrtToken
>>        
>>                    <|> do string "subi"
>>        
>>                           return $ SubiToken
>>        
>>                    <|> do string "subf"
>>        
>>                           return $ SubfToken
>>        
>>
>>        
>> parsePointOperators = do string "getx"
>>        
>>                          return $ GetXToken
>>        
>>                   <|> do string "gety"
>>        
>>                          return $ GetYToken
>>        
>>                   <|> do string "getz"
>>        
>>                          return $ GetZToken
>>        
>>                   <|> do string "point"
>>        
>>                          return $ PointToken
>>        
>>
>>        
>> parseArrayOperators = do string "get"
>>        
>>                          return $ GetToken
>>        
>>                   <|> do string "length"
>>        
>>                          return $ LengthToken
>>        
>>
>>        
>> parseInteger = liftM (IntToken . read) $ many1 digit
>>        
>> parseBool = do string "true"
>>        
>>                return $ BoolToken True
>>        
>>         <|> do string "false"
>>        
>>                return $ BoolToken False
>>        
>> parseString = do char '"'
>>        
>>                  string <- many (noneOf "\"")
>>        
>>                  char '"'
>>        
>>                  return $ StringToken string
>>        
>>
>>        
>> parseIdentifier = do identifier <- many (noneOf " ")
>>        
>>                      return $ IdentifierToken identifier
>>        
>> parseBinder = do char '/'
>>        
>>                  binder <- many (noneOf " ")
>>        
>>                  return $ BinderToken binder
>>        
>>
>>        
>> parseComment = do char '%'
>>        
>>                   many (noneOf "")
>>        
>>                   newline
>>        
>>                   return $ ()
>>        
>>
>>        
>> spaces = skipMany1 space       
>>  
>>  
>> After gluing all this together in my mind all worked well. But it
>> doesn't. The test file for parsing looks like:
>>  
>> { /self /n
>>   n 2 lessi
>>   { 1 }
>>   { n 1 subi self self apply n muli }
>>   if
>> } /fact
>>  
>> 12 fact fact apply
>>  
>>
>>     * I think there is a problem with overlaping rules. There is a
>>       parser rule consuming "negi" and resulting in the NegiToken. A
>>       single "n" is a valid identifier. For the example file my parser
>>       says: unexpected " ", expecting "negi"
>>     * I think the same problem is present for "parseInteger" and
>>       "parseReal" (currently no in code but looks like "parseReal = do a
>>       <- many1 digit \n char '.' \n b <- many1 digit \n return $
>>       RealToken (read (a ++ "." ++ b)"
>>     * Something with "parseFunction" is going really wrong.
>>     * All parsig rules are designed with the condition that each
>>       "construct" is separated by whitespaces. For this before parsing
>>       the input will be preprocessed: insert spaces, removing
>>       whitespaces and so on. Now in the parsed result appears
>>       (IdentifierToken ""). I think my version is not the best way to
>>       parse a identifer:
>>
>> parseIdentifier = *do* identifier <- many (noneOf " ")
>>                      return $ *IdentifierToken* identifier
>>  
>> Please help me.
>>  
>> Klaus
>>  
>>
>>
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe at haskell.org
>> http://www.haskell.org/mailman/listinfo/haskell-cafe



More information about the Haskell-Cafe mailing list