Safe Haskell	None
Language	Haskell2010

Language.C.Types.Parse

Contents

Parser configuration
- Default configuration
Parser type
Types and parsing
YACC grammar
Testing utilities

Description

A parser for C99 declarations. Currently, the parser has the following limitations:

Array sizes can only be *, n (where n is a positive integer), x (where x is a C identifier). In C99 they can be arbitrary expressions. See the ArrayType data type.
_Bool, _Complex, and _Imaginary are not present.
Untyped parameter lists (pre-K&R C) are not allowed.

The parser is incremental and generic (see CParser). Pretty and Arbitrary instances are provided for all the data types.

The entry point if you want to parse C declarations is parameter_declaration.

Synopsis

type TypeNames = HashSet CIdentifier
data CParserContext i = CParserContext {
- cpcIdentName :: String
- cpcTypeNames :: TypeNames
- cpcParseIdent :: forall m. CParser i m => m i
- cpcIdentToString :: i -> String
}
data CIdentifier
unCIdentifier :: CIdentifier -> String
cIdentifierFromString :: String -> Either String CIdentifier
cCParserContext :: TypeNames -> CParserContext CIdentifier
type CParser i m = (Monad m, Functor m, Applicative m, MonadPlus m, Parsing m, CharParsing m, TokenParsing m, LookAheadParsing m, MonadReader (CParserContext i) m, Hashable i)
runCParser :: Stream s Identity Char => CParserContext i -> String -> s -> ReaderT (CParserContext i) (Parsec s ()) a -> Either ParseError a
quickCParser :: CParserContext i -> String -> ReaderT (CParserContext i) (Parsec String ()) a -> a
quickCParser_ :: String -> ReaderT (CParserContext CIdentifier) (Parsec String ()) a -> a
identifier_no_lex :: CParser i m => m i
data DeclarationSpecifier
- = StorageClassSpecifier StorageClassSpecifier
- | TypeSpecifier TypeSpecifier
- | TypeQualifier TypeQualifier
- | FunctionSpecifier FunctionSpecifier
declaration_specifiers :: CParser i m => m [DeclarationSpecifier]
data StorageClassSpecifier
- = TYPEDEF
- | EXTERN
- | STATIC
- | AUTO
- | REGISTER
storage_class_specifier :: CParser i m => m StorageClassSpecifier
data TypeSpecifier
- = VOID
- | CHAR
- | SHORT
- | INT
- | LONG
- | FLOAT
- | DOUBLE
- | SIGNED
- | UNSIGNED
- | Struct CIdentifier
- | Enum CIdentifier
- | TypeName CIdentifier
type_specifier :: CParser i m => m TypeSpecifier
data TypeQualifier
- = CONST
- | RESTRICT
- | VOLATILE
type_qualifier :: CParser i m => m TypeQualifier
data FunctionSpecifier = INLINE
function_specifier :: CParser i m => m FunctionSpecifier
data Declarator i = Declarator {
- declaratorPointers :: [Pointer]
- declaratorDirect :: DirectDeclarator i
}
declarator :: CParser i m => m (Declarator i)
data DirectDeclarator i
- = DeclaratorRoot i
- | ArrayOrProto (DirectDeclarator i) (ArrayOrProto i)
- | DeclaratorParens (Declarator i)
direct_declarator :: CParser i m => m (DirectDeclarator i)
data ArrayOrProto i
- = Array (ArrayType i)
- | Proto [ParameterDeclaration i]
array_or_proto :: CParser i m => m (ArrayOrProto i)
data ArrayType i
- = VariablySized
- | Unsized
- | SizedByInteger Integer
- | SizedByIdentifier i
array_type :: CParser i m => m (ArrayType i)
data Pointer = Pointer [TypeQualifier]
pointer :: CParser i m => m Pointer
data ParameterDeclaration i = ParameterDeclaration {
- parameterDeclarationSpecifiers :: [DeclarationSpecifier]
- parameterDeclarationDeclarator :: DeclaratorOrAbstractDeclarator i
}
data DeclaratorOrAbstractDeclarator i
- = IsDeclarator (Declarator i)
- | IsAbstractDeclarator (AbstractDeclarator i)
parameter_declaration :: CParser i m => m (ParameterDeclaration i)
parameter_list :: CParser i m => m [ParameterDeclaration i]
data AbstractDeclarator i = AbstractDeclarator {
- abstractDeclaratorPointers :: [Pointer]
- abstractDeclaratorDirect :: Maybe (DirectAbstractDeclarator i)
}
abstract_declarator :: CParser i m => m (AbstractDeclarator i)
data DirectAbstractDeclarator i
- = ArrayOrProtoHere (ArrayOrProto i)
- | ArrayOrProtoThere (DirectAbstractDeclarator i) (ArrayOrProto i)
- | AbstractDeclaratorParens (AbstractDeclarator i)
direct_abstract_declarator :: CParser i m => m (DirectAbstractDeclarator i)
cIdentStart :: [Char]
cIdentLetter :: [Char]
cReservedWords :: HashSet String
isTypeName :: TypeNames -> String -> Bool

