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
- cpcEnableCpp :: Bool
}
data CIdentifier
unCIdentifier :: CIdentifier -> String
cIdentifierFromString :: Bool -> String -> Either String CIdentifier
cCParserContext :: Bool -> 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_ :: Bool -> 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
- | BOOL
- | CHAR
- | SHORT
- | INT
- | LONG
- | FLOAT
- | DOUBLE
- | SIGNED
- | UNSIGNED
- | Struct CIdentifier
- | Enum CIdentifier
- | TypeName CIdentifier
- | Template CIdentifier [TypeSpecifier]
- | TemplateConst String
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 :: Bool -> TypeNames -> String -> Bool

Parser configuration

type TypeNames = HashSet CIdentifier Source #

A collection of named types (typedefs)

data CParserContext i Source #

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 cpcEnableCpp :: Bool

Default configuration

data CIdentifier Source #

A type for C identifiers.

Instances

Eq CIdentifier Source #
Instance details Defined in Language.C.Types.Parse Methods (==) :: CIdentifier -> CIdentifier -> Bool # (/=) :: CIdentifier -> CIdentifier -> Bool #
Ord CIdentifier Source #
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 Source #
Instance details Defined in Language.C.Types.Parse Methods showsPrec :: Int -> CIdentifier -> ShowS # show :: CIdentifier -> String # showList :: [CIdentifier] -> ShowS #
IsString CIdentifier Source #
Instance details Defined in Language.C.Types.Parse Methods fromString :: String -> CIdentifier #
Pretty CIdentifier Source #
Instance details Defined in Language.C.Types.Parse Methods pretty :: CIdentifier -> Doc # prettyList :: [CIdentifier] -> Doc #
Hashable CIdentifier Source #
Instance details Defined in Language.C.Types.Parse Methods hashWithSalt :: Int -> CIdentifier -> Int # hash :: CIdentifier -> Int #

unCIdentifier :: CIdentifier -> String Source #

cIdentifierFromString :: Bool -> String -> Either String CIdentifier Source #

cCParserContext :: Bool -> TypeNames -> CParserContext CIdentifier Source #

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) Source #

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 Source #

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 Source #

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_ Source #

Arguments

:: Bool
-> 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 Source #

data DeclarationSpecifier Source #

Constructors

StorageClassSpecifier StorageClassSpecifier
TypeSpecifier TypeSpecifier
TypeQualifier TypeQualifier
FunctionSpecifier FunctionSpecifier

Instances

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

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

data StorageClassSpecifier Source #

Constructors

TYPEDEF
EXTERN
STATIC
AUTO
REGISTER

Instances

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

storage_class_specifier :: CParser i m => m StorageClassSpecifier Source #

data TypeSpecifier Source #

Instances

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

type_specifier :: CParser i m => m TypeSpecifier Source #

data TypeQualifier Source #

Constructors

CONST
RESTRICT
VOLATILE

Instances

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

type_qualifier :: CParser i m => m TypeQualifier Source #

data FunctionSpecifier Source #

Constructors

INLINE

Instances

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

function_specifier :: CParser i m => m FunctionSpecifier Source #

data Declarator i Source #

Constructors

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

Instances

Functor Declarator Source #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> Declarator a -> Declarator b # (<$) :: a -> Declarator b -> Declarator a #
Foldable Declarator Source #
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 Source #
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) Source #
Instance details Defined in Language.C.Types.Parse Methods (==) :: Declarator i -> Declarator i -> Bool # (/=) :: Declarator i -> Declarator i -> Bool #
Show i => Show (Declarator i) Source #
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) Source #
Instance details Defined in Language.C.Types.Parse Methods pretty :: Declarator i -> Doc # prettyList :: [Declarator i] -> Doc #

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

data DirectDeclarator i Source #

Constructors

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

Instances

Functor DirectDeclarator Source #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> DirectDeclarator a -> DirectDeclarator b # (<$) :: a -> DirectDeclarator b -> DirectDeclarator a #
Foldable DirectDeclarator Source #
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 Source #
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) Source #
Instance details Defined in Language.C.Types.Parse Methods (==) :: DirectDeclarator i -> DirectDeclarator i -> Bool # (/=) :: DirectDeclarator i -> DirectDeclarator i -> Bool #
Show i => Show (DirectDeclarator i) Source #
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) Source #
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) Source #

data ArrayOrProto i Source #

Constructors

Array (ArrayType i)
Proto [ParameterDeclaration i]

Instances

