2 The C Language

This library provides data types representing C abstract syntax, a C parser, and macros for constructing C abstract syntax with a convenient parenthesized syntax. It can be required via:

2.1 C Language Grammar

The grammar provided in the ISO/IEC 9899:TC3 standard is mum about when typedef-name tokens can be used as identifier tokens. For example, all C parsers admit programs such as:

typedef int T;

void proc(char T) { }

despite the fact that T is a typedef-name and the grammar for procedure arguments requires argument declarator names to be identifier tokens.

The following is a more detailed (and slightly reorganized) grammar than the one in the C99 standard which explicitly specifies when tokens bound as typedef names can be used as identifiers.

‹List›X
::=
X {"," ‹List›X}*

‹AnyIdentifier›
::=
‹Identifier›

|
‹TypedefName›

2.1.1 Expressions

‹PrimaryExpression›
::=
‹Identifier›

  |
‹Constant›

  |
‹StringLiteral›

  |
"(" ‹Expression› ")"

‹PostfixExpression›
::=
‹PrimaryExpression›

  |
‹PostfixExpression› "[" ‹Expression› "]"

  |
‹PostfixExpression› "(" [‹List›‹AssignmentExpression›] ")"

  |
‹PostfixExpression› "." ‹AnyIdentifier›

  |
‹PostfixExpression› "->" ‹AnyIdentifier›

  |
‹PostfixExpression› "++"

  |
‹PostfixExpression› "–"

  |
"(" ‹TypeName› ")" "{" ‹List›‹Initializer› [","] "}"

‹UnaryExpression›
::=
"++" ‹UnaryExpression›

  |
"–" ‹UnaryExpression›

  |
{"&"  |  "*"  |  "+"  |  "-"  |  "~"  |  "!"} ‹CastExpression›

  |
"sizeof" ‹UnaryExpression›

  |
"sizeof" "(" ‹TypeName› ")"

‹CastExpression›
::=
‹UnaryExpression›

  |
"(" ‹TypeName› ")" ‹CastExpression›

‹BinaryExpression›(E,Op)
::=
E

  |
‹BinaryExpression›(E,Op) Op E

‹MultiplicativeExpression›
::=
‹BinaryExpression›(‹CastExpression›,{"*" | "/" | "%"})

‹AdditiveExpression›
::=
‹BinaryExpression›(‹MultiplicativeExpression›,{"+" | "-"})

‹ShiftExpression›
::=
‹BinaryExpression›(‹AdditiveExpression›,{"<<" | ">>"})

‹RelationalExpression›
::=
‹BinaryExpression›(‹ShiftExpression›,{"<" | ">" | "<=" | ">="})

‹EqualityExpression›
::=
‹BinaryExpression›(‹RelationalExpression›,{"==" | "!="})

‹ANDExpression›
::=
‹BinaryExpression›(‹EqualityExpression›,"&")

‹ExclusiveORExpression›
::=
‹BinaryExpression›(‹ANDExpression›,"^")

‹InclusiveORExpression›
::=
‹BinaryExpression›(‹ExclusiveORExpression›,"|")

‹LogicalANDExpression›
::=
‹BinaryExpression›(‹LogicalORExpression›,"||")

‹ConditionalExpression›
::=
‹LogicalORExpression›

  |
‹LogicalORExpression› "?" ‹Expression› ":" ‹ConditionalExpression›

‹AssignmentExpression›
::=
‹ConditionalExpression›

  |
‹UnaryExpression› ‹AssignmentOperator› ‹AssignmentExpression›

‹AssignmentOperator›
::=
"="  |  "*="  |  "/="  |  "%="  |  "+="  |  "-="

  |
"<<="  |  ">>="  |  "&="  |  "^="  |  "|="

‹Expression›
::=
‹List›‹AssignmentExpression›

‹ConstantExpression›
::=
‹ConditionalExpression›

2.1.2 Declarations

‹Declaration›
::=
‹DeclarationModifier›+ [‹List›‹InitDeclarator›‹Identifier›] ";"

  |
‹DeclarationSpecifiers› [‹List›‹InitDeclarator›‹AnyIdentifier›] ";"

‹DeclarationSpecifiers›
::=
‹DeclarationModifier›* ‹TaggedTypeSpecifier› ‹DeclarationModifier›*

  |
‹DeclarationModifier›* ‹TypedefName› ‹DeclarationModifier›*

  |
‹DeclarationModifier›* {‹PrimTypeSpecifier› ‹DeclarationModifier›*}+

‹DeclarationModifier›
::=
‹StorageClassSpecifier›

  |
‹TypeQualifier›

  |
‹FunctionSpecifier›

‹InitDeclarator›X
::=
‹Declarator›X ["=" ‹Initializer›]

‹StorageClassSpecifier›
::=
"typedef"  |  "extern"  |  "static"  |  "auto"  |  "register"

‹TypeSpecifier›
::=
‹PrimTypeSpecifier›

  |
‹TaggedTypeSpecifier›

  |
‹TypedefName›

‹PrimTypeSpecifier›
::=
"void"

  |
"char"  |  "short"  |  "int"  |  "long"

  |