Parser configuration

type TypeNames = HashSet CIdentifier #

A collection of named types (typedefs)

data CParserContext i #

Constructors

CParserContext
Fields cpcIdentName :: String cpcTypeNames :: TypeNames Function used to determine whether an identifier is a type name. cpcParseIdent :: forall m. CParser i m => m i Parses an identifier, without consuming whitespace afterwards. cpcIdentToString :: i -> String

Default configuration

data CIdentifier #

A type for C identifiers.

Instances

Eq CIdentifier #
Instance details Defined in Language.C.Types.Parse Methods (==) :: CIdentifier -> CIdentifier -> Bool # (/=) :: CIdentifier -> CIdentifier -> Bool #
Ord CIdentifier #
Instance details Defined in Language.C.Types.Parse Methods compare :: CIdentifier -> CIdentifier -> Ordering # (<) :: CIdentifier -> CIdentifier -> Bool # (<=) :: CIdentifier -> CIdentifier -> Bool # (>) :: CIdentifier -> CIdentifier -> Bool # (>=) :: CIdentifier -> CIdentifier -> Bool # max :: CIdentifier -> CIdentifier -> CIdentifier # min :: CIdentifier -> CIdentifier -> CIdentifier #
Show CIdentifier #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> CIdentifier -> ShowS # show :: CIdentifier -> String # showList :: [CIdentifier] -> ShowS #
IsString CIdentifier #
Instance details Defined in Language.C.Types.Parse Methods fromString :: String -> CIdentifier #
Pretty CIdentifier #
Instance details Defined in Language.C.Types.Parse Methods pretty :: CIdentifier -> Doc # prettyList :: [CIdentifier] -> Doc #
Hashable CIdentifier #
Instance details Defined in Language.C.Types.Parse Methods hashWithSalt :: Int -> CIdentifier -> Int # hash :: CIdentifier -> Int #

unCIdentifier :: CIdentifier -> String #

cIdentifierFromString :: String -> Either String CIdentifier #

cCParserContext :: TypeNames -> CParserContext CIdentifier #

Parser type

type CParser i m = (Monad m, Functor m, Applicative m, MonadPlus m, Parsing m, CharParsing m, TokenParsing m, LookAheadParsing m, MonadReader (CParserContext i) m, Hashable i) #

All the parsing is done using the type classes provided by the parsers package. You can use the parsing routines with any of the parsers that implement the classes, such as parsec or trifecta.

We parametrize the parsing by the type of the variable identifiers, i. We do so because we use this parser to implement anti-quoters referring to Haskell variables, and thus we need to parse Haskell identifiers in certain positions.

runCParser #

Arguments

:: Stream s Identity Char
=> CParserContext i
-> String	Source name.
-> s	String to parse.
-> ReaderT (CParserContext i) (Parsec s ()) a	Parser. Anything with type `forall m. CParser i m => m a` is a valid argument.
-> Either ParseError a

Runs a CParser using parsec.

quickCParser #

Arguments

:: CParserContext i
-> String	String to parse.
-> ReaderT (CParserContext i) (Parsec String ()) a	Parser. Anything with type `forall m. CParser i m => m a` is a valid argument.
-> a

Useful for quick testing. Uses "quickCParser" as source name, and throws an error if parsing fails.

quickCParser_ #

Arguments

:: String	String to parse.
-> ReaderT (CParserContext CIdentifier) (Parsec String ()) a	Parser. Anything with type `forall m. CParser i m => m a` is a valid argument.
-> a

Like quickCParser, but uses cCParserContext (const False) as CParserContext.

Types and parsing

identifier_no_lex :: CParser i m => m i #

data DeclarationSpecifier #

Constructors

StorageClassSpecifier StorageClassSpecifier
TypeSpecifier TypeSpecifier
TypeQualifier TypeQualifier
FunctionSpecifier FunctionSpecifier

Instances

Eq DeclarationSpecifier #
Instance details Defined in Language.C.Types.Parse Methods (==) :: DeclarationSpecifier -> DeclarationSpecifier -> Bool # (/=) :: DeclarationSpecifier -> DeclarationSpecifier -> Bool #
Show DeclarationSpecifier #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> DeclarationSpecifier -> ShowS # show :: DeclarationSpecifier -> String # showList :: [DeclarationSpecifier] -> ShowS #
Pretty DeclarationSpecifier #
Instance details Defined in Language.C.Types.Parse Methods pretty :: DeclarationSpecifier -> Doc # prettyList :: [DeclarationSpecifier] -> Doc #

declaration_specifiers :: CParser i m => m [DeclarationSpecifier] #

data StorageClassSpecifier #

Constructors

TYPEDEF
EXTERN
STATIC
AUTO
REGISTER

Instances