Functor ArrayOrProto Source #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> ArrayOrProto a -> ArrayOrProto b # (<$) :: a -> ArrayOrProto b -> ArrayOrProto a #
Foldable ArrayOrProto Source #
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 Source #
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) Source #
Instance details Defined in Language.C.Types.Parse Methods (==) :: ArrayOrProto i -> ArrayOrProto i -> Bool # (/=) :: ArrayOrProto i -> ArrayOrProto i -> Bool #
Show i => Show (ArrayOrProto i) Source #
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) Source #
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) Source #

data ArrayType i Source #

Constructors

VariablySized
Unsized
SizedByInteger Integer
SizedByIdentifier i

Instances

Functor ArrayType Source #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> ArrayType a -> ArrayType b # (<$) :: a -> ArrayType b -> ArrayType a #
Foldable ArrayType Source #
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 Source #
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) Source #
Instance details Defined in Language.C.Types.Parse Methods (==) :: ArrayType i -> ArrayType i -> Bool # (/=) :: ArrayType i -> ArrayType i -> Bool #
Show i => Show (ArrayType i) Source #
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) Source #
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) Source #

data Pointer Source #

Constructors

Pointer [TypeQualifier]

Instances

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

pointer :: CParser i m => m Pointer Source #

data ParameterDeclaration i Source #

Constructors

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

Instances

Functor ParameterDeclaration Source #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> ParameterDeclaration a -> ParameterDeclaration b # (<$) :: a -> ParameterDeclaration b -> ParameterDeclaration a #
Foldable ParameterDeclaration Source #
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 Source #
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) Source #
Instance details Defined in Language.C.Types.Parse Methods (==) :: ParameterDeclaration i -> ParameterDeclaration i -> Bool # (/=) :: ParameterDeclaration i -> ParameterDeclaration i -> Bool #
Show i => Show (ParameterDeclaration i) Source #
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) Source #
Instance details Defined in Language.C.Types.Parse Methods pretty :: ParameterDeclaration i -> Doc # prettyList :: [ParameterDeclaration i] -> Doc #

data DeclaratorOrAbstractDeclarator i Source #

Constructors

IsDeclarator (Declarator i)
IsAbstractDeclarator (AbstractDeclarator i)

Instances

Functor DeclaratorOrAbstractDeclarator Source #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> DeclaratorOrAbstractDeclarator a -> DeclaratorOrAbstractDeclarator b # (<$) :: a -> DeclaratorOrAbstractDeclarator b -> DeclaratorOrAbstractDeclarator a #
Foldable DeclaratorOrAbstractDeclarator Source #
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 Source #
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) Source #
Instance details Defined in Language.C.Types.Parse Methods (==) :: DeclaratorOrAbstractDeclarator i -> DeclaratorOrAbstractDeclarator i -> Bool # (/=) :: DeclaratorOrAbstractDeclarator i -> DeclaratorOrAbstractDeclarator i -> Bool #
Show i => Show (DeclaratorOrAbstractDeclarator i) Source #
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) Source #

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

data AbstractDeclarator i Source #

Constructors

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

Instances

Functor AbstractDeclarator Source #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> AbstractDeclarator a -> AbstractDeclarator b # (<$) :: a -> AbstractDeclarator b -> AbstractDeclarator a #
Foldable AbstractDeclarator Source #
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 Source #
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) Source #
Instance details Defined in Language.C.Types.Parse Methods (==) :: AbstractDeclarator i -> AbstractDeclarator i -> Bool # (/=) :: AbstractDeclarator i -> AbstractDeclarator i -> Bool #
Show i => Show (AbstractDeclarator i) Source #
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) Source #
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) Source #

data DirectAbstractDeclarator i Source #

Constructors

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

Instances

Functor DirectAbstractDeclarator Source #
Instance details Defined in Language.C.Types.Parse Methods fmap :: (a -> b) -> DirectAbstractDeclarator a -> DirectAbstractDeclarator b # (<$) :: a -> DirectAbstractDeclarator b -> DirectAbstractDeclarator a #
Foldable DirectAbstractDeclarator Source #
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 Source #
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) Source #
Instance details Defined in Language.C.Types.Parse Methods (==) :: DirectAbstractDeclarator i -> DirectAbstractDeclarator i -> Bool # (/=) :: DirectAbstractDeclarator i -> DirectAbstractDeclarator i -> Bool #
Show i => Show (DirectAbstractDeclarator i) Source #
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) Source #
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) Source #

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] Source #

cIdentLetter :: [Char] Source #

cReservedWords :: HashSet String Source #

isTypeName :: Bool -> TypeNames -> String -> Bool Source #

VOID
BOOL
CHAR
SHORT
INT
LONG
FLOAT
DOUBLE
SIGNED
UNSIGNED
Struct CIdentifier
Enum CIdentifier
TypeName CIdentifier
Template CIdentifier [TypeSpecifier]
TemplateConst String