h*0# %       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        0.9.4'(c) [1995..1999] Manuel M. T. Chakravarty (c) 2008 Benedikt Huber BSD-stylebenedikt.huber@gmail.comalphaportable Safe-Inferred7<#  language-cNameSpaceMap a is a Map from identifiers to a., which manages global and local name spaces. language-ccreate a name space language-cAdd global definition%(ns',oldDef) = defGlobal ns ident def adds a global definition  ident := def8 to the namespace. It returns the modified namespace ns'. If the identifier is already declared in the global namespace, the definition is overwritten and the old definition oldDef is returned. language-cEnter new local scopens' = enterNewScope ns& creates and enters a new local scope. language-cLeave innermost local scope(ns',defs) = leaveScope ns pops leaves the innermost local scope. and returns its definitions language-cAdd local definition$(ns',oldDef) = defLocal ns ident def adds the local definition  ident := def to the innermost local scope, if there is a local scope, and to the global scope otherwise. It returns the modified name space ns'+ and the old binding of the identifier oldDef, which is overwritten.  language-cSearch for a definitiondef = find ns ident returns the definition in some scope (inner to outer), if there is one.  language-c%flatten a namespace into a assoc list nameSpaceToList ns = (localDefInnermost ns ++ .. ++ localDefsOutermost ns) ++ globalDefs ns  language-cMerge two namespaces. If they disagree on the types of any variables, all bets are off.    (c) 2008,2011 Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalghc Safe-Inferred7<&, language-c(b,is') = takeByte is# reads and removes the first byte b from the  is language-c(c,is') = takeChar is( reads and removes the first character c from the  is language-creturn True# if the given input stream is empty language-cstr = takeChars n is returns the first n= characters of the given input stream, without removing them language-cread a file into an  language-cconvert  to   language-c convert a   to an  language-c countLines1 returns the number of text lines in the given   (c) 2008 Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalghc Safe-Inferred7<' language-cName is a unique identifier language-creturn an infinite stream of s starting with nameId 0 language-cget the infinite stream of unique names starting from the given integer(c) [1995..2000] Manuel M. T. Chakravarty [2008..2009] Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalghc Safe-Inferred7<.% language-c4class of type which aggregate a source code location' language-cPosition and length of a token( language-c/uniform representation of source file positions) language-c(absolute offset in the preprocessed file* language-c:: (column ) [] >>> ...  language-c=raise a fatal internal error; message may have multiple lines~}|~}| (c) 2008 Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalghc Safe-Inferred7<><bcdel`fkgji(*+),-%&/135046GIHEFNMLQSUP|~}*bcdel`fkgji(*+),-%&/135046GIHEFNMLQSUP!.(c) [2007..2008] Duncan Coutts, Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalghc Safe-Inferred7<?^  5"!(c) 2001 Manuel M. T. Chakravarty BSD-stylebenedikt.huber@gmail.comportable Safe-Inferred7<? ,(c) 2007..2008 Duncan Coutts, Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalghc Safe-Inferred7<H language-cC String literals language-cClang dotted version literal https://clang.llvm.org/docs/AttributeReference.html#availability language-cFloats (represented as strings) language-c-datatype representing type flags for integers language-c8datatype for memorizing the representation of an integer language-cC char constants (abstract) language-cshowCharConst c prepends _a_ String representing the C char constant corresponding to c;. If necessary uses octal or hexadecimal escape sequences. language-c1get the haskell representation of a char constant language-cget integer value of a C char constant undefined result for multi-char char constants language-creturn true if the character constant is wide. language-c.construct a character constant from a haskell   Use cchar_w' if you want a wide character constant. language-c%construct a wide chararacter constant language-c+create a multi-character character constant language-cconstruct a integer constant (without type flags) from a haskell integer language-c'concatenate a list of C string literals language-cshowStringLiteral s prepends a String representing the C string literal corresponding to s>. If necessary it uses octal or hexadecimal escape sequences.  language-cisAsciiSourceChar b returns True if the given character is a character which may appear in a ASCII C source file and is printable.  language-c isCChar c returns true, if c is a source character which does not have to be escaped in C char constants (C99: 6.4.4.4)  language-c escapeCChar c% escapes c for use in a char constant  language-c isSChar c returns true if c is a source character which does not have to be escaped in C string literals (C99: 6.4.5)//#[1999..2004] Manuel M T Chakravarty 2005 Duncan Coutts BSD-stylebenedikt.huber@gmail.com%portable C Tokens for the C lexer. Safe-Inferred7<I $(c) [1999..2004] Manuel M T Chakravarty (c) 2005-2007 Duncan Coutts BSD-stylebenedikt.huber@gmail.comportable Safe-Inferred7<L language-cexecute the given parser on the supplied input stream. returns  if the parser failed, and a pair of result and remaining name supply otherwise Synopsis: execParser parser inputStream initialPos predefinedTypedefs uniqNameSupply  language-c setLastToken modifyCache tok  language-c0handle an End-Of-File token (changes savedToken) % Safe-Inferred 7<M   (c) 2008 Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalghc Safe-Inferred7<Qe language-cC unary operator (K&R A7.3-4) language-cprefix increment operator language-cprefix decrement operator language-cpostfix increment operator language-cpostfix decrement operator language-caddress operator language-cindirection operator language-c prefix plus language-c prefix minus language-cone's complement language-clogical negation language-c C binary operators (K&R A7.6-15) language-cremainder of division language-c shift left language-c shift right language-cless language-cgreater language-c less or equal language-cgreater or equal language-cequal language-c not equal language-c bitwise and language-cexclusive bitwise or language-cinclusive bitwise or language-c logical and language-c logical or language-c"C assignment operators (K&R A7.17) language-cremainder and assignment00 (c) [1999..2007] Manuel M T Chakravarty (c) 2008 Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalghc Safe-Inferred 7<$ language-cAll AST nodes are annotated. Inspired by the Annotated class of Niklas Broberg's haskell-src-exts package. In principle, we could have Copointed superclass instead of ann&, for the price of another dependency. language-c!get the annotation of an AST node language-cchange the annotation (non-recursively) of an AST node. Use fmap for recursively modifying the annotation. language-cAttributed string literals language-cC constant (K&R A2.5 & A7.2) language-c  (expr, type) language-c (type, designator-list) language-c  (type,type) language-c  (expr, type) language-c  (type, expr) language-c*GNU Builtins, which cannot be typed in C99 language-c7integer, character, floating point and string constants language-cC99 compound literal language-cC11 generic selection language-c GNU C compound statement as expr language-cGNU C address of label language-cbuiltin expressions, see  language-cC expression (K&R A7)6these can be arbitrary expression, as the argument of sizeof can be arbitrary, even if appearing in a constant expressionGNU C extensions: alignof, __real, __imag, ({ stmt-expr }), && label and built-ins language-c attribute annotationsThose are of the form )CAttr attribute-name attribute-parameters, and serve as generic properties of some syntax tree elements. language-carray position designator language-cmember designator language-carray range designator CRangeDesig from to _ (GNU C) language-c DesignatorsA designator specifies a member of an object, either an element or range of an array, or the named member of a struct / union. language-cInitializer List3The members of an initializer list are of the form (designator-list,initializer). The designator-list specifies one member of the compound type which is initialized. It is allowed to be empty - in this case the initializer refers to the 'next'- member of the compound type (see C99 6.7.8).2Examples (simplified expressions and identifiers): -- int x[3][4] = { [0][3] = 4, [2] = 5, 8 }; -- corresponds to the assignments -- x[0][3] = 4; x[2][0] = 5; x[2][1] = 8; let init1 = ([CArrDesig 0, CArrDesig 3], CInitExpr 4) init2 = ([CArrDesig 2] , CInitExpr 5) init3 = ([] , CInitExpr 8) in CInitList [init1, init2, init3] -- struct { struct { int a[2]; int b[2]; int c[2]; } s; } x = { .s = { {2,3} , .c[0] = 1 } }; -- corresponds to the assignments -- x.s.a[0] = 2; x.s.a[1] = 3; x.s.c[0] = 1; let init_s_0 = CInitList [ ([], CInitExpr 2), ([], CInitExpr 3)] init_s = CInitList [ ([], init_s_0), ([CMemberDesig "c", CArrDesig 0], CInitExpr 1) ] in CInitList [(CMemberDesig "s", init_s)] language-cassignment expression language-cinitialization list (see ) language-c&C initialization (K&R A8.7, C99 6.7.8)Initializers are either assignment expressions or initializer lists (surrounded in curly braces), whose elements are themselves initializers, paired with an optional list of designators. language-c/C enumeration specifier (K&R A8.4, C99 6.7.2.2)&CEnum identifier enumerator-list attrs represent as enum specifierEither the identifier or the enumerator-list (or both) have to be present.If enumerator-list$ is present, it has to be non-empty.#The enumerator list is of the form *(enumeration-constant, enumeration-value?), where the latter is an optional constant integral expression.attrs is a list of  attribute6 annotations associated with the enumeration specifier language-c(A tag to determine wheter we refer to a struct or union, see . language-c7C structure or union specifiers (K&R A8.3, C99 6.7.2.1)+CStruct tag identifier struct-decls c-attrs6 represents a struct or union specifier (depending on tag).either  identifier or the declaration list  struct-decls (or both) have to be present. Example: in  struct foo x; , the identifier is present, in struct { int y; } x# the declaration list, and in struct foo { int y; } x; both of them.c-attrs is a list of  attribute: annotations associated with the struct or union specifier language-c _Alignas(type) language-c _Alignas(expr) language-c"C alignment specifiers (C99 6.7.5) language-c!C function specifiers (C99 6.7.4)function specifiers inline and  _Noreturn language-c7C type qualifiers (K&R A8.2, C99 6.7.3) and attributes.const, volatile and restrict type qualifiers Additionally,  attribute annotations for declarations and declarators, and function specifiers language-c+IEC 60227: width (32,64,128), extended flag language-cStruct or Union specifier language-cEnumeration specifier language-c Typedef name language-c  typeof(expr) language-c  typeof(type) language-c  _Atomic(type) language-c&C type specifier (K&R A8.2, C99 6.7.2)/Type specifiers are either basic types such as char or int, struct, union or enum specifiers or typedef names.As a GNU extension, a typeof% expression also is a type specifier. language-cauto language-cregister language-cstatic language-cextern language-ctypedef language-cC11/GNUC thread local storage language-cOpenCL kernel function language-cOpenCL __global variable language-cOpenCL __local variable language-c>C storage class specifier (and typedefs) (K&R A8.1, C99 6.7.1) language-c"storage-class specifier or typedef language-c type name language-ctype qualifier language-cfunction specifier language-calignment specifier language-c'C declaration specifiers and qualifiersDeclaration specifiers include at most one storage-class specifier (C99 6.7.1), type specifiers (6.7.2) and type qualifiers (6.7.3). language-c A statement language-cA local declaration language-cA nested function (GNU C) language-cC99 Block itemsThings that may appear in compound statements: either statements, declarations or nested function definitions. language-cAssembler operand'CAsmOperand argName? constraintExpr arg2 specifies an operand for an assembler statement. language-cGNU Assembler statement CAssemblyStatement type-qual? asm-expr out-ops in-ops clobbers _is an inline assembler statement. The only type-qualifier (if any) allowed is volatile. asm-expr0 is the actual assembler epxression (a string), out-ops and in-ops7 are the input and output operands of the statement. clobbers is a list of registers which are clobbered when executing the assembler statement language-c-An (attributed) label followed by a statement language-cA statement of the form case expr : stmt language-cA case range of the form case lower ... upper : stmt language-cThe default case default : stmt language-cA simple statement, that is in C: evaluating an expression with side-effects and discarding the result. language-ccompound statement #CCompound localLabels blockItems at language-cconditional statement $CIf ifExpr thenStmt maybeElseStmt at language-cswitch statement CSwitch selectorExpr switchStmt , where  switchStmt usually includes case, break and default statements language-cwhile or do-while statement CWhile guard stmt isDoWhile at language-cfor statement CFor init expr-2 expr-3 stmt, where init4 is either a declaration or initializing expression language-cgoto statement  CGoto label language-ccomputed goto CGotoPtr labelExpr language-ccontinue statement language-cbreak statement language-creturn statement CReturn returnExpr language-cassembly statement language-cC statement (K&R A9, C99 6.8) language-c CUnknownSize isCompleteType language-c CArrSize isStatic expr language-cSize of an array language-cPointer declarator CPtrDeclr tyquals declr language-cArray declarator "CArrDeclr declr tyquals size-expr? language-cFunction declarator =CFunDeclr declr (old-style-params | new-style-params) c-attrs language-cDerived declarators, see Indirections are qualified using type-qualifiers and generic attributes, and additionallyThe size of an array is either a constant expression, variable length ( ) or missing; in the last case, the type of the array is incomplete. The qualifier static is allowed for function arguments only, indicating that the supplied argument is an array of at least the given size.(New style parameter lists have the form  Right (declarations, isVariadic)0, old style parameter lists have the form Left (parameter-names) language-cC declarator (K&R A8.5, C99 6.7.5) and abstract declarator (K&R A8.8, C99 6.7.6)A declarator declares a single object, function, or type. It is always associated with a declaration (), which specifies the declaration's type and the additional storage qualifiers and attributes, which apply to the declared object.A declarator is of the form +CDeclr name? indirections asm-name? attrs _ , where name is the name of the declared object (missing for abstract declarators),  declquals1 is a set of additional declaration specifiers, asm-name is the optional assembler name and attributes is a set of attrs is a set of  attribute% annotations for the declared object. indirections is a set of pointer, array and function declarators, which modify the type of the declared object as described below. If the  declaration specifies the non-derived type T, and we have  indirections = [D1, D2, ..., Dn]$ than the declared object has type (D1 indirect (D2 indirect ... (Dn indirect T))), where(CPtrDeclr attrs) indirect T is attributed pointer to T(CFunDeclr attrs) indirect T is attributed function returning T(CArrayDeclr attrs) indirect T is (attributed array of elemements of type T!Examples (simplified attributes):x is an int int x; CDeclr "x" []x0 is a restrict pointer to a const pointer to int const int * const * restrict x; CDeclr "x" [CPtrDeclr [restrict], CPtrDeclr [const]]f0 is an function return a constant pointer to int ;int* const f(); CDeclr "f" [CFunDeclr [],CPtrDeclr [const]]f2 is a constant pointer to a function returning int int (* const f)(); ==> CDeclr "f" [CPtrDeclr [const], CFunDeclr []] language-cC declarations (K&R A8, C99 6.7), including structure declarations, parameter declarations and type names.A declaration is of the form %CDecl specifiers init-declarator-list, where the form of the declarator list's elements depends on the kind of declaration:61) Toplevel declarations (K&R A8, C99 6.7 declaration)C99 requires that there is at least one specifier, though this is merely a syntactic restriction>at most one storage class specifier is allowed per declarationthe elements of the non-empty init-declarator-list are of the form (Just declr, init?, Nothing). The declarator declr has to be present and non-abstract and the initialization expression is optional.2) Structure declarations (K&R A8.3, C99 6.7.2.1 struct-declaration)4Those are the declarations of a structure's members.do not allow storage specifiers:in strict C99, the list of declarators has to be non-emptythe elements of init-declarator-list are either of the form (Just declr, Nothing, size?), representing a member with optional bit-field size, or of the form (Nothing, Nothing, Just size), for unnamed bitfields. declr has to be non-abstract.3no member of a structure shall have incomplete type3) Parameter declarations (K&R A8.6.3, C99 6.7.5 parameter-declaration)init-declarator-list- must contain at most one triple of the form (Just declr, Nothing, Nothing), i.e. consist of a single declarator, which is allowed to be abstract (i.e. unnamed).4) Type names (A8.8, C99 6.7.6)do not allow storage specifiersinit-declarator-list- must contain at most one triple of the form (Just declr, Nothing, Nothing) . where declr is an abstract declarator (i.e. doesn't contain a declared identifier) language-c,C function definition (C99 6.9.1, K&R A10.1)%A function definition is of the form ,CFunDef specifiers declarator decllist? stmt. specifiers are the type and storage-class specifiers of the function. The only storage-class specifiers allowed are extern and static.The  declarator/ must be such that the declared identifier has  function type. The return type shall be void or an object type other than array type.The optional declaration list decllist( is for old-style function declarations.The statement stmt is a compound statement. language-c)External C declaration (C99 6.9, K&R A10)Either a toplevel declaration, function definition or external assembler. language-c.Complete C tranlsation unit (C99 6.9, K&R A10)A complete C translation unit, for example representing a C header or source file. It consists of a list of external (i.e. toplevel) declarations. language-c#Separate the declaration specifiers attribute of a declaration qualify declarations or declarators (but not types), and are therefore separated as well. language-creturns True2 if the given typespec is a struct, union or enum  definition language-c%Lift a string literal to a C constant&(c) 2008 Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalghc Safe-Inferred7</ Copyright (c) 2007 Bertram Felgenhauer (c) 2008 Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalportable Safe-Inferred 7<v language-c,A class of types which can be pretty printed language-cpretty print the given value language-cprettyPrec prec p pretty prints p assuming that the surrounding context has a precedence of prec language-cPretty print the given tranlation unit, but replace declarations from header files with #include directives.7The resulting file may not compile (because of missing #define directives and similar things), but is very useful for testing, as otherwise the pretty printed file will be cluttered with declarations from system headers.' Safe-Inferred 7< language-cparseC input initialPos parses the given preprocessed C-source input and returns the AST or a list of parse errors. language-c translUnitP provides a parser for a complete C translation unit, i.e. a list of external declarations. language-cextDeclP; provides a parser for an external (file-scope) declaration language-c statementP# provides a parser for C statements language-c expressionP$ provides a parser for C expressions 9  9 (c) 2008 Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalghc Safe-Inferred7< language-crun the given parser using a new name supply and builtin typedefs see  Synopsis: 'runParser parser inputStream initialPos   (c) 2008 Benedikt Huber BSD-stylebenedikt.huber@gmail.comalphaghc Safe-Inferred7< language-c is currently an alias for  (Syntax) language-c is an alias for  (Syntax) language-c attribute annotationsThose are of the form (Attr attribute-name attribute-parameters, and serve as generic properties of some syntax tree elements.Some examples:labels can be attributed with unused to indicate that their not used*struct definitions can be attributed with packed< to tell the compiler to use the most compact representation$declarations can be attributed with  deprecated-function declarations can be attributes with noreturn: to tell the compiler that the function will never return,or with const' to indicate that it is a pure functionTODO: ultimatively, we want to parse attributes and represent them in a typed way language-cAssembler name (alias for CStrLit) language-c%Top level assembler block (alias for CStrLit) language-cVarName name assembler-name is a name of an declared object language-c is currently an alias for .We're planning a normalized representation, but this depends on the implementation of constant expression evaluation language-c0Type qualifiers: constant, volatile and restrict language-cAn Enumerator consists of an identifier, a constant expressions and the link to its type language-c%Representation of C enumeration types language-c .EnumType name enumeration-constants attrs node language-c(a tag to determine wheter we refer to a struct or union, see . language-c!Composite type (struct or union). language-ccomposite type declarations language-c!floating point type (C99 6.7.2.2) language-cintegral types (C99 6.7.2.2) language-ctypdef references If the actual type is known, it is attached for convenience language-c Builtin type (va_list, anything) language-cnormalized type representation language-cAn array type may either have unknown size or a specified array size, the latter either variable or constant. Furthermore, when used as a function parameters, the size may be qualified as static. In a function prototype, the size may be `Unspecified variable size' ([*]). language-c UnknownArraySize is-starred language-c "FixedSizeArray is-static size-expr language-cFunction types are of the form %FunType return-type params isVariadic.?If the parameter types aren't yet known, the function has type FunTypeIncomplete type attrs. language-ctypes of C objects language-ca non-derived type language-c pointer type language-c array type language-c function type language-ca defined type language-cLinkage: Either no linkage, internal to the translation unit or external language-c*Storage duration and linkage of a variable language-c no storage language-c&automatic storage (optional: register) language-c?static storage, linkage spec and thread local specifier (gnu c) language-c-function, either internal or external linkage language-c#Declaration attributes of the form 0DeclAttrs isInlineFunction storage linkage attrs:They specify the storage and linkage of a declared object. language-c DeclAttrs fspecs storage attrs language-cGeneric variable declarations language-ctypedef definitions.0The identifier is a new name for the given type. language-cStruct/Union member declaration language-c $MemberDecl vardecl bitfieldsize node language-c AnonBitField typ size language-cParameter declaration language-cFunction definitionsA function definition is a declaration together with a statement (the function body). language-cObject DefinitionsAn object definition is a declaration together with an initializer.If the initializer is missing, it is a tentative definition, i.e. a definition which might be overriden later on. language-c&Declarations, which aren't definitions language-cDeclaration eventsThose events are reported to callbacks, which are executed during the traversal. language-c"file-scope struct/union/enum event language-c$file-scope declaration or definition language-cparameter declaration language-c(local variable declaration or definition language-ca type definition language-cassembler block language-chandle a function-scope object declaration / definition see [ http://www.sivity.net/projects/language.c/wiki/LocalDefinitions]  language-cGiven a context, determine the type declaration for the enclosing function, if possible, given a context.  language-cTypecheck a statement, given a statement context. The type of a statement is usually void, but expression statements and blocks can sometimes have other types.  language-cTypecheck a block item. When statement expressions are blocks, they have the type of their last expression statement, so this needs to return a type.  language-cTypecheck an expression, with information about whether it appears as an lvalue or an rvalue.  language-cReturn the type of a builtin.  ((c) 2008 Benedikt Huber BSD-stylebenedikt.huber@gmail.comalphaghc Safe-Inferred7< (c) 2008 Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalportable Safe-Inferred7<  language-c&Generic arguments for the preprocessor  language-c$Generic Options for the preprocessor  language-c  encapsulates the abstract interface for invoking C preprocessors  language-cparse the given command line arguments, and return a pair of parsed and ignored arguments  language-crun the preprocessor  language-c%file extension of a preprocessed file  language-c4Cpp arguments that only specify the input file name.  language-c;use the given preprocessor arguments without analyzing them  language-c6add a typed option to the given preprocessor arguments  language-c7add a string option to the given preprocessor arguments  language-c#run the preprocessor and return an  if preprocesssing succeeded  language-ccreate an output file, given  Maybe tmpdir and  inputfile  language-c-compute output file name from input file name  language-ccreate a temporary file  language-c7guess whether a file is preprocessed (file end with .i)  (c) 2008 Benedikt Huber BSD-stylebenedikt.huber@gmail.com experimentalportable Safe-Inferred7<-  language-cGCC+ represents a reference to the gcc compiler  language-ccreate a reference to gcc  language-cParse arguments for preprocessing via GCC. At least one .c, .hc or .h file has to be present. For now we only support the most important gcc options.1) Parse all flags relevant to CppArgs 2) Move -c,-S,-M? to other_args 3) Strip -E 4) The rest goes into extra_args  (c) 2008 Benedikt Huber [1995..2007] Manuel M. T. Chakravarty Duncan Coutts Betram Felgenhauer BSD-stylebenedikt.huber@gmail.com experimentalghc Safe-Inferred7<s  language-c3preprocess (if necessary) and parse a C source file Synopsis: parseCFile preprocesssor tmp-dir? cpp-opts file Example: parseCFile (newGCC "gcc") Nothing ["-I/usr/include/gtk-2.0"] my-gtk-exts.c  language-c$parse an already preprocessed C file Synopsis: parseCFilePre file.i `|bcd(*+)%&GIHEF~}elfkgji,-/135046NMLQSUP )*+,-./0123456789:;<=>?@@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopoqrstuvwxyz{|}~"                                                                                                $$$$                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   '''''                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ! ! ! ! ! ! ! ! ! ! ! !  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # $ $ $ $ $ $ $ $ $0$ $ $ $ $ $ $ % % ' '                              'language-c-0.9.4-9yWFXod72jo4EfM9VWrwhH Language.C.Analysis.NameSpaceMapLanguage.C.Data.InputStreamLanguage.C.Data.NameLanguage.C.Data.PositionLanguage.C.Data.NodeLanguage.C.Data.IdentLanguage.C.Data.ErrorLanguage.C.ParserLanguage.C.Syntax.ConstantsLanguage.C.Syntax.OpsLanguage.C.Syntax.ASTLanguage.C.PrettyLanguage.C.Analysis.SemRep#Language.C.Analysis.TypeConversionsLanguage.C.Analysis.SemErrorLanguage.C.Analysis.DefTableLanguage.C.Analysis.TypeUtilsLanguage.C.Analysis.BuiltinsLanguage.C.Analysis.TravMonadLanguage.C.Analysis.ExportLanguage.C.Analysis.DebugLanguage.C.Analysis.TypeCheckLanguage.C.Syntax.UtilsLanguage.C.Analysis.AstAnalysis Language.C.Analysis.DeclAnalysisLanguage.C.Analysis.ConstEval Language.C.Analysis.MachineDescsLanguage.C.System.PreprocessLanguage.C.System.GCC Language.C language-cLanguage.C.DataLanguage.C.Data.RListLanguage.C.Parser.BuiltinLanguage.C.Parser.TokensLanguage.C.Parser.ParserMonadLanguage.C.Parser.LexerLanguage.C.SyntaxLanguage.C.Parser.ParserLanguage.C.Analysis NameSpaceMap globalNames hasLocalNames localNames nameSpaceMap defGlobal enterNewScope leaveScopedefLocal lookupName lookupGloballookupInnermostScope nsMapToListmergeNameSpace InputStreamtakeBytetakeCharinputStreamEmpty takeCharsreadInputStreaminputStreamToStringinputStreamFromString countLinesNamenameId newNameSupplynamesStartingFrom $fEnumName $fNFDataName $fShowName $fReadName$fEqName $fOrdName$fIxName $fDataName $fGenericNamePosposOf PosLengthPosition posOffsetposRow posColumnposFile posParentpositioninitPos isSourcePosnoposisNoPos builtinPos isBuiltinPos internalPos isInternalPosincPosretPos incOffset$fShowPosition$fNFDataPosition$fNFDataFilePosition $fEqPosition $fOrdPosition$fDataPosition$fGenericPosition$fEqFilePosition$fOrdFilePosition$fDataFilePosition$fGenericFilePositionCNodenodeInfoNodeInfoOnlyPos lengthOfNodegetLastTokenPos nameOfNode posOfNode fileOfNodeeqByName internalNode undefNode isUndefNodemkNodeInfoOnlyPosmkNodeInfoPosLen mkNodeInfo mkNodeInfo' $fPosNodeInfo$fShowNodeInfo$fNFDataNodeInfo $fCNodeEither$fCNodeNodeInfo$fDataNodeInfo $fEqNodeInfo $fOrdNodeInfo$fGenericNodeInfoIdentSUERef AnonymousRefNamedRefisAnonymousRefmkIdent internalIdentinternalIdentAt builtinIdentisInternalIdent identToStringsueRefToString dumpIdent $fPosIdent $fCNodeIdent $fOrdIdent $fEqIdent $fNFDataIdent$fNFDataSUERef $fDataSUERef $fOrdSUERef $fEqSUERef $fShowSUERef$fGenericSUERef $fDataIdent $fShowIdent$fGenericIdent UserErrorUnsupportedFeatureError errorInfotoError fromErrorchangeErrorLevelCError ErrorInfo ErrorLevel LevelWarn LevelError LevelFatal isHardError mkErrorInfoerrorPos errorLevel errorMsgsunsupportedFeatureunsupportedFeature_userErr showError showErrorInfo internalErr$fShowErrorLevel$fShowErrorInfo $fErrorCError $fShowCError$fErrorErrorInfo$fShowUnsupportedFeature$fErrorUnsupportedFeature$fShowUserError$fErrorUserError$fEqErrorLevel$fOrdErrorLevelbuiltinTypeNamesFlagsCString ClangCVersionCFloatCIntegerCIntFlag FlagUnsignedFlagLong FlagLongLongFlagImagCIntReprDecReprHexRepr OctalReprCCharCChars showCharConstgetCChar getCCharAsInt isWideCharcCharcChar_wcChars readCInteger getCIntegercIntegercFloat readCFloatreadClangCVersioncString cString_w getCStringconcatCStrings showStringLit escapeChar unescapeCharunescapeStringnoFlagssetFlag clearFlagtestFlag $fNFDataCChar $fShowCChar$fNFDataCIntRepr$fNFDataCIntFlag$fShowCIntFlag$fNFDataCFloat $fShowCFloat$fShowClangCVersion$fNFDataCString $fShowCString $fNFDataFlags$fNFDataCInteger$fShowCInteger $fEqCInteger $fOrdCInteger$fDataCInteger$fGenericCInteger $fEqFlags $fOrdFlags $fDataFlags$fGenericFlags$fGeneric1TYPEFlags $fEqCString $fOrdCString $fDataCString$fGenericCString$fEqClangCVersion$fOrdClangCVersion$fDataClangCVersion $fEqCFloat $fOrdCFloat $fDataCFloat$fGenericCFloat $fEqCIntFlag $fOrdCIntFlag$fEnumCIntFlag$fBoundedCIntFlag$fDataCIntFlag$fGenericCIntFlag $fEqCIntRepr $fOrdCIntRepr$fEnumCIntRepr$fBoundedCIntRepr$fDataCIntRepr$fGenericCIntRepr $fEqCChar $fOrdCChar $fDataCChar$fGenericCCharP ParseError execParserCUnaryOp CPreIncOp CPreDecOp CPostIncOp CPostDecOpCAdrOpCIndOpCPlusOpCMinOpCCompOpCNegOp CBinaryOpCMulOpCDivOpCRmdOpCAddOpCSubOpCShlOpCShrOpCLeOpCGrOpCLeqOpCGeqOpCEqOpCNeqOpCAndOpCXorOpCOrOpCLndOpCLorOp CAssignOp CMulAssOp CDivAssOp CRmdAssOp CAddAssOp CSubAssOp CShlAssOp CShrAssOp CAndAssOp CXorAssOpCOrAssOp assignBinopisCmpOpisPtrOpisBitOp isLogicOp isEffectfulOp$fNFDataCAssignOp$fNFDataCBinaryOp$fNFDataCUnaryOp $fEqCUnaryOp $fOrdCUnaryOp$fShowCUnaryOp$fDataCUnaryOp$fGenericCUnaryOp $fEqCBinaryOp$fOrdCBinaryOp$fShowCBinaryOp$fDataCBinaryOp$fGenericCBinaryOp $fEqCAssignOp$fOrdCAssignOp$fShowCAssignOp$fDataCAssignOp$fGenericCAssignOp Annotated annotationamapCStringLiteralCStrLit CConstant CIntConst CCharConst CFloatConst CStrConstCConst CBuiltinThing CBuiltinVaArgCBuiltinOffsetOfCBuiltinTypesCompatibleCBuiltinConvertVectorCBuiltinBitCastCBuiltin CExpressionCCommaCAssignCCondCBinaryCCastCUnary CSizeofExpr CSizeofType CAlignofExpr CAlignofType CComplexReal CComplexImagCIndexCCallCMemberCVar CCompoundLitCGenericSelection CStatExpr CLabAddrExpr CBuiltinExprCExpr CAttributeCAttrCPartDesignator CArrDesig CMemberDesig CRangeDesig CDesignatorCInitializerList CInitList CInitializer CInitExprCInit CEnumerationCEnum CStructTag CUnionTagCStructureUnionCStruct CStructUnionCAlignmentSpecifier CAlignAsType CAlignAsExpr CAlignSpecCFunctionSpecifier CInlineQual CNoreturnQualCFunSpecCTypeQualifier CConstQual CVolatQual CRestrQual CAtomicQual CAttrQual CNullableQual CNonnullQual CClRdOnlyQual CClWrOnlyQual CTypeQualCTypeSpecifier CVoidType CCharType CShortTypeCIntType CLongType CFloatType CDoubleType CSignedType CUnsigType CBoolType CComplexType CInt128Type CUInt128Type CFloatNTypeCSUType CEnumTypeCTypeDef CTypeOfExpr CTypeOfType CAtomicType CTypeSpecCStorageSpecifierCAuto CRegisterCStaticCExternCTypedefCThread CClKernel CClGlobalCClLocal CStorageSpecCDeclarationSpecifier CDeclSpecCCompoundBlockItem CBlockStmt CBlockDecl CNestedFunDef CBlockItemCAssemblyOperand CAsmOperandCAssemblyStatementCAsmStmt CStatementCLabelCCaseCCasesCDefault CCompoundCIfCSwitchCWhileCForCGotoCGotoPtrCContCBreakCReturnCAsmCStat CArraySize CNoArrSizeCArrSizeCDerivedDeclarator CPtrDeclr CArrDeclr CFunDeclr CDerivedDeclr CDeclaratorCDeclr CDeclarationCDecl CStaticAssert CFunctionDefCFunDefCExternalDeclarationCDeclExtCFDefExtCAsmExtCExtDeclCTranslationUnit CTranslUnitpartitionDeclSpecsisSUEDef cstringOfLit liftStrLit$fFunctorCStorageSpecifier$fPosCStorageSpecifier$fCNodeCStorageSpecifier$fNFDataCStorageSpecifier$fFunctorCFunctionSpecifier$fPosCFunctionSpecifier$fCNodeCFunctionSpecifier$fNFDataCFunctionSpecifier$fNFDataCStructTag$fFunctorCConstant$fPosCConstant$fCNodeCConstant$fNFDataCConstant$fFunctorCStringLiteral$fPosCStringLiteral$fCNodeCStringLiteral$fNFDataCStringLiteral$fFunctorCBuiltinThing$fPosCBuiltinThing$fCNodeCBuiltinThing$fPosCExpression$fCNodeCExpression$fFunctorCAttribute$fPosCAttribute$fCNodeCAttribute$fFunctorCPartDesignator$fPosCPartDesignator$fCNodeCPartDesignator$fPosCInitializer$fCNodeCInitializer$fFunctorCEnumeration$fPosCEnumeration$fCNodeCEnumeration$fFunctorCStructureUnion$fPosCStructureUnion$fCNodeCStructureUnion$fFunctorCAlignmentSpecifier$fPosCAlignmentSpecifier$fCNodeCAlignmentSpecifier$fFunctorCTypeQualifier$fPosCTypeQualifier$fCNodeCTypeQualifier$fFunctorCTypeSpecifier$fPosCTypeSpecifier$fCNodeCTypeSpecifier$fFunctorCDeclarationSpecifier$fPosCDeclarationSpecifier$fCNodeCDeclarationSpecifier$fFunctorCCompoundBlockItem$fPosCCompoundBlockItem$fCNodeCCompoundBlockItem$fFunctorCAssemblyOperand$fPosCAssemblyOperand$fCNodeCAssemblyOperand$fFunctorCAssemblyStatement$fPosCAssemblyStatement$fCNodeCAssemblyStatement$fPosCStatement$fCNodeCStatement$fFunctorCArraySize$fPosCDerivedDeclarator$fCNodeCDerivedDeclarator$fFunctorCDeclarator$fPosCDeclarator$fCNodeCDeclarator$fPosCDeclaration$fCNodeCDeclaration$fFunctorCFunctionDef$fPosCFunctionDef$fCNodeCFunctionDef$fNFDataCBuiltinThing$fFunctorCExpression$fNFDataCExpression$fNFDataCAttribute$fNFDataCPartDesignator$fFunctorCInitializer$fNFDataCInitializer$fNFDataCEnumeration$fNFDataCStructureUnion$fNFDataCAlignmentSpecifier$fNFDataCTypeQualifier$fNFDataCTypeSpecifier$fNFDataCDeclarationSpecifier$fNFDataCCompoundBlockItem$fNFDataCAssemblyOperand$fNFDataCAssemblyStatement$fFunctorCStatement$fNFDataCStatement$fNFDataCArraySize$fFunctorCDerivedDeclarator$fNFDataCDerivedDeclarator$fNFDataCDeclarator$fFunctorCDeclaration$fNFDataCDeclaration$fNFDataCFunctionDef$fFunctorCExternalDeclaration$fPosCExternalDeclaration$fCNodeCExternalDeclaration$fNFDataCExternalDeclaration$fFunctorCTranslationUnit$fPosCTranslationUnit$fCNodeCTranslationUnit$fNFDataCTranslationUnit$fAnnotatedCStringLiteral$fAnnotatedCConstant$fAnnotatedCBuiltinThing$fAnnotatedCExpression$fAnnotatedCAttribute$fAnnotatedCPartDesignator$fAnnotatedCInitializer$fAnnotatedCEnumeration$fAnnotatedCStructureUnion$fAnnotatedCAlignmentSpecifier$fAnnotatedCFunctionSpecifier$fAnnotatedCTypeQualifier$fAnnotatedCTypeSpecifier$fAnnotatedCStorageSpecifier $fAnnotatedCDeclarationSpecifier$fAnnotatedCCompoundBlockItem$fAnnotatedCAssemblyOperand$fAnnotatedCAssemblyStatement$fAnnotatedCStatement$fAnnotatedCDerivedDeclarator$fAnnotatedCDeclarator$fAnnotatedCDeclaration$fAnnotatedCFunctionDef$fAnnotatedCExternalDeclaration$fAnnotatedCTranslationUnit$fShowCTranslationUnit$fDataCTranslationUnit$fGenericCTranslationUnit$fGeneric1TYPECTranslationUnit$fShowCExternalDeclaration$fDataCExternalDeclaration$fGenericCExternalDeclaration"$fGeneric1TYPECExternalDeclaration$fShowCDeclaration$fDataCDeclaration$fGenericCDeclaration$fDataCExpression$fShowCExpression$fGenericCExpression$fShowCBuiltinThing$fDataCBuiltinThing$fGenericCBuiltinThing$fShowCPartDesignator$fDataCPartDesignator$fGenericCPartDesignator$fShowCInitializer$fDataCInitializer$fGenericCInitializer$fShowCStatement$fDataCStatement$fGenericCStatement$fShowCAttribute$fDataCAttribute$fGenericCAttribute$fGeneric1TYPECAttribute$fShowCCompoundBlockItem$fDataCCompoundBlockItem$fGenericCCompoundBlockItem $fGeneric1TYPECCompoundBlockItem$fShowCFunctionDef$fDataCFunctionDef$fGenericCFunctionDef$fGeneric1TYPECFunctionDef$fShowCDeclarationSpecifier$fDataCDeclarationSpecifier$fGenericCDeclarationSpecifier#$fGeneric1TYPECDeclarationSpecifier$fShowCAlignmentSpecifier$fDataCAlignmentSpecifier$fGenericCAlignmentSpecifier!$fGeneric1TYPECAlignmentSpecifier$fShowCTypeQualifier$fDataCTypeQualifier$fGenericCTypeQualifier$fGeneric1TYPECTypeQualifier$fShowCTypeSpecifier$fDataCTypeSpecifier$fGenericCTypeSpecifier$fGeneric1TYPECTypeSpecifier$fShowCEnumeration$fDataCEnumeration$fGenericCEnumeration$fGeneric1TYPECEnumeration$fShowCStructureUnion$fDataCStructureUnion$fGenericCStructureUnion$fGeneric1TYPECStructureUnion$fShowCDeclarator$fDataCDeclarator$fGenericCDeclarator$fGeneric1TYPECDeclarator$fShowCDerivedDeclarator$fDataCDerivedDeclarator$fGenericCDerivedDeclarator$fShowCArraySize$fDataCArraySize$fGenericCArraySize$fGeneric1TYPECArraySize$fShowCAssemblyStatement$fDataCAssemblyStatement$fGenericCAssemblyStatement $fGeneric1TYPECAssemblyStatement$fShowCAssemblyOperand$fDataCAssemblyOperand$fGenericCAssemblyOperand$fGeneric1TYPECAssemblyOperand$fShowCStringLiteral$fDataCStringLiteral$fGenericCStringLiteral$fGeneric1TYPECStringLiteral$fShowCConstant$fDataCConstant$fGenericCConstant$fGeneric1TYPECConstant$fShowCStructTag$fEqCStructTag$fDataCStructTag$fGenericCStructTag$fShowCFunctionSpecifier$fDataCFunctionSpecifier$fGenericCFunctionSpecifier $fGeneric1TYPECFunctionSpecifier$fShowCStorageSpecifier$fEqCStorageSpecifier$fOrdCStorageSpecifier$fDataCStorageSpecifier$fGenericCStorageSpecifier$fGeneric1TYPECStorageSpecifierPrettypretty prettyPrecprettyUsingInclude$fPrettyCStringLiteral$fPrettyCConstant$fPrettyCUnaryOp$fPrettyCBinaryOp$fPrettyCAssignOp$fPrettyCBuiltinThing$fPrettyCExpression$fPrettyCAttribute$fPrettyCPartDesignator$fPrettyCInitializer$fPrettyCArraySize$fPrettyCDeclarator$fPrettyCEnumeration$fPrettyCStructTag$fPrettyCStructureUnion$fPrettyCFunctionSpecifier$fPrettyCTypeQualifier$fPrettyCTypeSpecifier$fPrettyCStorageSpecifier$fPrettyCAlignmentSpecifier$fPrettyCDeclarationSpecifier$fPrettyCDeclaration$fPrettyCCompoundBlockItem$fPrettyCAssemblyOperand$fPrettyCAssemblyStatement$fPrettyCStatement$fPrettyCFunctionDef$fPrettyCExternalDeclaration$fPrettyCTranslationUnitparseC translUnitPextDeclP statementP expressionP execParser_ExprStmt AttributesAttrAsmNameAsmBlockVarNameNoName Initializer TypeQualsconstantvolatilerestrictatomicnullablenonnullclrdonlyclwronly EnumeratorEnumType CompTyKind StructTagUnionTagCompType EnumTypeRef CompTypeRef FloatTypeTyFloatTyDouble TyLDoubleTyFloatNIntTypeTyBoolTyCharTySCharTyUCharTyShortTyUShortTyIntTyUIntTyInt128 TyUInt128TyLongTyULongTyLLongTyULLong TypeDefRef BuiltinTypeTyVaListTyAnyTypeNameTyVoid TyIntegral TyFloating TyComplexTyCompTyEnum TyBuiltin ArraySizeUnknownArraySizeFunTypeFunTypeIncompleteType DirectTypePtrType ArrayType FunctionType TypeDefTypeLinkage NoLinkageInternalLinkageExternalLinkageRegister ThreadLocalStorage NoStorageAutoStatic FunLinkage FunctionAttrsisInline isNoreturn DeclAttrsVarDeclTypeDef MemberDecl AnonBitField ParamDeclAbstractParamDeclFunDefObjDefDecl DeclEventTagEvent ParamEvent LocalEvent TypeDefEventAsmEvent GlobalDeclsgObjsgTags gTypeDefs IdentDecl Declaration ObjectDef FunctionDef EnumeratorDef getVarDeclTagDefCompDefEnumDef HasCompTyKindcompTag HasSUERefsueRef typeOfTagDef declIdentdeclNamedeclType declAttrs objKindDescrsplitIdentDeclsemptyGlobalDeclsfilterGlobalDeclsmergeGlobalDecls isTentativeidentOfTypeDef isExtDecl declStorage functionAttrsnoFunctionAttrs hasLinkage declLinkage typeOfCompDef typeOfEnumDef noTypeQualsmergeTypeQualsidentOfVarNameisNoName noAttributesmergeAttributes $fShowIntType$fShowFloatType$fPosEnumTypeRef$fCNodeEnumTypeRef$fHasSUERefEnumTypeRef$fShowCompTyKind$fPosCompTypeRef$fCNodeCompTypeRef$fHasSUERefCompTypeRef$fHasCompTyKindCompTypeRef$fOrdTypeQuals $fEqTypeQuals $fPosAttr $fCNodeAttr$fPosEnumerator$fCNodeEnumerator $fPosEnumType$fCNodeEnumType$fHasSUERefEnumType$fPosTypeDefRef$fCNodeTypeDefRef$fPosParamDecl$fCNodeParamDecl $fPosFunDef $fCNodeFunDef $fPosObjDef $fCNodeObjDef $fPosDecl $fCNodeDecl$fPosIdentDecl$fCNodeIdentDecl$fDeclarationEnumerator$fDeclarationVarDecl$fDeclarationParamDecl$fDeclarationFunDef$fDeclarationObjDef$fDeclarationDecl$fDeclarationIdentDecl$fDeclarationEither $fPosTypeDef$fCNodeTypeDef$fPosMemberDecl$fCNodeMemberDecl$fDeclarationMemberDecl $fPosCompType$fCNodeCompType$fHasCompTyKindCompType$fHasSUERefCompType $fPosTagDef $fCNodeTagDef$fHasSUERefTagDef$fPosDeclEvent$fCNodeDeclEvent $fDataTagDef $fShowTagDef$fDataCompType$fShowCompType$fDataMemberDecl$fShowMemberDecl $fDataTypeDef $fShowTypeDef$fDataIdentDecl$fShowIdentDecl $fDataDecl $fShowDecl $fDataObjDef $fShowObjDef $fDataFunDef $fShowFunDef $fDataType $fShowType$fDataTypeDefRef$fShowTypeDefRef $fDataFunType $fShowFunType$fDataParamDecl$fShowParamDecl $fDataVarDecl $fShowVarDecl$fDataArraySize$fShowArraySize$fDataEnumerator$fShowEnumerator$fDataEnumType$fShowEnumType$fDataDeclAttrs$fShowDeclAttrs $fDataAttr $fShowAttr $fDataVarName $fShowVarName$fDataTypeQuals$fShowTypeQuals$fDataTypeName$fShowTypeName$fDataCompTypeRef$fShowCompTypeRef$fEqCompTyKind$fOrdCompTyKind$fDataCompTyKind$fDataEnumTypeRef$fShowEnumTypeRef$fDataFloatType $fEqFloatType$fOrdFloatType $fDataIntType $fEqIntType $fOrdIntType$fDataBuiltinType$fShowBuiltinType $fDataStorage $fShowStorage $fEqStorage $fOrdStorage $fDataLinkage $fShowLinkage $fEqLinkage $fOrdLinkage$fEqFunctionAttrs$fOrdFunctionAttrs$fDataFunctionAttrs$fShowFunctionAttrsarithmeticConversionfloatConversion intConversion TypeMismatch RedefKind DuplicateDefDiffKindRedecl ShadowedDefDisagreeLinkage NoLinkageOld RedefInfo RedefErrorBadSpecifierErrorInvalidASTError InvalidAST invalidASTbadSpecifierError typeMismatch redefinition$fShowInvalidASTError$fErrorInvalidASTError$fShowBadSpecifierError$fErrorBadSpecifierError$fErrorRedefError$fShowRedefError$fErrorTypeMismatch$fShowTypeMismatchDeclarationStatusNewDecl RedeclaredKeepDefShadowed KindMismatchDefTable identDeclstagDecls labelDefs memberDeclsrefTable typeTableTagEntry TagFwdDeclCompDeclEnumDecl IdentEntry identOfTyDecl emptyDefTable globalDefs inFileScopeenterFunctionScopeleaveFunctionScopeenterBlockScopeleaveBlockScopeenterMemberDeclleaveMemberDecldeclStatusDescr defineTypeDefdefineGlobalIdentdefineScopedIdentdefineScopedIdentWhen declareTag defineTag defineLabel lookupIdent lookupTag lookupLabellookupIdentInnerlookupTagInner insertType lookupType mergeDefTable$fCNodeTagFwdDecl$fHasSUERefTagFwdDecl$fShowTagEntryKind$fEqTagEntryKind$fOrdTagEntryKind$fDataDeclarationStatusintegralfloating simplePtr uint16_tType uint32_tType uint64_tType size_tType ptrDiffTypeboolTypevoidTypevoidPtr constVoidPtrcharPtr constCharPtr stringType valistTypeisIntegralTypeisFloatingType isPointerType isScalarTypeisFunctionType typeQuals typeQualsUpd typeAttrs typeAttrsUpdbaseType derefTypeDefdeepDerefTypeDefsameType canonicalType getIntType getFloatTypebuiltins TravState userState TravOptionslanguage CLanguageC89C99GNU89GNU99TravTravT MonadTrav handleDecl MonadCErrorthrowTravErrorcatchTravError recordError getErrors MonadSymtab getDefTable withDefTable MonadNamegenName handleTagDecl handleTagDefhandleEnumeratorDef handleTypeDefhandleAsmBlock handleVarDeclhandleParamDecl handleFunDefhandleObjectDefenterPrototypeScopeleavePrototypeScope lookupTypeDef lookupObject createSUERefhandleTravError hadHardErrorsastError throwOnLeftwarnrunTravTrunTravTWithTravStaterunTravrunTrav_withExtDeclHandler travErrors initTravStatemodifyUserState getUserState modifyOptions mapMaybeMmaybeMmapSndM concatMapM$fMonadTravTravT$fMonadCErrorTravT$fMonadSymtabTravT$fMonadNameTravT$fMonadIOTravT$fMonadTransTravT $fMonadTravT$fApplicativeTravT$fFunctorTravT$fMonadStateTravStateTravTexport exportDeclrexportTypeDecl exportTypeDef exportTypeexportTypeSpecexportCompTypeDeclexportEnumTypeDeclexportCompTypeexportCompTypeRefexportEnumTypeexportEnumTypeRef prettyAssocsprettyAssocsWithglobalDeclStats $fPrettyAttr $fPrettyList$fPrettyVarName$fPrettyLinkage$fPrettyStorage$fPrettyFunctionAttrs$fPrettyEnumerator$fPrettyEnumType$fPrettyMemberDecl$fPrettyCompType$fPrettyTypeQuals $fPrettyType$fPrettyDeclAttrs$fPrettyParamDecl$fPrettyVarDecl$fPrettyFunDef$fPrettyObjDef$fPrettyTypeDef $fPrettyDecl$fPrettyIdentDecl$fPrettyTagDef$fPrettySUERef $fPrettyIdent$fPrettyEnumTypeRef$fPrettyCompTypeRef$fPrettyCompTyKind$fPrettyTagFwdDecl$fPrettyEither$fPrettyGlobalDecls$fPrettyDefTablepTypetypeErrorOnLeft typeErrornotFound checkScalar'checkIntegral'assignCompatible' binopType'conditionalType' checkScalar checkIntegral constType compatible compositeType compositeSize sizeEqual mergeAttrscompositeParamDeclcompositeParamDecl'compositeVarDeclcompositeDeclAttrscastCompatibleassignCompatible binopTypeconditionalType derefType varAddrType fieldType tagMembersexpandAnonymous lookupSUE deepTypeAttrs typeDefAttrssueAttrs getSubStmts mapSubStmtsmapBlockItemStmts getLabelsExprSideLValueRValueStmtCtxFunCtxLoopCtx SwitchCtxtExprTypeSpecAnalysisTSNoneTSVoidTSBoolTSNum TSTypeDefTSType TSNonBasic NumTypeSpecbasesignSpecsizeMod isComplexSizeMod NoSizeModShortModLongMod LongLongModSignSpec NoSignSpecSignedUnsigned NumBaseType NoBaseTypeBaseCharBaseInt BaseInt128 BaseFloat BaseFloatN BaseDouble VarDeclInfo StorageSpec NoStorageSpecAutoSpecRegSpec ThreadSpec StaticSpec ExternSpec ClKernelSpec ClGlobalSpec ClLocalSpechasThreadLocalSpechasClKernelSpecanalyseVarDecl'analyseVarDecl isTypeDefanalyseTypeDecltType tDirectTypetNumType tArraySize tTypeQualscanonicalTypeSpeccanonicalStorageSpec mergeOldStyletAttr mkVarName nameOfDecl getOnlyDeclr $fEqSizeMod $fOrdSizeMod $fEqSignSpec $fOrdSignSpec$fEqNumBaseType$fOrdNumBaseType$fEqStorageSpec$fOrdStorageSpec$fShowStorageSpec$fReadStorageSpec MachineDesciSizefSize builtinSizeptrSizevoidSizeiAlignfAlign builtinAlignptrAlign voidAlignintExpr sizeofType alignofTypecompSizeAndAlignroundToAlignmentintOpintUnOp withWordBytes boolValueintValue constEval analyseAST analyseExt analyseFunDef analyseDecl defineParamsanalyseFunctionBodytStmt defaultMD tDesignator $fEqExprSide$fShowExprSidex86_64armv7lCppArgs cppOptions extraOptions cppTmpDir inputFile outputFile CppOption IncludeDirDefineUndefine IncludeFile Preprocessor parseCPPArgsrunCPPcppFile rawCppArgs addCppOptionaddExtraOptionrunPreprocessorisPreprocessedGCCnewGCC$fPreprocessorGCC parseCFile parseCFilePreGHC.BaseString posFileInfo FilePosition posSrcFile posParentFileRListReversedempty singletonsnocrappendappendrrappendrrmapreverseviewrghc-prim GHC.TypesCharisAsciiSourceCharisCChar escapeCCharisSCharCTokenCTokEof CTokLParen CTokRParen CTokLBracket CTokRBracket CTokArrowCTokDot CTokExclam CTokTildeCTokIncCTokDecCTokPlus CTokMinusCTokStar CTokSlash CTokPercent CTokAmper CTokShiftL CTokShiftRCTokLess CTokLessEqCTokHigh CTokHighEq CTokEqual CTokUnequalCTokHatCTokBarCTokAndCTokOr CTokQuest CTokColon CTokAssign CTokPlusAss CTokMinusAss CTokStarAss CTokSlashAss CTokPercAss CTokAmpAss CTokHatAss CTokBarAss CTokSLAss CTokSRAss CTokComma CTokSemic CTokLBrace CTokRBrace CTokEllipsis CTokAlignof CTokAlignasCTokAsm CTokAtomicCTokAuto CTokBreakCTokBoolCTokCaseCTokChar CTokConst CTokContinue CTokComplex CTokDefaultCTokDo CTokDoubleCTokElseCTokEnum CTokExtern CTokFloat CTokFloatNCTokFor CTokGenericCTokGotoCTokIf CTokInlineCTokInt CTokInt128CTokLong CTokLabel CTokNoreturn CTokNullable CTokNonnull CTokRegister CTokRestrict CTokReturn CTokShort CTokSigned CTokSizeof CTokStaticCTokStaticAssert CTokStruct CTokSwitch CTokTypedef CTokTypeof CTokThread CTokUInt128 CTokUnion CTokUnsignedCTokVoid CTokVolatile CTokWhileCTokCLitCTokILitCTokFLitCTokSLit CTokIdent CTokTyIdentCTokGnuC CTokClangC CTokClKernel CTokClRdOnly CTokClWrOnly CTokClGlobal CTokClLocal posLenOfTokGnuCTok GnuCAttrTok GnuCExtTok GnuCVaArg GnuCOffsetof GnuCTyCompatGnuCComplexRealGnuCComplexImag ClangCTokClangCVersionTokClangBuiltinConvertVector ClangCBitCast setLastTokenhandleEofTokenfailP getNewName addTypedef shadowTypedef isTypeIdent enterScopesetPosgetPosgetInputsetInput getLastToken getSavedTokengetCurrentPositionlexC parseErrorGHC.Num*HappyStk declOfDeftagKindconstPtrisVariablyModifiedType sameArraySizeTrueaddRefexportFunAttrs exportStorage tParamDeclcomputeParamStorage tMemberDeclsmergeTypeAttributes tEnumTypeDecl tEnumType splitCDeclanalyseTypeDefcomputeFunDefStorage extFunProto extVarDecl localVarDeclenclosingFunctionType tBlockItemtExpr' builtinTypepreprocessedExt mkOutputFilegetOutputFileName mkTmpFilegccParseCPPArgs