Eq StorageClassSpecifier #
Instance details Defined in Language.C.Types.Parse Methods (==) :: StorageClassSpecifier -> StorageClassSpecifier -> Bool # (/=) :: StorageClassSpecifier -> StorageClassSpecifier -> Bool #
Show StorageClassSpecifier #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> StorageClassSpecifier -> ShowS # show :: StorageClassSpecifier -> String # showList :: [StorageClassSpecifier] -> ShowS #
Pretty StorageClassSpecifier #
Instance details Defined in Language.C.Types.Parse Methods pretty :: StorageClassSpecifier -> Doc # prettyList :: [StorageClassSpecifier] -> Doc #

storage_class_specifier :: CParser i m => m StorageClassSpecifier #

data TypeSpecifier #

Constructors

VOID
CHAR
SHORT
INT
LONG
FLOAT
DOUBLE
SIGNED
UNSIGNED
Struct CIdentifier
Enum CIdentifier
TypeName CIdentifier

Instances

Eq TypeSpecifier #
Instance details Defined in Language.C.Types.Parse Methods (==) :: TypeSpecifier -> TypeSpecifier -> Bool # (/=) :: TypeSpecifier -> TypeSpecifier -> Bool #
Show TypeSpecifier #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> TypeSpecifier -> ShowS # show :: TypeSpecifier -> String # showList :: [TypeSpecifier] -> ShowS #
Pretty TypeSpecifier #
Instance details Defined in Language.C.Types.Parse Methods pretty :: TypeSpecifier -> Doc # prettyList :: [TypeSpecifier] -> Doc #

type_specifier :: CParser i m => m TypeSpecifier #

data TypeQualifier #

Constructors

CONST
RESTRICT
VOLATILE

Instances

Eq TypeQualifier #
Instance details Defined in Language.C.Types.Parse Methods (==) :: TypeQualifier -> TypeQualifier -> Bool # (/=) :: TypeQualifier -> TypeQualifier -> Bool #
Show TypeQualifier #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> TypeQualifier -> ShowS # show :: TypeQualifier -> String # showList :: [TypeQualifier] -> ShowS #
Pretty TypeQualifier #
Instance details Defined in Language.C.Types.Parse Methods pretty :: TypeQualifier -> Doc # prettyList :: [TypeQualifier] -> Doc #

type_qualifier :: CParser i m => m TypeQualifier #

data FunctionSpecifier #

Constructors

INLINE

Instances

Eq FunctionSpecifier #
Instance details Defined in Language.C.Types.Parse Methods (==) :: FunctionSpecifier -> FunctionSpecifier -> Bool # (/=) :: FunctionSpecifier -> FunctionSpecifier -> Bool #
Show FunctionSpecifier #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> FunctionSpecifier -> ShowS # show :: FunctionSpecifier -> String # showList :: [FunctionSpecifier] -> ShowS #
Pretty FunctionSpecifier #
Instance details Defined in Language.C.Types.Parse Methods pretty :: FunctionSpecifier -> Doc # prettyList :: [FunctionSpecifier] -> Doc #

function_specifier :: CParser i m => m FunctionSpecifier #

data Declarator i #

Constructors

Declarator
Fields declaratorPointers :: [Pointer] declaratorDirect :: DirectDeclarator i

Instances

Functor Declarator #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> Declarator a -> Declarator b # (<$) :: a -> Declarator b -> Declarator a #
Foldable Declarator #
Instance details Defined in Language.C.Types.Parse Methods fold :: Monoid m => Declarator m -> m # foldMap :: Monoid m => (a -> m) -> Declarator a -> m # foldr :: (a -> b -> b) -> b -> Declarator a -> b # foldr' :: (a -> b -> b) -> b -> Declarator a -> b # foldl :: (b -> a -> b) -> b -> Declarator a -> b # foldl' :: (b -> a -> b) -> b -> Declarator a -> b # foldr1 :: (a -> a -> a) -> Declarator a -> a # foldl1 :: (a -> a -> a) -> Declarator a -> a # toList :: Declarator a -> [a] # null :: Declarator a -> Bool # length :: Declarator a -> Int # elem :: Eq a => a -> Declarator a -> Bool # maximum :: Ord a => Declarator a -> a # minimum :: Ord a => Declarator a -> a # sum :: Num a => Declarator a -> a # product :: Num a => Declarator a -> a #
Traversable Declarator #
Instance details Defined in Language.C.Types.Parse Methods traverse :: Applicative f => (a -> f b) -> Declarator a -> f (Declarator b) # sequenceA :: Applicative f => Declarator (f a) -> f (Declarator a) # mapM :: Monad m => (a -> m b) -> Declarator a -> m (Declarator b) # sequence :: Monad m => Declarator (m a) -> m (Declarator a) #
Eq i => Eq (Declarator i) #
Instance details Defined in Language.C.Types.Parse Methods (==) :: Declarator i -> Declarator i -> Bool # (/=) :: Declarator i -> Declarator i -> Bool #
Show i => Show (Declarator i) #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> Declarator i -> ShowS # show :: Declarator i -> String # showList :: [Declarator i] -> ShowS #
Pretty i => Pretty (Declarator i) #
Instance details Defined in Language.C.Types.Parse Methods pretty :: Declarator i -> Doc # prettyList :: [Declarator i] -> Doc #