"float"  |  "double"

  |
"signed"  |  "unsigned"

  |
"_Bool"  |  "_Complex"

‹TaggedTypeSpecifier›
::=
{"struct"  |  "union"} [‹Tag›] "{" ‹StructDeclaration›+ "}"

  |
{"struct"  |  "union"} ‹Tag›

  |
‹EnumSpecifier›

‹Tag›
::=
‹Identifier›

  |
‹TypedefName›

‹StructDeclaration›
::=
‹TypeQualifier›+ [‹List›‹StructDeclarator›‹Identifier›] ";"

  |
‹StructSpecifiers› [‹List›‹StructDeclarator›‹AnyIdentifier›] ";"

‹StructSpecifiers›
::=
‹TypeQualifier›* ‹TaggedTypeSpecifier› ‹TypeQualifier›*

  |
‹TypeQualifier›* ‹TypedefName› ‹TypeQualifier›*

  |
‹TypeQualifier›* {‹PrimTypeSpecifier› ‹TypeQualifier›*}+

‹StructDeclarator›X
::=
‹Declarator›X

  |
[‹Declarator›X] ":" ‹ConstantExpression›

‹EnumSpecifier›
::=
"enum" [‹Tag›] "{" ‹List›‹Enumerator› [","] "}"

  |
"enum" ‹Tag›

‹Enumerator›
::=
‹AnyIdentifier› ["=" ‹ConstantExpression›]

‹TypeQualifier›
::=
"const"  |  "restrict"  |  "volatile"

‹FunctionSpecifier›
::=
"inline"

‹Declarator›X
::=
[‹Pointer›] ‹DirectDeclarator›X

‹DirectDeclarator›X
::=
X

  |
"(" ‹Declarator›X ")"

  |
‹DirectDeclarator›X "[" ‹TypeQualifier›* [‹AssignmentExpression›] "]"

  |
‹DirectDeclarator›X "[" "static" ‹TypeQualifier›* ‹AssignmentExpression› "]"

  |
‹DirectDeclarator›X "[" TypeQualifier+ "static" ‹AssignmentExpression› "]"

  |
‹DirectDeclarator›X "[" ‹TypeQualifier›* "*" "]"

  |
‹DirectDeclarator›X "(" ‹ParameterTypeList› ")"

  |
‹DirectDeclarator›X "(" [‹List›‹Identifier›] ")"

‹Pointer›
::=
{"*" ‹TypeQualifier›*}+

‹ParameterTypeList›
::=
‹List›‹ParameterDeclaration› ["," "..."]

‹ParameterDeclaration›
::=
‹DeclarationModifier›+ [‹Declarator›‹Identifier›]

  |
‹DeclarationSpecifiers› [‹Declarator›‹AnyIdentifier›]

  |
‹DeclarationModifier›+ ‹AbstractDeclarator›

  |
‹DeclarationSpecifiers› ‹AbstractDeclarator›

‹TypeName›
::=
{‹TypeSpecifier›  |  ‹TypeQualifier›}+ [‹AbstractDeclarator›]

‹AbstractDeclarator›
::=
‹Pointer›

  |
[‹Pointer›] ‹DirectAbstractDeclarator›

‹DirectAbstractDeclarator›
::=
"(" ‹AbstractDeclarator› ")"

  |
[‹DirectAbstractDeclarator›] "[" ‹TypeQualifier›* [‹AssignmentExpression›] "]"

  |
[‹DirectAbstractDeclarator›] "[" "static" ‹TypeQualifier›* ‹AssignmentExpression› "]"

  |
[‹DirectAbstractDeclarator›] "[" ‹TypeQualifier›+ "static" ‹AssignmentExpression› "]"

  |
[‹DirectAbstractDeclarator›] "[" "*" "]"

  |
[‹DirectAbstractDeclarator›] "(" [‹ParameterTypeList›] ")"

‹Initializer›
::=
‹AssignmentExpression›

  |
"{" ‹List›{[‹List›‹Designator› "="] ‹Initializer›} [","] "}"

‹Designator›
::=
"[" ‹ConstantExpression› "]"

  |
"." ‹AnyIdentifier›

2.1.3 Statements

The parameterized statement non-terminals such as ‹Statement›X take a flag indicating whether the productions may be right-terminated by a one-armed if statement (i.e., an if statement with no else clause). This is used to avoid the “dangling else” ambiguity.

‹Statement›X
::=
‹LabeledStatement›X

  |
‹CompoundStatement›

  |
‹ExpressionStatement›

  |
‹SelectionStatement›X

  |
‹IterationStatement›X

  |
‹JumpStatement›

‹LabeledStatement›X
::=
‹AnyIdentifier› ":" ‹Statement›X

  |
"case" ‹ConstantExpression› ":" ‹Statement›X

  |
"default" ":" ‹Statement›X

‹CompoundStatement›
::=
"{" ‹BlockItem›* "}"

‹BlockItem›
::=
‹Declaration›

  |
‹Statement›#t

‹ExpressionStatement›
::=
[‹Expression›] ";"

‹SelectionStatement›X
::=
‹IfStatement›X

  |
