Safe Haskell | None |
---|---|
Language | Haskell2010 |
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
(wherex
is a C identifier). In C99 they can be arbitrary expressions. See the
data type.ArrayType
_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
- type CParser m = (Monad m, Functor m, Applicative m, MonadPlus m, Parsing m, CharParsing m, TokenParsing m, LookAheadParsing m, MonadReader IsTypeName m)
- type IsTypeName = Identifier -> Bool
- runCParser :: Stream s Identity Char => IsTypeName -> String -> s -> ReaderT IsTypeName (Parsec s ()) a -> Either ParseError a
- quickCParser :: IsTypeName -> String -> ReaderT IsTypeName (Parsec String ()) a -> a
- quickCParser_ :: String -> ReaderT IsTypeName (Parsec String ()) a -> a
- newtype Identifier = Identifier {}
- identifier :: CParser m => m Identifier
- identifier_no_lex :: CParser m => m Identifier
- data DeclarationSpecifier
- declaration_specifiers :: forall m. CParser m => m [DeclarationSpecifier]
- data StorageClassSpecifier
- storage_class_specifier :: CParser m => m StorageClassSpecifier
- data TypeSpecifier
- = VOID
- | CHAR
- | SHORT
- | INT
- | LONG
- | FLOAT
- | DOUBLE
- | SIGNED
- | UNSIGNED
- | Struct Identifier
- | Enum Identifier
- | TypeName Identifier
- type_specifier :: CParser m => m TypeSpecifier
- data TypeQualifier
- type_qualifier :: CParser m => m TypeQualifier
- data FunctionSpecifier = INLINE
- function_specifier :: CParser m => m FunctionSpecifier
- data Declarator = Declarator {}
- declarator :: CParser m => m Declarator
- data DirectDeclarator
- direct_declarator :: CParser m => m DirectDeclarator
- data ArrayOrProto
- array_or_proto :: CParser m => m ArrayOrProto
- data ArrayType
- array_type :: CParser m => m ArrayType
- data Pointer = Pointer [TypeQualifier]
- pointer :: CParser m => m Pointer
- data ParameterDeclaration = ParameterDeclaration {}
- parameter_declaration :: CParser m => m ParameterDeclaration
- parameter_list :: CParser m => m [ParameterDeclaration]
- data AbstractDeclarator = AbstractDeclarator {}
- abstract_declarator :: CParser m => m AbstractDeclarator
- data DirectAbstractDeclarator
- direct_abstract_declarator :: CParser m => m DirectAbstractDeclarator
- data ParameterDeclarationWithTypeNames = ParameterDeclarationWithTypeNames {}
Parser type
type CParser m = (Monad m, Functor m, Applicative m, MonadPlus m, Parsing m, CharParsing m, TokenParsing m, LookAheadParsing m, MonadReader IsTypeName m) 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
.
The MonadReader
with IsTypeName
is required for parsing C, see
http://en.wikipedia.org/wiki/The_lexer_hack.
type IsTypeName = Identifier -> Bool Source
Function used to determine whether an Id
is a type name.
:: Stream s Identity Char | |
=> IsTypeName | Function determining if an identifier is a type name. |
-> String | Source name. |
-> s | String to parse. |
-> ReaderT IsTypeName (Parsec s ()) a | Parser. Anything with type |
-> Either ParseError a |
Runs a
using CParser
parsec
.
:: IsTypeName | Function determining if an identifier is a type name. |
-> String | String to parse. |
-> ReaderT IsTypeName (Parsec String ()) a | Parser. Anything with type |
-> a |
Useful for quick testing. Uses "quickCParser"
as source name, and throws
an error
if parsing fails.
:: String | String to parse. |
-> ReaderT IsTypeName (Parsec String ()) a | Parser. Anything with type |
-> a |
Like quickCParser
, but uses
as const
False
IsTypeName
.
Types and parsing
newtype Identifier Source
identifier :: CParser m => m Identifier Source
identifier_no_lex :: CParser m => m Identifier Source
This parser parses an Id
and nothing else -- it does not consume
trailing spaces and the like.
declaration_specifiers :: forall m. CParser m => m [DeclarationSpecifier] Source
data TypeSpecifier Source
type_specifier :: CParser m => m TypeSpecifier Source
data TypeQualifier Source
type_qualifier :: CParser m => m TypeQualifier Source
data FunctionSpecifier Source
function_specifier :: CParser m => m FunctionSpecifier Source
data Declarator Source
declarator :: CParser m => m Declarator Source
data DirectDeclarator Source
direct_declarator :: CParser m => m DirectDeclarator Source
data ArrayOrProto Source
array_or_proto :: CParser m => m ArrayOrProto Source
array_type :: CParser m => m ArrayType Source
parameter_list :: CParser m => m [ParameterDeclaration] Source
abstract_declarator :: CParser m => m AbstractDeclarator 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
data ParameterDeclarationWithTypeNames Source
Type used to generate an Arbitrary
ParameterDeclaration
with
arbitrary allowed type names.