declarator :: CParser i m => m (Declarator i) #

data DirectDeclarator i #

Constructors

DeclaratorRoot i
ArrayOrProto (DirectDeclarator i) (ArrayOrProto i)
DeclaratorParens (Declarator i)

Instances

Functor DirectDeclarator #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> DirectDeclarator a -> DirectDeclarator b # (<$) :: a -> DirectDeclarator b -> DirectDeclarator a #
Foldable DirectDeclarator #
Instance details Defined in Language.C.Types.Parse Methods fold :: Monoid m => DirectDeclarator m -> m # foldMap :: Monoid m => (a -> m) -> DirectDeclarator a -> m # foldr :: (a -> b -> b) -> b -> DirectDeclarator a -> b # foldr' :: (a -> b -> b) -> b -> DirectDeclarator a -> b # foldl :: (b -> a -> b) -> b -> DirectDeclarator a -> b # foldl' :: (b -> a -> b) -> b -> DirectDeclarator a -> b # foldr1 :: (a -> a -> a) -> DirectDeclarator a -> a # foldl1 :: (a -> a -> a) -> DirectDeclarator a -> a # toList :: DirectDeclarator a -> [a] # null :: DirectDeclarator a -> Bool # length :: DirectDeclarator a -> Int # elem :: Eq a => a -> DirectDeclarator a -> Bool # maximum :: Ord a => DirectDeclarator a -> a # minimum :: Ord a => DirectDeclarator a -> a # sum :: Num a => DirectDeclarator a -> a # product :: Num a => DirectDeclarator a -> a #
Traversable DirectDeclarator #
Instance details Defined in Language.C.Types.Parse Methods traverse :: Applicative f => (a -> f b) -> DirectDeclarator a -> f (DirectDeclarator b) # sequenceA :: Applicative f => DirectDeclarator (f a) -> f (DirectDeclarator a) # mapM :: Monad m => (a -> m b) -> DirectDeclarator a -> m (DirectDeclarator b) # sequence :: Monad m => DirectDeclarator (m a) -> m (DirectDeclarator a) #
Eq i => Eq (DirectDeclarator i) #
Instance details Defined in Language.C.Types.Parse Methods (==) :: DirectDeclarator i -> DirectDeclarator i -> Bool # (/=) :: DirectDeclarator i -> DirectDeclarator i -> Bool #
Show i => Show (DirectDeclarator i) #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> DirectDeclarator i -> ShowS # show :: DirectDeclarator i -> String # showList :: [DirectDeclarator i] -> ShowS #
Pretty i => Pretty (DirectDeclarator i) #
Instance details Defined in Language.C.Types.Parse Methods pretty :: DirectDeclarator i -> Doc # prettyList :: [DirectDeclarator i] -> Doc #

direct_declarator :: CParser i m => m (DirectDeclarator i) #

data ArrayOrProto i #

Constructors

Array (ArrayType i)
Proto [ParameterDeclaration i]

Instances

Functor ArrayOrProto #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> ArrayOrProto a -> ArrayOrProto b # (<$) :: a -> ArrayOrProto b -> ArrayOrProto a #
Foldable ArrayOrProto #
Instance details Defined in Language.C.Types.Parse Methods fold :: Monoid m => ArrayOrProto m -> m # foldMap :: Monoid m => (a -> m) -> ArrayOrProto a -> m # foldr :: (a -> b -> b) -> b -> ArrayOrProto a -> b # foldr' :: (a -> b -> b) -> b -> ArrayOrProto a -> b # foldl :: (b -> a -> b) -> b -> ArrayOrProto a -> b # foldl' :: (b -> a -> b) -> b -> ArrayOrProto a -> b # foldr1 :: (a -> a -> a) -> ArrayOrProto a -> a # foldl1 :: (a -> a -> a) -> ArrayOrProto a -> a # toList :: ArrayOrProto a -> [a] # null :: ArrayOrProto a -> Bool # length :: ArrayOrProto a -> Int # elem :: Eq a => a -> ArrayOrProto a -> Bool # maximum :: Ord a => ArrayOrProto a -> a # minimum :: Ord a => ArrayOrProto a -> a # sum :: Num a => ArrayOrProto a -> a # product :: Num a => ArrayOrProto a -> a #
Traversable ArrayOrProto #
Instance details Defined in Language.C.Types.Parse Methods traverse :: Applicative f => (a -> f b) -> ArrayOrProto a -> f (ArrayOrProto b) # sequenceA :: Applicative f => ArrayOrProto (f a) -> f (ArrayOrProto a) # mapM :: Monad m => (a -> m b) -> ArrayOrProto a -> m (ArrayOrProto b) # sequence :: Monad m => ArrayOrProto (m a) -> m (ArrayOrProto a) #
Eq i => Eq (ArrayOrProto i) #
Instance details Defined in Language.C.Types.Parse Methods (==) :: ArrayOrProto i -> ArrayOrProto i -> Bool # (/=) :: ArrayOrProto i -> ArrayOrProto i -> Bool #
Show i => Show (ArrayOrProto i) #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> ArrayOrProto i -> ShowS # show :: ArrayOrProto i -> String # showList :: [ArrayOrProto i] -> ShowS #
Pretty i => Pretty (ArrayOrProto i) #
Instance details Defined in Language.C.Types.Parse Methods pretty :: ArrayOrProto i -> Doc # prettyList :: [ArrayOrProto i] -> Doc #