"switch" "(" ‹Expression› ")" ‹Statement›X

‹IfStatement›#t
::=
"if" "(" ‹Expression› ")" ‹Statement›#t ["else" ‹Statement›#t]

‹IfStatement›#f
::=
"if" "(" ‹Expression› ")" ‹Statement›#t "else" ‹Statement›#f

‹IterationStatement›X
::=
"while" "(" ‹Expression› ")" ‹Statement›X

  |
"do" ‹Statement›#t "while" "(" ‹Expression› ")" ";"

  |
"for" "(" [‹Expression›] ";" [‹Expression›] ";" [‹Expression›] ")" ‹Statement›X

  |
"for" "(" ‹Declaration› [‹Expression›] ";" [‹Expression›] ")" ‹Statement›X

‹JumpStatement›
::=
"goto" ‹AnyIdentifier› ";"

  |
"continue" ";"

  |
"break" ";"

  |
"return" [‹Expression›] ";"

2.1.4 Programs

‹TranslationUnit›
::=
‹ExternalDefinition›+

‹ExternalDefinition›
::=
‹FunctionDefinition›

|
‹Declaration›

‹FunctionDefinition›
::=
‹FunctionHead› [‹List›‹Declaration›] ‹FunctionBody›

‹FunctionHead›
::=
‹DeclarationModifier›+ ‹Declarator›‹Identifier›

|
‹DeclarationSpecifiers› ‹Declarator›‹AnyIdentifier›

‹FunctionBody›
::=
‹CompoundStatement›

2.2 Abstract Syntax

The abstract syntax of C is represented as structs. All of the structure definitions are provided by the package

(require (planet dherman/c:3:3/ast))

All of the structs defined in this library are prefab structs, and consist entirely of read-able and write-able data.

2.2.1 Source Locations

Source location information is stored with the following struct type.

