■

Parsec分からん。まあろくに説明も読まずに使っているけれど、なんでこれでCのexpressionがうまくパース出来ないのでしょう…ちゃんと解説読むか…

module Main where

import Text.ParserCombinators.Parsec

main = do src <- getContents
          putStrLn $ makeSrc src

makeSrc :: String -> String
makeSrc src = case parse expression "" src of
    Right madeSrc -> madeSrc
    Left err -> show err

expression :: Parser String
expression = assignment_expression
         <|> do a <- expression
                b <- string ","
                c <- assignment_expression
                return $ a ++ b ++ c

assignment_expression = conditional_expression
                    <|> do a <- unary_expression
                           b <- assignment_operator
                           c <- assignment_expression
                           return $ a ++ b ++ c

assignment_operator = string "="
                  <|> string "*="
                  <|> string "/="
                  <|> string "%="
                  <|> string "+="
                  <|> string "-="
                  <|> string "<<="
                  <|> string ">>="
                  <|> string "&="
                  <|> string "^="
                  <|> string "|="

conditional_expression = logical_OR_expression
                     <|> do a <- logical_OR_expression
                            b <- string "?"
                            c <- expression
                            d <- string ":"
                            e <- conditional_expression
                            return $ a ++ b ++ c ++ d ++ e

constant_expression = conditional_expression

logical_OR_expression = logical_AND_expression
                    <|> do a <- logical_OR_expression
                           b <- string "||"
                           c <- logical_AND_expression
                           return $ a ++ b ++ c

logical_AND_expression = inclusive_OR_expression
                     <|> do a <- logical_AND_expression
                            b <- string "&&"
                            c <- inclusive_OR_expression
                            return $ a ++ b ++ c

inclusive_OR_expression = exclusive_OR_expression
                      <|> do a <- inclusive_OR_expression
                             b <- string "|"
                             c <- exclusive_OR_expression
                             return $ a ++ b ++ c

exclusive_OR_expression = aND_expression
                      <|> do a <- inclusive_OR_expression
                             b <- string "^"
                             c <- aND_expression
                             return $ a ++ b ++ c

aND_expression = equality_expression
             <|> do a <- aND_expression
                    b <- string "&"
                    c <- equality_expression
                    return $ a ++ b ++ c

equality_expression = relational_expression
                  <|> do a <- equality_expression
                         b <- string "=="
                         c <- relational_expression
                         return $ a ++ b ++ c
                  <|> do a <- equality_expression
                         b <- string "!="
                         c <- relational_expression
                         return $ a ++ b ++ c

relational_expression = shift_expression
                    <|> do a <- relational_expression
                           b <- string "<"
                           c <- shift_expression
                           return $ a ++ b ++ c
                    <|> do a <- relational_expression
                           b <- string ">"
                           c <- shift_expression
                           return $ a ++ b ++ c
                    <|> do a <- relational_expression
                           b <- string "<="
                           c <- shift_expression
                           return $ a ++ b ++ c
                    <|> do a <- relational_expression
                           b <- string ">="
                           c <- shift_expression
                           return $ a ++ b ++ c

shift_expression = additive_expression
               <|> do a <- shift_expression
                      b <- string "<<"
                      c <- additive_expression
                      return $ a ++ b ++ c
               <|> do a <- shift_expression
                      b <- string ">>"
                      c <- additive_expression
                      return $ a ++ b ++ c

additive_expression = multiplicative_expression
                  <|> do a <- additive_expression
                         b <- string "+"
                         c <- multiplicative_expression
                         return $ a ++ b ++ c
                  <|> do a <- additive_expression
                         b <- string "-"
                         c <- multiplicative_expression
                         return $ a ++ b ++ c

multiplicative_expression = cast_expression
                        <|> do a <- multiplicative_expression
                               b <- string "*"
                               c <- cast_expression
                               return $ a ++ b ++ c
                        <|> do a <- multiplicative_expression
                               b <- string "/"
                               c <- cast_expression
                               return $ a ++ b ++ c
                        <|> do a <- multiplicative_expression
                               b <- string "%"
                               c <- cast_expression
                               return $ a ++ b ++ c

cast_expression = unary_expression -- also cast

unary_expression = postfix_expression -- also something

postfix_expression = primary_expression -- also something

primary_expression = identifier
                 <|> do char '('
                        a <- expression
                        char ')'
                        return $ "(" ++ a ++ ")" -- also something

identifier = do spaces
                a <- many1 alphaNum --also underbar
                spaces
                return a