array_or_proto :: CParser i m => m (ArrayOrProto i) #

data ArrayType i #

Constructors

VariablySized
Unsized
SizedByInteger Integer
SizedByIdentifier i

Instances

Functor ArrayType #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> ArrayType a -> ArrayType b # (<$) :: a -> ArrayType b -> ArrayType a #
Foldable ArrayType #
Instance details Defined in Language.C.Types.Parse Methods fold :: Monoid m => ArrayType m -> m # foldMap :: Monoid m => (a -> m) -> ArrayType a -> m # foldr :: (a -> b -> b) -> b -> ArrayType a -> b # foldr' :: (a -> b -> b) -> b -> ArrayType a -> b # foldl :: (b -> a -> b) -> b -> ArrayType a -> b # foldl' :: (b -> a -> b) -> b -> ArrayType a -> b # foldr1 :: (a -> a -> a) -> ArrayType a -> a # foldl1 :: (a -> a -> a) -> ArrayType a -> a # toList :: ArrayType a -> [a] # null :: ArrayType a -> Bool # length :: ArrayType a -> Int # elem :: Eq a => a -> ArrayType a -> Bool # maximum :: Ord a => ArrayType a -> a # minimum :: Ord a => ArrayType a -> a # sum :: Num a => ArrayType a -> a # product :: Num a => ArrayType a -> a #
Traversable ArrayType #
Instance details Defined in Language.C.Types.Parse Methods traverse :: Applicative f => (a -> f b) -> ArrayType a -> f (ArrayType b) # sequenceA :: Applicative f => ArrayType (f a) -> f (ArrayType a) # mapM :: Monad m => (a -> m b) -> ArrayType a -> m (ArrayType b) # sequence :: Monad m => ArrayType (m a) -> m (ArrayType a) #
Eq i => Eq (ArrayType i) #
Instance details Defined in Language.C.Types.Parse Methods (==) :: ArrayType i -> ArrayType i -> Bool # (/=) :: ArrayType i -> ArrayType i -> Bool #
Show i => Show (ArrayType i) #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> ArrayType i -> ShowS # show :: ArrayType i -> String # showList :: [ArrayType i] -> ShowS #
Pretty i => Pretty (ArrayType i) #
Instance details Defined in Language.C.Types.Parse Methods pretty :: ArrayType i -> Doc # prettyList :: [ArrayType i] -> Doc #

array_type :: CParser i m => m (ArrayType i) #

data Pointer #

Constructors

Pointer [TypeQualifier]

Instances

Eq Pointer #
Instance details Defined in Language.C.Types.Parse Methods (==) :: Pointer -> Pointer -> Bool # (/=) :: Pointer -> Pointer -> Bool #
Show Pointer #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> Pointer -> ShowS # show :: Pointer -> String # showList :: [Pointer] -> ShowS #
Pretty Pointer #
Instance details Defined in Language.C.Types.Parse Methods pretty :: Pointer -> Doc # prettyList :: [Pointer] -> Doc #

pointer :: CParser i m => m Pointer #

data ParameterDeclaration i #

Constructors

ParameterDeclaration
Fields parameterDeclarationSpecifiers :: [DeclarationSpecifier] parameterDeclarationDeclarator :: DeclaratorOrAbstractDeclarator i

Instances