(struct src ( start-offset
start-line
start-col
end-offset
end-line
end-col
path)
#:extra-constructor-name make-src)
  start-offset : exact-nonnegative-integer?
  start-line : exact-positive-integer?
  start-col : exact-nonnegative-integer?
  end-offset : exact-nonnegative-integer?
  end-line : exact-positive-integer?
  end-col : exact-nonnegative-integer?
  path : any

(src-start src) → position?

src : src?

Extracts a source location’s start position as a position struct.

(src-end src) → position?

src : src?

Extracts a source location’s end position as a position struct.

(build-src start end path) → src?

start : position?

end : position?

path : any

Builds a source location struct from position structs.

(position-min p ...+) → position?

p : position?

Returns the least of the given positions p, i.e. the p with the least position-offset.

(position-max p ...+) → position?

p : position?

Returns the greatest of the given positions p, i.e. the p with the greatest position-offset.

(src-range src ...+) → src?

src : src?

Returns the smallest range that spans all the given source locations src.

(src->syntax x [datum original?]) → syntax?

x : src?

datum : any = '...

original? : boolean? = #t

Converts a source location to a syntax object, using datum as the syntax object’s underlying datum. If original? is #t, the generated syntax object has the syntax-original? property.

(id->syntax id [original?]) → syntax?

id : id?

original? : boolean? = #t

Converts an identifier to a syntax object, using the identifier name as the syntax object’s underlying datum. If original? is #t, the generated syntax object has the syntax-original? property.

(primitive-type-specifier? x) → boolean?

x : symbol?

Indicates whether x is a primitive type specifier, which is one of the symbols 'void, 'char, 'short, 'int, 'long, 'float, 'double, 'signed, 'unsigned, '_Bool, or '_Complex.

(unary-operator? x) → boolean?

x : symbol?

Indicates whether x is a unary operator symbol, which is one of the symbols '&, '*, '+, '-, '~, or '!.

(binary-operator? x) → boolean?

x : symbol?

Indicates whether x is a binary operator symbol, which is one of the symbols '*, '/, '%, '+, '-, '<<, '>>, '<, '>, '<=, '>=, '==, '!=, '&, '^, '\|, '&&, or '\|\|.

(assignment-operator? x) → boolean?

x : symbol?

Indicates whether x is an assignment operator symbol, which is one of the symbols '=, '*=, '/=, '%=, '+=, '-=, '<<=, '>>=, '&=, '^=, or '\|=.

(increment-operator? x) → boolean?

x : symbol?

Indicates whether x is an increment/decrement operator symbol, which is one of the symbols '++ or '--.

2.2.2 Identifiers

(struct		id (src)
		#:extra-constructor-name make-id)

src : (or/c src? #f)

A C identifier, i.e., a variable name, type name, label name, or keyword.

(struct		id:var id (name)
		#:extra-constructor-name make-id:var)

name : symbol?

A variable or type name.

(struct		id:label id (name)
		#:extra-constructor-name make-id:label)

name : symbol?

A struct, union, or enum tag, a statement label, or a struct or union member name.

(struct		id:qualifier id (name)
		#:extra-constructor-name make-id:qualifier)

name : (or/c 'const 'restrict 'volatile)

A type qualifier.

(struct		id:op id (name)
		#:extra-constructor-name make-id:op)

name : (or/c unary-operator? binary-operator? assignment-operator? increment-operator?)

A unary, binary, assignment, or increment/decrement operator.

(struct		id:storage id (class)
		#:extra-constructor-name make-id:storage)

class : (or/c 'typedef 'extern 'static 'auto 'register)

A storage class specifier.

(struct		id:inline id ()
		#:extra-constructor-name make-id:inline)

The inline keyword.

(struct		id:ellipsis id ()
		#:extra-constructor-name make-id:ellipsis)

The varargs keyword “...”.

(struct		id:star id ()
		#:extra-constructor-name make-id:star)

The array-type modifier keyword “*”.

2.2.3 Expressions

(struct		expr (src)
		#:extra-constructor-name make-expr)

src : (or/c src? #f)

A C expression.

(struct		expr:ref expr (id)
		#:extra-constructor-name make-expr:ref)

id : id:var?

A variable reference.

(struct		expr:int expr (value qualifiers)
		#:extra-constructor-name make-expr:int)

value : integer?

qualifiers : (listof id:qualifier?)

An integer literal.

(struct		expr:float expr (value qualifiers)
		#:extra-constructor-name make-expr:float)

value : inexact-real?

qualifiers : (listof id:qualifier?)

A floating-point literal.

(struct		expr:char expr (source wide?)
		#:extra-constructor-name make-expr:char)

source : string?

wide? : boolean?

A character literal. Character literals are stored as uninterpreted source, i.e., with escape sequences left in.

Example:

> (parse-expression "'\\n'")
'#s((expr:char expr 1) #s(src 1 1 0 5 1 4 #f) "\\n" #f)

(struct		expr:string expr (source wide?)
		#:extra-constructor-name make-expr:string)

source : string?

wide? : boolean?

A string literal. String literals are stored as uninterpreted source, i.e., with escape sequences left in.

Example:

> (parse-expression "\"foo\\nbar\"")
'#s((expr:string expr 1) #s(src 1 1 0 11 1 10 #f) "foo\\nbar" #f)

(struct		expr:compound expr (type inits)
		#:extra-constructor-name make-expr:compound)

type : type?

inits : (listof (or/c init? (cons (listof dtor?) init?)))

A C99 compound literal.

(struct		expr:array-ref expr (expr offset)
		#:extra-constructor-name make-expr:array-ref)

expr : expr?

offset : expr?

An array dereference.

(struct		expr:call expr (function arguments)
		#:extra-constructor-name make-expr:call)

function : expr?

arguments : (listof expr?)

A function call.

(struct		expr:member expr (expr label)
		#:extra-constructor-name make-expr:member)

expr : expr?

label : id:label?

A struct or union member dereference.

(struct		expr:pointer-member expr (expr label)
		#:extra-constructor-name make-expr:pointer-member)

expr : expr?

label : id:label?

A struct- or union-pointer member dereference.

(struct		expr:postfix expr (expr op)
		#:extra-constructor-name make-expr:postfix)

expr : expr?

op : id:op?

A postfix increment or decrement. The id:op-name field of op is an increment-operator? symbol.

(struct		expr:prefix expr (op expr)
		#:extra-constructor-name make-expr:prefix)

op : id:op?

expr : expr?

A prefix increment or decrement. The id:op-name field of op is an increment-operator? symbol.

(struct		expr:cast expr (type expr)
		#:extra-constructor-name make-expr:cast)

type : type?

expr : expr?

A type cast.

(struct		expr:sizeof expr (term)
		#:extra-constructor-name make-expr:sizeof)

term : (or/c type? expr?)

A sizeof expression.

(struct		expr:unop expr (op expr)
		#:extra-constructor-name make-expr:unop)

op : id:op?

expr : expr?

A unary operator expression. The id:op-name field of op is a unary-operator? symbol.

(struct		expr:binop expr (left op right)
		#:extra-constructor-name make-expr:binop)

left : expr?

op : id:op?

right : expr?

A binary operator expression. The id:op-name field of op is a binary-operator? symbol.

(struct		expr:assign expr (left op right)
		#:extra-constructor-name make-expr:assign)

left : expr?

op : id:op?

right : expr?

An assignment expression. The id:op-name field of op is an assignment-operator? symbol.

(struct		expr:begin expr (left right)
		#:extra-constructor-name make-expr:begin)

left : expr?

right : expr?

A sequence expression.

(struct		expr:if expr (test cons alt)
		#:extra-constructor-name make-expr:if)

test : expr?

cons : expr?

alt : expr?

A conditional expression.

2.2.4 Statements

(struct		stmt (src)
		#:extra-constructor-name make-stmt)

src : (or/c src? #f)

A C statement.

(struct		stmt:label stmt (label stmt)
		#:extra-constructor-name make-stmt:label)

label : id:label?

stmt : stmt?

A labeled statement.

(struct		stmt:case stmt (expr stmt)
		#:extra-constructor-name make-stmt:case)

expr : expr?

stmt : stmt?

A case statement.

(struct		stmt:default stmt (stmt)
		#:extra-constructor-name make-stmt:default)

stmt : stmt?

A default statement.

(struct		stmt:block stmt (items)
		#:extra-constructor-name make-stmt:block)

items : (listof (or/c decl? stmt?))

A compound statement.

(struct		stmt:expr stmt (expr)
		#:extra-constructor-name make-stmt:expr)

expr : expr?

An expression statement.

(struct		stmt:if stmt (test cons alt)
		#:extra-constructor-name make-stmt:if)

test : expr?

cons : stmt?

alt : (or/c stmt? #f)

An if statement.

(struct		stmt:switch stmt (test body)
		#:extra-constructor-name make-stmt:switch)

test : expr?

body : stmt?

A switch statement.

(struct		stmt:while stmt (test body)
		#:extra-constructor-name make-stmt:while)

test : expr?

body : stmt?

A while statement.

(struct		stmt:do stmt (body test)
		#:extra-constructor-name make-stmt:do)

body : stmt?

test : expr?

A do-while statement.

(struct		stmt:for stmt (init test update body)
		#:extra-constructor-name make-stmt:for)

init : (or/c expr? decl? #f)

test : (or/c expr? #f)

update : (or/c expr? #f)

body : stmt?

A for statement.

(struct		stmt:goto stmt (label)
		#:extra-constructor-name make-stmt:goto)

label : id:label?

A goto statement.

(struct		stmt:continue stmt ()
		#:extra-constructor-name make-stmt:continue)

A continue statement.

(struct		stmt:break stmt ()
		#:extra-constructor-name make-stmt:break)

A break statement.

(struct		stmt:return stmt (result)
		#:extra-constructor-name make-stmt:return)

result : (or/c expr? #f)

A return statement.

(struct		stmt:empty stmt ()
		#:extra-constructor-name make-stmt:empty)

An empty statement.

2.2.5 Declarations

(struct		decl (src)
		#:extra-constructor-name make-decl)

src : (or/c src? #f)

A C declaration.

(struct		decl:typedef decl (type declarators)
		#:extra-constructor-name make-decl:typedef)

type : type?

declarators : (listof declarator-context?)

A type definition. Note that each of the declarators is a declarator context.

(struct		decl:vars decl (storage-class type declarators)
		#:extra-constructor-name make-decl:vars)

storage-class : (or/c id:storage? #f)

type : (or/c type? #f)

declarators : (listof declarator-context?)

A variable declaration. Note that each of the declarators is a declarator context.

(struct		decl:formal decl (storage-class type declarator)
		#:extra-constructor-name make-decl:formal)

storage-class : (or/c id:storage? #f)

type : (or/c type? #f)

declarator : (or/c declarator-context? type-context?)

A formal argument declaration.

(struct	decl:function decl	(	storage-class
			inline?
			return-type
			declarator
			preamble
			body)
	#:extra-constructor-name make-decl:function)

storage-class : (or/c id:storage? #f)

inline? : (or/c id:inline? #f)

return-type : type?

declarator : declarator-context?

preamble : (or/c (listof decl?) #f)

body : stmt:block?

A function definition. Note that the declarator is a declarator context. The complete type of the function can be obtained by applying apply-declarator-context to the return-type and declarator.

(struct		decl:declarator decl (id type initializer)
		#:extra-constructor-name make-decl:declarator)

id : (or/c id:var? #f)

type : (or/c type? #f)

initializer : (or/c init? #f)

A declarator, i.e., a single variable binding within a variable declaration.

There are two classes of declarator:

(declarator-context? x) → boolean?

x : any

Determines whether x is a declarator context, which is a declarator with a type context as its type field.

(complete-declarator? x) → boolean?

x : any

Determines whether x is a complete declarator, which is a declarator with a complete type as its type field.

(struct		decl:member-declarator decl (id type initializer bit-size)
		#:extra-constructor-name make-decl:member-declarator)

id : (or/c id:label? #f)

type : (or/c type? #f)

initializer : (or/c init? #f)

bit-size : (or/c expr? #f)

A member declarator, i.e., a single member definition within a struct or union definition.

There are two classes of member declarator:

(member-declarator-context? x) → boolean?

x : any

Determines whether x is a member declarator context, which is a member declarator with a type context as its type field.

(complete-member-declarator? x) → boolean?

x : any

Determines whether x is a complete member declarator, which is a member declarator with a complete type as its type field.

(struct		decl:member decl (type declarators)
		#:extra-constructor-name make-decl:member)

type : (or/c type? #f)

declarators : (listof decl:declarator?)

A member declaration within a struct or union definition.

2.2.6 Initializers

(struct		init (src)
		#:extra-constructor-name make-init)

src : (or/c src? #f)

A C initializer.

(struct		init:compound init (elements)
		#:extra-constructor-name make-init:compound)

elements : (listof (or/c init? (cons (listof dtor?) init?)))

A C99 compound initializer.

(struct		init:expr init (expr)
		#:extra-constructor-name make-init:expr)

expr : expr?

An expression initializer.

2.2.7 Designators

(struct		dtor (src)
		#:extra-constructor-name make-dtor)

src : (or/c src? #f)

A C99 designator.

(struct		dtor:array dtor (expr)
		#:extra-constructor-name make-dtor:array)

expr : expr?

An array designator.

(struct		dtor:member dtor (label)
		#:extra-constructor-name make-dtor:member)

label : id:label?

A struct or union member designator.

2.2.8 Types

(struct		type (src)
		#:extra-constructor-name make-type)

src : (or/c src? #f)

A C type.

(struct		type:primitive type (name)
		#:extra-constructor-name make-type:primitive)

name : (or/c primitive-type-specifier? (listof primitive-type-specifier?))

A primitive type. The name field can be one of:

'void, 'char, 'short, 'int, 'long, 'float, 'double, 'signed, 'unsigned, '_Bool, or '_Complex
'(signed char)
'(unsigned char)
'(signed short)
'(signed short int)
'(unsigned short)
'(unsigned short int)
'(signed int)
'(unsigned int)
'(signed long)
'(long int)
'(signed long int)
'(unsigned long)
'(unsigned long int)
'(long long)
'(signed long long)
'(long long int)
'(signed long long int)
'(unsigned long long)
'(unsigned long long int)
'(long double)
'(float _Complex)
'(double _Complex)
'(long double _Complex)

(struct		type:ref type (id)
		#:extra-constructor-name make-type:ref)

id : id:var?

A reference to a typedef name.

(struct		type:struct type (tag fields)
		#:extra-constructor-name make-type:struct)

tag : id:label?

fields : (or/c (listof decl:member?) #f)

A struct type.

(struct		type:union type (tag variants)
		#:extra-constructor-name make-type:union)

tag : id:label?

variants : (or/c (listof decl:member?) #f)

A union type.

(struct		type:enum type (tag variants)
		#:extra-constructor-name make-type:enum)

tag : id:label?

variants : (or/c (listof (or/c id:var? (cons id:var? expr?))) #f)

An enum type.

(struct		type:array type (base static? qualifiers length star?)
		#:extra-constructor-name make-type:array)

base : type?

static? : (or/c id:static? #f)

qualifiers : (listof id:qualifier?)

length : (or/c expr? #f)

star? : (or/c id:star? #f)

An array type.

(struct		type:pointer type (base qualifiers)
		#:extra-constructor-name make-type:pointer)

base : type?

qualifiers : (listof id:qualifier?)

A pointer type.

(struct		type:function type (return formals)
		#:extra-constructor-name make-type:function)

return : type?

formals : (listof (or/c decl:formal? id:ellipsis?))

A function type.

(struct		type:qualified type (type qualifiers)
		#:extra-constructor-name make-type:qualified)

type : (or/c type? #f)

qualifiers : (listof id:qualifier?)

A qualified type.

2.2.9 Type Contexts

The peculiar syntax of declarations in C leads to a particular notion of type context. A type context is a type with a “hole,” represented by the value #f. For example, in the C declaration

typedef int A[32], *PA[32];

there are two declared types, A and PA, each of which is formed by plugging the base type int into the respective type contexts __[32] and *__[32].

More precisely, a type context is one of:

#f;
a type:pointer whose type:pointer-base field is a type context;
a type:array whose type:array-base field is a type context;
or a type:function whose type:function-return field is a type context.

(type-context? x) → boolean?

x : any

Determines whether x is a type context.

A complete type is a type with no holes.

(complete-type? x) → boolean?

x : any

Determines whether x is a complete type.

(apply-type-context context base) → complete-type?

context : type-context?

base : complete-type?

Plugs the type base into the hole of context to obtain a complete type.

(apply-declarator-context context base) → complete-declarator?

context : declarator-context?

base : complete-type?

Plugs the type base into the hole of context to obtain a complete declarator.

(apply-declarator-contexts contexts base)

→ (listof complete-declarator?)

contexts : (listof declarator-context?)

base : complete-type?

Plugs the type base into each of the holes of contexts to obtain a list of complete declarators.

(apply-member-declarator-context		context
		base)

→ complete-member-declarator?

context : declarator-context?

base : complete-type?

Plugs the type base into the hole of context to obtain a complete member declarator.

(apply-member-declarator-contexts		contexts
		base)

→ (listof complete-member-declarator?)

contexts : (listof member-declarator-context?)

base : complete-type?

Plugs the type base into each of the holes of contexts to obtain a list of complete member declarators.

← prev up next →

1	C Metaprogramming Utilities
2	The C Language
3	Parsing and Reading C
4	Parenthetical C
5	Header Compilation
6	Evaluation
7	Internals
	Index

‹List›X	::=	X {"," ‹List›X}*
‹AnyIdentifier›	::=	‹Identifier›
	\|	‹TypedefName›

‹PrimaryExpression›	::=	‹Identifier›
	\|	‹Constant›
	\|	‹StringLiteral›
	\|	"(" ‹Expression› ")"
‹PostfixExpression›	::=	‹PrimaryExpression›
	\|	‹PostfixExpression› "[" ‹Expression› "]"
	\|	‹PostfixExpression› "(" [‹List›‹AssignmentExpression›] ")"
	\|	‹PostfixExpression› "." ‹AnyIdentifier›
	\|	‹PostfixExpression› "->" ‹AnyIdentifier›
	\|	‹PostfixExpression› "++"
	\|	‹PostfixExpression› "–"
	\|	"(" ‹TypeName› ")" "{" ‹List›‹Initializer› [","] "}"
‹UnaryExpression›	::=	"++" ‹UnaryExpression›
	\|	"–" ‹UnaryExpression›
	\|	{"&" \| "*" \| "+" \| "-" \| "~" \| "!"} ‹CastExpression›
	\|	"sizeof" ‹UnaryExpression›
	\|	"sizeof" "(" ‹TypeName› ")"
‹CastExpression›	::=	‹UnaryExpression›
	\|	"(" ‹TypeName› ")" ‹CastExpression›
‹BinaryExpression›(E,Op)	::=	E
	\|	‹BinaryExpression›(E,Op) Op E
‹MultiplicativeExpression›	::=	‹BinaryExpression›(‹CastExpression›,{"*" \| "/" \| "%"})
‹AdditiveExpression›	::=	‹BinaryExpression›(‹MultiplicativeExpression›,{"+" \| "-"})
‹ShiftExpression›	::=	‹BinaryExpression›(‹AdditiveExpression›,{"<<" \| ">>"})
‹RelationalExpression›	::=	‹BinaryExpression›(‹ShiftExpression›,{"<" \| ">" \| "<=" \| ">="})
‹EqualityExpression›	::=	‹BinaryExpression›(‹RelationalExpression›,{"==" \| "!="})
‹ANDExpression›	::=	‹BinaryExpression›(‹EqualityExpression›,"&")
‹ExclusiveORExpression›	::=	‹BinaryExpression›(‹ANDExpression›,"^")
‹InclusiveORExpression›	::=	‹BinaryExpression›(‹ExclusiveORExpression›,"\|")
‹LogicalANDExpression›	::=	‹BinaryExpression›(‹LogicalORExpression›,"\|\|")
‹ConditionalExpression›	::=	‹LogicalORExpression›
	\|	‹LogicalORExpression› "?" ‹Expression› ":" ‹ConditionalExpression›
‹AssignmentExpression›	::=	‹ConditionalExpression›
	\|	‹UnaryExpression› ‹AssignmentOperator› ‹AssignmentExpression›
‹AssignmentOperator›	::=	"=" \| "*=" \| "/=" \| "%=" \| "+=" \| "-="
	\|	"<<=" \| ">>=" \| "&=" \| "^=" \| "\|="
‹Expression›	::=	‹List›‹AssignmentExpression›
‹ConstantExpression›	::=	‹ConditionalExpression›

‹Declaration›	::=	‹DeclarationModifier›+ [‹List›‹InitDeclarator›‹Identifier›] ";"
	\|	‹DeclarationSpecifiers› [‹List›‹InitDeclarator›‹AnyIdentifier›] ";"
‹DeclarationSpecifiers›	::=	‹DeclarationModifier›* ‹TaggedTypeSpecifier› ‹DeclarationModifier›*
	\|	‹DeclarationModifier›* ‹TypedefName› ‹DeclarationModifier›*
	\|	‹DeclarationModifier›* {‹PrimTypeSpecifier› ‹DeclarationModifier›*}+
‹DeclarationModifier›	::=	‹StorageClassSpecifier›
	\|	‹TypeQualifier›
	\|	‹FunctionSpecifier›
‹InitDeclarator›X	::=	‹Declarator›X ["=" ‹Initializer›]
‹StorageClassSpecifier›	::=	"typedef" \| "extern" \| "static" \| "auto" \| "register"
‹TypeSpecifier›	::=	‹PrimTypeSpecifier›
	\|	‹TaggedTypeSpecifier›
	\|	‹TypedefName›
‹PrimTypeSpecifier›	::=	"void"
	\|	"char" \| "short" \| "int" \| "long"
	\|	"float" \| "double"
	\|	"signed" \| "unsigned"
	\|	"_Bool" \| "_Complex"
‹TaggedTypeSpecifier›	::=	{"struct" \| "union"} [‹Tag›] "{" ‹StructDeclaration›+ "}"
	\|	{"struct" \| "union"} ‹Tag›
	\|	‹EnumSpecifier›
‹Tag›	::=	‹Identifier›
	\|	‹TypedefName›
‹StructDeclaration›	::=	‹TypeQualifier›+ [‹List›‹StructDeclarator›‹Identifier›] ";"
	\|	‹StructSpecifiers› [‹List›‹StructDeclarator›‹AnyIdentifier›] ";"
‹StructSpecifiers›	::=	‹TypeQualifier›* ‹TaggedTypeSpecifier› ‹TypeQualifier›*
	\|	‹TypeQualifier›* ‹TypedefName› ‹TypeQualifier›*
	\|	‹TypeQualifier›* {‹PrimTypeSpecifier› ‹TypeQualifier›*}+
‹StructDeclarator›X	::=	‹Declarator›X
	\|	[‹Declarator›X] ":" ‹ConstantExpression›
‹EnumSpecifier›	::=	"enum" [‹Tag›] "{" ‹List›‹Enumerator› [","] "}"
	\|	"enum" ‹Tag›
‹Enumerator›	::=	‹AnyIdentifier› ["=" ‹ConstantExpression›]
‹TypeQualifier›	::=	"const" \| "restrict" \| "volatile"
‹FunctionSpecifier›	::=	"inline"
‹Declarator›X	::=	[‹Pointer›] ‹DirectDeclarator›X
‹DirectDeclarator›X	::=	X
	\|	"(" ‹Declarator›X ")"
	\|	‹DirectDeclarator›X "[" ‹TypeQualifier›* [‹AssignmentExpression›] "]"
	\|	‹DirectDeclarator›X "[" "static" ‹TypeQualifier›* ‹AssignmentExpression› "]"
	\|	‹DirectDeclarator›X "[" TypeQualifier+ "static" ‹AssignmentExpression› "]"
	\|	‹DirectDeclarator›X "[" ‹TypeQualifier›* "*" "]"
	\|	‹DirectDeclarator›X "(" ‹ParameterTypeList› ")"
	\|	‹DirectDeclarator›X "(" [‹List›‹Identifier›] ")"
‹Pointer›	::=	{"" ‹TypeQualifier›}+
‹ParameterTypeList›	::=	‹List›‹ParameterDeclaration› ["," "..."]
‹ParameterDeclaration›	::=	‹DeclarationModifier›+ [‹Declarator›‹Identifier›]
	\|	‹DeclarationSpecifiers› [‹Declarator›‹AnyIdentifier›]
	\|	‹DeclarationModifier›+ ‹AbstractDeclarator›
	\|	‹DeclarationSpecifiers› ‹AbstractDeclarator›
‹TypeName›	::=	{‹TypeSpecifier› \| ‹TypeQualifier›}+ [‹AbstractDeclarator›]
‹AbstractDeclarator›	::=	‹Pointer›
	\|	[‹Pointer›] ‹DirectAbstractDeclarator›
‹DirectAbstractDeclarator›	::=	"(" ‹AbstractDeclarator› ")"
	\|	[‹DirectAbstractDeclarator›] "[" ‹TypeQualifier›* [‹AssignmentExpression›] "]"
	\|	[‹DirectAbstractDeclarator›] "[" "static" ‹TypeQualifier›* ‹AssignmentExpression› "]"
	\|	[‹DirectAbstractDeclarator›] "[" ‹TypeQualifier›+ "static" ‹AssignmentExpression› "]"
	\|	[‹DirectAbstractDeclarator›] "[" "*" "]"
	\|	[‹DirectAbstractDeclarator›] "(" [‹ParameterTypeList›] ")"
‹Initializer›	::=	‹AssignmentExpression›
	\|	"{" ‹List›{[‹List›‹Designator› "="] ‹Initializer›} [","] "}"
‹Designator›	::=	"[" ‹ConstantExpression› "]"
	\|	"." ‹AnyIdentifier›

‹Statement›X	::=	‹LabeledStatement›X
	\|	‹CompoundStatement›
	\|	‹ExpressionStatement›
	\|	‹SelectionStatement›X
	\|	‹IterationStatement›X
	\|	‹JumpStatement›
‹LabeledStatement›X	::=	‹AnyIdentifier› ":" ‹Statement›X
	\|	"case" ‹ConstantExpression› ":" ‹Statement›X
	\|	"default" ":" ‹Statement›X
‹CompoundStatement›	::=	"{" ‹BlockItem›* "}"
‹BlockItem›	::=	‹Declaration›
	\|	‹Statement›#t
‹ExpressionStatement›	::=	[‹Expression›] ";"
‹SelectionStatement›X	::=	‹IfStatement›X
	\|	"switch" "(" ‹Expression› ")" ‹Statement›X
‹IfStatement›#t	::=	"if" "(" ‹Expression› ")" ‹Statement›#t ["else" ‹Statement›#t]
‹IfStatement›#f	::=	"if" "(" ‹Expression› ")" ‹Statement›#t "else" ‹Statement›#f
‹IterationStatement›X	::=	"while" "(" ‹Expression› ")" ‹Statement›X
	\|	"do" ‹Statement›#t "while" "(" ‹Expression› ")" ";"
	\|	"for" "(" [‹Expression›] ";" [‹Expression›] ";" [‹Expression›] ")" ‹Statement›X
	\|	"for" "(" ‹Declaration› [‹Expression›] ";" [‹Expression›] ")" ‹Statement›X
‹JumpStatement›	::=	"goto" ‹AnyIdentifier› ";"
	\|	"continue" ";"
	\|	"break" ";"
	\|	"return" [‹Expression›] ";"

‹TranslationUnit›	::=	‹ExternalDefinition›+
‹ExternalDefinition›	::=	‹FunctionDefinition›
	\|	‹Declaration›
‹FunctionDefinition›	::=	‹FunctionHead› [‹List›‹Declaration›] ‹FunctionBody›
‹FunctionHead›	::=	‹DeclarationModifier›+ ‹Declarator›‹Identifier›
	\|	‹DeclarationSpecifiers› ‹Declarator›‹AnyIdentifier›
‹FunctionBody›	::=	‹CompoundStatement›