Functor ParameterDeclaration #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> ParameterDeclaration a -> ParameterDeclaration b # (<$) :: a -> ParameterDeclaration b -> ParameterDeclaration a #
Foldable ParameterDeclaration #
Instance details Defined in Language.C.Types.Parse Methods fold :: Monoid m => ParameterDeclaration m -> m # foldMap :: Monoid m => (a -> m) -> ParameterDeclaration a -> m # foldr :: (a -> b -> b) -> b -> ParameterDeclaration a -> b # foldr' :: (a -> b -> b) -> b -> ParameterDeclaration a -> b # foldl :: (b -> a -> b) -> b -> ParameterDeclaration a -> b # foldl' :: (b -> a -> b) -> b -> ParameterDeclaration a -> b # foldr1 :: (a -> a -> a) -> ParameterDeclaration a -> a # foldl1 :: (a -> a -> a) -> ParameterDeclaration a -> a # toList :: ParameterDeclaration a -> [a] # null :: ParameterDeclaration a -> Bool # length :: ParameterDeclaration a -> Int # elem :: Eq a => a -> ParameterDeclaration a -> Bool # maximum :: Ord a => ParameterDeclaration a -> a # minimum :: Ord a => ParameterDeclaration a -> a # sum :: Num a => ParameterDeclaration a -> a # product :: Num a => ParameterDeclaration a -> a #
Traversable ParameterDeclaration #
Instance details Defined in Language.C.Types.Parse Methods traverse :: Applicative f => (a -> f b) -> ParameterDeclaration a -> f (ParameterDeclaration b) # sequenceA :: Applicative f => ParameterDeclaration (f a) -> f (ParameterDeclaration a) # mapM :: Monad m => (a -> m b) -> ParameterDeclaration a -> m (ParameterDeclaration b) # sequence :: Monad m => ParameterDeclaration (m a) -> m (ParameterDeclaration a) #
Eq i => Eq (ParameterDeclaration i) #
Instance details Defined in Language.C.Types.Parse Methods (==) :: ParameterDeclaration i -> ParameterDeclaration i -> Bool # (/=) :: ParameterDeclaration i -> ParameterDeclaration i -> Bool #
Show i => Show (ParameterDeclaration i) #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> ParameterDeclaration i -> ShowS # show :: ParameterDeclaration i -> String # showList :: [ParameterDeclaration i] -> ShowS #
Pretty i => Pretty (ParameterDeclaration i) #
Instance details Defined in Language.C.Types.Parse Methods pretty :: ParameterDeclaration i -> Doc # prettyList :: [ParameterDeclaration i] -> Doc #

data DeclaratorOrAbstractDeclarator i #

Constructors

IsDeclarator (Declarator i)
IsAbstractDeclarator (AbstractDeclarator i)

Instances

Functor DeclaratorOrAbstractDeclarator #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> DeclaratorOrAbstractDeclarator a -> DeclaratorOrAbstractDeclarator b # (<$) :: a -> DeclaratorOrAbstractDeclarator b -> DeclaratorOrAbstractDeclarator a #
Foldable DeclaratorOrAbstractDeclarator #
Instance details Defined in Language.C.Types.Parse Methods fold :: Monoid m => DeclaratorOrAbstractDeclarator m -> m # foldMap :: Monoid m => (a -> m) -> DeclaratorOrAbstractDeclarator a -> m # foldr :: (a -> b -> b) -> b -> DeclaratorOrAbstractDeclarator a -> b # foldr' :: (a -> b -> b) -> b -> DeclaratorOrAbstractDeclarator a -> b # foldl :: (b -> a -> b) -> b -> DeclaratorOrAbstractDeclarator a -> b # foldl' :: (b -> a -> b) -> b -> DeclaratorOrAbstractDeclarator a -> b # foldr1 :: (a -> a -> a) -> DeclaratorOrAbstractDeclarator a -> a # foldl1 :: (a -> a -> a) -> DeclaratorOrAbstractDeclarator a -> a # toList :: DeclaratorOrAbstractDeclarator a -> [a] # null :: DeclaratorOrAbstractDeclarator a -> Bool # length :: DeclaratorOrAbstractDeclarator a -> Int # elem :: Eq a => a -> DeclaratorOrAbstractDeclarator a -> Bool # maximum :: Ord a => DeclaratorOrAbstractDeclarator a -> a # minimum :: Ord a => DeclaratorOrAbstractDeclarator a -> a # sum :: Num a => DeclaratorOrAbstractDeclarator a -> a # product :: Num a => DeclaratorOrAbstractDeclarator a -> a #
Traversable DeclaratorOrAbstractDeclarator #
Instance details Defined in Language.C.Types.Parse Methods traverse :: Applicative f => (a -> f b) -> DeclaratorOrAbstractDeclarator a -> f (DeclaratorOrAbstractDeclarator b) # sequenceA :: Applicative f => DeclaratorOrAbstractDeclarator (f a) -> f (DeclaratorOrAbstractDeclarator a) # mapM :: Monad m => (a -> m b) -> DeclaratorOrAbstractDeclarator a -> m (DeclaratorOrAbstractDeclarator b) # sequence :: Monad m => DeclaratorOrAbstractDeclarator (m a) -> m (DeclaratorOrAbstractDeclarator a) #
Eq i => Eq (DeclaratorOrAbstractDeclarator i) #
Instance details Defined in Language.C.Types.Parse Methods (==) :: DeclaratorOrAbstractDeclarator i -> DeclaratorOrAbstractDeclarator i -> Bool # (/=) :: DeclaratorOrAbstractDeclarator i -> DeclaratorOrAbstractDeclarator i -> Bool #
Show i => Show (DeclaratorOrAbstractDeclarator i) #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> DeclaratorOrAbstractDeclarator i -> ShowS # show :: DeclaratorOrAbstractDeclarator i -> String # showList :: [DeclaratorOrAbstractDeclarator i] -> ShowS #

parameter_declaration :: CParser i m => m (ParameterDeclaration i) #

parameter_list :: CParser i m => m [ParameterDeclaration i] #

data AbstractDeclarator i #

Constructors

AbstractDeclarator
Fields abstractDeclaratorPointers :: [Pointer] abstractDeclaratorDirect :: Maybe (DirectAbstractDeclarator i)

Instances

Functor AbstractDeclarator #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> AbstractDeclarator a -> AbstractDeclarator b # (<$) :: a -> AbstractDeclarator b -> AbstractDeclarator a #
Foldable AbstractDeclarator #
Instance details Defined in Language.C.Types.Parse Methods fold :: Monoid m => AbstractDeclarator m -> m # foldMap :: Monoid m => (a -> m) -> AbstractDeclarator a -> m # foldr :: (a -> b -> b) -> b -> AbstractDeclarator a -> b # foldr' :: (a -> b -> b) -> b -> AbstractDeclarator a -> b # foldl :: (b -> a -> b) -> b -> AbstractDeclarator a -> b # foldl' :: (b -> a -> b) -> b -> AbstractDeclarator a -> b # foldr1 :: (a -> a -> a) -> AbstractDeclarator a -> a # foldl1 :: (a -> a -> a) -> AbstractDeclarator a -> a # toList :: AbstractDeclarator a -> [a] # null :: AbstractDeclarator a -> Bool # length :: AbstractDeclarator a -> Int # elem :: Eq a => a -> AbstractDeclarator a -> Bool # maximum :: Ord a => AbstractDeclarator a -> a # minimum :: Ord a => AbstractDeclarator a -> a # sum :: Num a => AbstractDeclarator a -> a # product :: Num a => AbstractDeclarator a -> a #
Traversable AbstractDeclarator #
Instance details Defined in Language.C.Types.Parse Methods traverse :: Applicative f => (a -> f b) -> AbstractDeclarator a -> f (AbstractDeclarator b) # sequenceA :: Applicative f => AbstractDeclarator (f a) -> f (AbstractDeclarator a) # mapM :: Monad m => (a -> m b) -> AbstractDeclarator a -> m (AbstractDeclarator b) # sequence :: Monad m => AbstractDeclarator (m a) -> m (AbstractDeclarator a) #
Eq i => Eq (AbstractDeclarator i) #
Instance details Defined in Language.C.Types.Parse Methods (==) :: AbstractDeclarator i -> AbstractDeclarator i -> Bool # (/=) :: AbstractDeclarator i -> AbstractDeclarator i -> Bool #
Show i => Show (AbstractDeclarator i) #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> AbstractDeclarator i -> ShowS # show :: AbstractDeclarator i -> String # showList :: [AbstractDeclarator i] -> ShowS #
Pretty i => Pretty (AbstractDeclarator i) #
Instance details Defined in Language.C.Types.Parse Methods pretty :: AbstractDeclarator i -> Doc # prettyList :: [AbstractDeclarator i] -> Doc #

abstract_declarator :: CParser i m => m (AbstractDeclarator i) #

data DirectAbstractDeclarator i #

Constructors

ArrayOrProtoHere (ArrayOrProto i)
ArrayOrProtoThere (DirectAbstractDeclarator i) (ArrayOrProto i)
AbstractDeclaratorParens (AbstractDeclarator i)

Instances

Functor DirectAbstractDeclarator #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> DirectAbstractDeclarator a -> DirectAbstractDeclarator b # (<$) :: a -> DirectAbstractDeclarator b -> DirectAbstractDeclarator a #
Foldable DirectAbstractDeclarator #
Instance details Defined in Language.C.Types.Parse Methods fold :: Monoid m => DirectAbstractDeclarator m -> m # foldMap :: Monoid m => (a -> m) -> DirectAbstractDeclarator a -> m # foldr :: (a -> b -> b) -> b -> DirectAbstractDeclarator a -> b # foldr' :: (a -> b -> b) -> b -> DirectAbstractDeclarator a -> b # foldl :: (b -> a -> b) -> b -> DirectAbstractDeclarator a -> b # foldl' :: (b -> a -> b) -> b -> DirectAbstractDeclarator a -> b # foldr1 :: (a -> a -> a) -> DirectAbstractDeclarator a -> a # foldl1 :: (a -> a -> a) -> DirectAbstractDeclarator a -> a # toList :: DirectAbstractDeclarator a -> [a] # null :: DirectAbstractDeclarator a -> Bool # length :: DirectAbstractDeclarator a -> Int # elem :: Eq a => a -> DirectAbstractDeclarator a -> Bool # maximum :: Ord a => DirectAbstractDeclarator a -> a # minimum :: Ord a => DirectAbstractDeclarator a -> a # sum :: Num a => DirectAbstractDeclarator a -> a # product :: Num a => DirectAbstractDeclarator a -> a #
Traversable DirectAbstractDeclarator #
Instance details Defined in Language.C.Types.Parse Methods traverse :: Applicative f => (a -> f b) -> DirectAbstractDeclarator a -> f (DirectAbstractDeclarator b) # sequenceA :: Applicative f => DirectAbstractDeclarator (f a) -> f (DirectAbstractDeclarator a) # mapM :: Monad m => (a -> m b) -> DirectAbstractDeclarator a -> m (DirectAbstractDeclarator b) # sequence :: Monad m => DirectAbstractDeclarator (m a) -> m (DirectAbstractDeclarator a) #
Eq i => Eq (DirectAbstractDeclarator i) #
Instance details Defined in Language.C.Types.Parse Methods (==) :: DirectAbstractDeclarator i -> DirectAbstractDeclarator i -> Bool # (/=) :: DirectAbstractDeclarator i -> DirectAbstractDeclarator i -> Bool #
Show i => Show (DirectAbstractDeclarator i) #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> DirectAbstractDeclarator i -> ShowS # show :: DirectAbstractDeclarator i -> String # showList :: [DirectAbstractDeclarator i] -> ShowS #
Pretty i => Pretty (DirectAbstractDeclarator i) #
Instance details Defined in Language.C.Types.Parse Methods pretty :: DirectAbstractDeclarator i -> Doc # prettyList :: [DirectAbstractDeclarator i] -> Doc #

direct_abstract_declarator :: CParser i m => m (DirectAbstractDeclarator i) #

YACC grammar

The parser above is derived from a modification of the YACC grammar for C99 found at http://www.quut.com/c/ANSI-C-grammar-y-1999.html, reproduced below.

%token IDENTIFIER TYPE_NAME INTEGER

%token TYPEDEF EXTERN STATIC AUTO REGISTER INLINE RESTRICT
%token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID
%token BOOL COMPLEX IMAGINARY
%token STRUCT UNION ENUM

%start parameter_list
%%

declaration_specifiers
	: storage_class_specifier
	| storage_class_specifier declaration_specifiers
	| type_specifier
	| type_specifier declaration_specifiers
	| type_qualifier
	| type_qualifier declaration_specifiers
	| function_specifier
	| function_specifier declaration_specifiers
	;

storage_class_specifier
	: TYPEDEF
	| EXTERN
	| STATIC
	| AUTO
	| REGISTER
	;

type_specifier
	: VOID
	| CHAR
	| SHORT
	| INT
	| LONG
	| FLOAT
	| DOUBLE
	| SIGNED
	| UNSIGNED
	| BOOL
	| COMPLEX
	| IMAGINARY
 	| STRUCT IDENTIFIER
	| UNION IDENTIFIER
	| ENUM IDENTIFIER
	| TYPE_NAME
	;

type_qualifier
	: CONST
	| RESTRICT
	| VOLATILE
	;

function_specifier
	: INLINE
	;

declarator
	: pointer direct_declarator
	| direct_declarator
	;

direct_declarator
	: IDENTIFIER
	| '(' declarator ')'
	| direct_declarator '[' type_qualifier_list ']'
	| direct_declarator '[' type_qualifier_list * ']'
	| direct_declarator '[' * ']'
 	| direct_declarator '[' IDENTIFIER ']'
	| direct_declarator '[' INTEGER ']'
	| direct_declarator '[' ']'
	| direct_declarator '(' parameter_list ')'
	| direct_declarator '(' ')'
	;

pointer
	: *
	| * type_qualifier_list
	| * pointer
	| * type_qualifier_list pointer
	;

type_qualifier_list
	: type_qualifier
	| type_qualifier_list type_qualifier
	;

parameter_list
	: parameter_declaration
	| parameter_list ',' parameter_declaration
	;

parameter_declaration
	: declaration_specifiers declarator
	| declaration_specifiers abstract_declarator
	| declaration_specifiers
	;

abstract_declarator
	: pointer
	| direct_abstract_declarator
	| pointer direct_abstract_declarator
	;

direct_abstract_declarator
	: '(' abstract_declarator ')'
	| '[' ']'
	| direct_abstract_declarator '[' ']'
	| '[' * ']'
	| direct_abstract_declarator '[' * ']'
	| '[' IDENTIFIER ']'
	| direct_abstract_declarator '[' IDENTIFIER ']'
	| '[' INTEGER ']'
	| direct_abstract_declarator '[' INTEGER ']'
	| '(' ')'
	| '(' parameter_list ')'
	| direct_abstract_declarator '(' ')'
	| direct_abstract_declarator '(' parameter_list ')'
	;

%%
#include <stdio.h>

extern char yytext[];
extern int column;

void yyerror(char const *s)
{
	fflush(stdout);
	printf("n%*sn%*sn", column, "^", column, s);
}

Testing utilities

cIdentStart :: [Char] #

cIdentLetter :: [Char] #

cReservedWords :: HashSet String #

isTypeName :: TypeNames -> String -> Bool #