File Types: Specification

Version: 3        Date: 2014-09-16 Download Version Released Comments 3 2014-09-16 Auto check-in from xdoc download 1.0 2013-11-12 download

The specification given in this document describes version 1.0 of
XC.

The layout of this manual and portions of its text are based upon
the K&R definition of C
. Commentary material
highlighting differences between XC and C is indented and written
in smaller type.

Lexical Conventions

A program consists of one or more translation units stored in
files. It is translated in several phases, which are described in
Preprocessing
. The first phases perform low-level lexical
transformations, carry out directives introduced by lines beginning
with the # character, and perform macro definition and
expansion. When the preprocessing of Preprocessing
is complete,
the program has been reduced to a sequence of tokens.

Tokens

There are six classes of tokens: identifiers, keywords, constants,
string literals, operators, and other separators. Blank spaces,
horizontal tabs, newlines, formfeeds, and comments as described
below, collectively referred to as white space, are ignored
except as they separate tokens. Some white space is required to
separate otherwise adjacent identifiers, keywords and constants.

Comments

Two styles of commenting are supported: the characters /*
introduce a comment, which terminates with the characters */,
and the characters // introduce a comment, which terminates
with a newline. Comments may not be nested, and they may not occur
within string or character literals.

Identifiers

An identifier is a sequence of letters, digits and underscore
(_) characters of any length; the first character must not be a
digit. Upper and lower case letters are different.

Keywords

The following identifiers are reserved for use as keywords and may
not be used otherwise:

auto	else	return	union
break	enum	short	unsigned
case	extern	signed	void
char	for	sizeof	volatile
const	if	static	while
continue	int	struct
default	long	switch
do	register	typedef

The following identifiers are also reserved for use as keywords and
may not be used otherwise:

buffered	inline	out	slave
chan	isnull	par	streaming
chanend	master	port	timer
core	null	select	transaction
in	on	service	when

The construction port:n where n is a
sequence of digits is also a valid identifier. The sequence of
digits is taken to be decimal and is interpreted as an integer
constant. The following identifiers are reserved for compatibility
issues and for future use:

accept	claim	float	restrict
asm	double	module

Constants

There are several kinds of constants. Each has a data type;
Basic Types
discusses the basic types.

constant	::=	integer-constant
	|	character-constant
	|	enumeration-constant
	|	null

Floating-point constants are unsupported.

Integer Constants

A sequence of digits is taken to be binary if preceded by 0b or
0B, octal if preceded by 0, hexadecimal if preceded by
0x or 0X, and decimal otherwise. integer constant may be
suffixed by the letter u or U (unsigned), the letter l
or L (long), or both (unsigned long).

The type of an integer constant depends on its form, value and
suffix. (See Meaning of Identifiers
for a discussion of types.) An
unsuffixed decimal constant has the first of the following types in
which its value can be represented: int, long int,
unsigned long int; an unsuffixed octal or hexadecimal constant
has the first possible of types: int, unsigned int,
long int, unsigned long int. An unsigned constant has
the first possible of types: unsigned int,
unsigned long int; a long constant has the first possible
of types: long int, unsigned long int.

Character Constants

A character constant is a sequence of one or more characters
(excluding the single-quote and newline characters) enclosed in
single quotes. The value of a character constant with a single
character is the numeric value of the character in the machine’s
character set at execution time. The value of a multi-character
constant is implementation-defined.

Wide character constants are unsupported.

The following escape sequences are supported.

newline	NL	\n	backslash	\	\\
horizontal tab	HT	\t	question mark	?	\?
vertical tab	VT	\v	single quote	‘	\'
backspace	BS	\b	double quote	“	\"
carriage return	CR	\r	octal number	ooo	\ooo
formfeed	FF	\f	hex number	hh	\xhh
audible alert	BEL	\a

The escape sequence \ooo requires one, two or three
octal digits. The sequence \xhh requires one or more
hexadecimal digits; its behaviour is undefined if the resulting
character value exceeds that of the largest character. For either
octal or hexadecimal escape characters, if the implementation
treats the char type as signed, the value is sign-extended as if
cast to char type. If any other character follows the \ then
the behaviour is undefined.

Enumeration Constants

Identifiers declared as enumerators (see Enumerations
) are
constants of type int.

Null Constants

The null constant has type null.

String Literals

A string literal is a sequence of zero or more characters
(excluding the double-quote and newline characters) enclosed in
double quotes. It has type “array of characters” and storage class
static (see Storage Class
) initialised with the given
characters. Whether identical string literals are distinct is
implementation-defined, and the behaviour of a program that
attempts to alter a string literal is undefined.

Adjacent string literals are concatenated into a single string.
After any concatenation, a null byte \0 is appended to the
string. All of the character escape sequences are supported.

Syntax Notation

In the syntax notation used in this manual, syntactic categories
are indicated by sans serif type, and literal words and characters by
typewriter style. An optional terminal or nonterminal symbol
carries the subscripted suffix “opt,” so that, for example,

{ expression_opt }

means an optional expression, enclosed
in braces. The terms “zero or more” and “one or more” are
represented using angled brackets along with the star (*) and plus
(+) symbols respectively, so that, for example,

⟨declaration⟩*

means a sequence of zero or more declarations, and

⟨declaration⟩+

means a sequence of one or more declarations.

Meaning of Identifiers

Identifiers (or names) refer collectively to functions, tags of
structures and unions, members of structures or unions, and
objects. An object (or variable) is a location in storage, and its
interpretation depends on its storage class and its type. The
storage class determines the lifetime of the storage associated
with the identifier; the type determines the meaning of the values
found in the identified object. A name also has scope, which is the
region of the program in which it is known, and a linkage, which
determines whether the same name in another scope refers to the
same object or function. Scope and linkage are discussed in
Scope and Linkage
.

Storage Class

An object has either automatic or static storage. Automatic
objects are local to a block (Compound Statement
) and are discarded
on exit from the block. Declarations within a block create
automatic objects if no storage class is mentioned, or if the
auto or register specifier is used.

Static objects may be local to a block or external to all blocks,
but in either case retain their values across exit from and reentry
to functions and blocks. Within a block, static objects are
declared with the keyword static. The objects declared outside
all blocks, at the same level as function definitions, are always
static. They may be made local to a particular translation unit by
use of the static keyword; this gives them file-scope (or
internal linkage). They become global to an entire program by
omitting an explicit storage class, or by using the keyword
extern; this gives them program-scope (or
external linkage).

A function may be declared with the keyword service. This
specifier has no effect on the behaviour of the function; the
extent to which suggestions made by using this specifier are
effective is implementation-defined.

Basic Types

Objects declared as char are large enough to store any member of
the execution character set. If a genuine character from that set
is stored in a char object, its value is equivalent to the
integer code for the character, and is non-negative. Other
quantities may be stored into char variables, but the available
range of values, and especially whether the value is signed, is
implementation-defined.

Objects declared unsigned char consume the same amount of space
as plain characters, but always appear non-negative; explicitly
signed characters declared signed char likewise take the same
space as plain characters.

In addition to the char type, up to three sizes of integer are
available, declared short int, int and long int. Plain
int objects have the natural size suggested by the host machine
architecture. Longer integers provide at least as much storage as
shorter ones, but the implementation may make plain integers
equivalent to either short or long integers. The int types all
represent signed values unless specified otherwise.

Unsigned integers obey the laws of arithmetic modulo
2ⁿ where n is the number of bits in the
representation. The set of non-negative values that can be stored
in a signed object is a subset of the values that can be stored in
the corresponding unsigned object, and the representation for the
overlapping values is the same.

All of the above types are collectively referred to as arithmetic
types, because they can be interpreted as numbers, and as
integral types, because they represent integer values.

The void type specifies an empty set of values; it is used as
the type returned by functions that generate no value.

The C types long long int, float and double are
unsupported.

The chan type specifies a logical communication channel over
which values can be communicated between parallel statements
(Concurrency Statement
). The chanend type specifies one end of a
communication channel.

The locations of at most two implied ends of chan (themselves
chanends) are defined through the use of the channel in at most
two parallel statements (Concurrency Statement
).

Channel ends are used as operands of input and output statements
(Input and Output Statements
). Channels are bidirectional and synchronised:
an outputter waits for a matching inputter to become ready before
data is communicated. Whether a streaming channel is synchronised
or unsynchronised is implementation-defined.

The port type specifies a p-bit register, which interfaces to
a collection of p pins used for communicating with the
environment where p is implementation-defined. The
port:n type specifies an n-bit register, which
interfaces to a collection of p pins used for communicating with
the environment (where p need not equal n). A void port is
a special type of port that may not be used for input or output. A
port also has a notional transfer type and counter type (see
Input and Output Statements
); these types are implementation-defined.

Ports are used as operands of input and output statements
(Input and Output Statements
).

The timer type is a special type of input port that returns the
current time when input from. A void timer is a timer that may
not be used for input. A timer also has a notional counter type (see
Input and Output Statements
); this type is implementation-defined.

The core type specifies a processor core on which ports and
parallel statements may be placed. Objects of core type do not
reserve storage.

Channel ends, ports, timers and cores are collectively referred to
as having resource types. Except for cores, which do not reserve
storage, an object of resource type refers to a location in storage
in which an identifier for the resource is recorded.

chan, chanend, port, timer, core,
buffered and streaming are new.

Derived Types

In addition to the basic types, the following derived types may be
constructed in the following ways:

• Arrays of objects of a given type.
• Functions returning objects of a given type.
• References to objects of a given type.
• Structures containing a sequence of objects of various types.
• Unions capable of containing any one of several objects of
  various types.
• Lists of objects containing a sequence of objects of various
  types.

In general these methods of constructing objects can be applied
recursively.

Lists of types are used in multiple assignment statements
(Multiple Assignment Statement
); pointers are replaced by references (see
Reference Generation
; Function Calls
;
Reference Declarators
).

Type Qualifiers

An object’s type may be qualified const, which announces that
its value will not be changed; its range of values and arithmetic
properties is unaffected.

A port may be qualified in or out, which announces that it
will only be used for input or output operators
(Input and Output Statements
).

Qualifiers are discussed in Function Calls
and
Type Specifiers
.

in and out are new.

Objects and Lvalues

An object is a named region of storage; an lvalue is a
reference to an object. For example, if str is an identifier of
type “1-dimensional array of char” then str[0] is an lvalue
referring to the character object indexed by the first element of
the array str.

A modifiable lvalue is an lvalue which is modifiable: it must not
be an array, and must not have a resource or incomplete type, or be
a function. Also, its type must not be qualified with const; if
it is a structure or union, it must not have any member or,
recursively, submember qualified with const.

Conversions

Some operators, depending on their operands, cause conversion of
the value of an operand from one type to another. This section
explains the results to be expected from such conversions.
It details the conversions demanded by most operators.

Integral Promotion

A character or a short integer, both either signed or not, may be
used in an expression wherever an integer may be used. If an
int can represent all the values of the original type then the
value is converted to int, otherwise the value is converted to
unsigned int.

Integral Conversions

Any integer is converted to a given unsigned type by finding the
smallest non-negative value that is congruent to that integer,
modulo one more than the largest value that can be represented in
the unsigned type.

When any integer is converted to a signed type, its value is
unchanged if it can be represented in the new type, and
implementation-defined otherwise.

Arithmetic Conversions

Many operators cause conversions which bring their operands into a
common type, which is also the type of the result. The rules for
performing these usual arithmetic conversions are as follows:

• First, integral promotions are performed on both operands.
• If either operand is unsigned long int then the other is
  converted to unsigned long int.
• Otherwise, if one operand is long int and the other is
  unsigned int then: if a long int can represent all
  values of an unsigned int then the unsigned int operand is
  converted to long int, otherwise both operands are converted to
  unsigned long int.
• Otherwise, if one operand is long int then the other is
  converted to long int.
• Otherwise, if either operand is unsigned int then the other
  is converted to unsigned int.
• Otherwise both operands have type int.

Void

The (nonexistent) value of a void object may not be used in any
way, and neither explicit nor implicit conversion to any non-void
type may be applied. An object of type void port or
void timer may not be used for input or output.

Expressions

The precedence of expression operators is the same as the order of
the major subsections of this section, highest precedence first.
Within each section, the operators have the same precedence. Left-
or right-associativity is specified in each subsection for the
operators discussed therein.

The precedence and associativity of operators is fully specified.
The order of evaluation of expressions does not, with certain
exceptions, affect the behaviour of the program, even if the
subexpressions involve side effects. In particular, a variable
which is changed in one part of an expression may not unless
otherwise stated appear in any other part of the expression. This
rule applies recursively to all variables which are changed in
functions called in the expression.

The handling of overflow, divide check, and other exceptions in
expression evaluation is implementation-defined.

Reference Generation

If the type of an expression is “array of T,” for some type T,
then the value of the expression is a reference to the array, and
the type of the expression is altered to “reference to array of T.”

Primary Expressions

Primary expressions are variable references, function calls,
constants, strings, or expressions in parentheses:

primary-expression	::=	variable-reference
	|	function-call
	|	constant
	|	string
	|	( expression )

A variable reference is a primary expression, providing the
identifier named (Postfix Expressions
) has been suitably declared as
discussed below; the type of the identifier is specified by its
declaration; the type of the expression is that of the identifier.

A function call is a primary expression; the type of the expression
depends on the return type of the function
(Function Calls
).

A constant is a primary expression; the type of the expression is
that of the constant (which depends on its form discussed in
Constants
).

A string literal is a primary expression; the type of the
expression is “array of char.”

A parenthesised expression is a primary expression whose type and
value are identical to those of the unadorned expression.

Postfix Expressions

The operators in postfix expressions group left to right.

postfix-expression	::=	primary-expression
	|	variable-reference ++
	|	variable-reference --
variable-reference	::=	identifier
	|	variable-reference [ expression ]
	|	variable-reference . identifier
	|	( variable-reference , type-name )
function-call	::=	identifier ( expression-listopt )
expression-list	::=	expression
	|	expression , expression-list

Array References

A variable reference followed by an expression in square brackets
is a subscripted array reference. The variable reference must
either have type “n-array of T” or “reference to an n-array of
T,” where n is the number of dimensions and T is some type,
and the expression must have integral type; the type of the
subscripted variable reference is T. If the value of the
expression is less than zero or greater than or equal to n then
the expression is invalid. See Array Declarators
for further
discussion.

Function Calls

A function call is an identifier followed by parentheses containing
an optional list of comma-separated expressions, which constitute
the arguments to the function. If the identifier has type
“transaction function returning void” then the call must be within
the scope of a transaction statement (Transaction Statement
).
Otherwise, the identifier must have type “function returning T,”
or “select function returning T,” for some type T, in which
case the value of the function call has type T.

Function declarations are limited to file-scope only
(External Declarations
). Implicit function declarations (see K&R §A7.3.2)
are unsupported.

The term argument refers to an expression passed by a function
call, and the term parameter refers to an input object (or its
identifier) received by a function definition, or described in a
function declaration.

If the type of a parameter is “reference to T,” for some T,
then its argument is passed by reference, otherwise the argument is
passed by value. In preparing for the call to a function, a copy is
made of each argument that is passed by value. A function may
change the values of these parameter objects, which are copies of
the argument expressions, but these changes cannot affect the
values of the arguments. For objects that are passed by reference,
a function may change the values that these objects dereference,
thereby affecting the values of the arguments. For the purpose of
disjointness checking, passing an object by reference counts as a
write to that object unless the type of the parameter is qualified
as const or an array of objects qualified as const.

For arguments passed by value, the argument and parameter are
deemed to agree in type if the promoted type of the argument is
that of the parameter itself, without promotion. For arguments
passed by reference, the argument and parameter agree in type only
if the types are equivalent (see Type Equivalence
) ignoring all
qualifiers and array sizes, and obey the following rules:

• An object or an array of objects declared with the qualifier
  const may only be used as an argument to a function with
  parameter qualified const.
• An object declared with the qualifier in may only be used as
  an argument to a function with parameter qualified in or
  void.
• An object declared with the qualifier out may only be used
  as an argument to a function with parameter qualified out or
  void.
• An object declared with the specifier void may only be used
  as an argument to a function with parameter specified void. An
  object not qualified in, out or void may be used as an
  argument to a function with parameter qualified either in,
  out or void.
• An object declared with the qualifier buffered may only be
  used as an argument to a function parameter qualified buffered.
  An object not declared with the qualifier buffered may only be
  used as an argument to a function parameter not qualified
  buffered.
• An object declared with the qualifier streaming may only be
  used as an argument to a function parameter qualified
  streaming. An object not declared with the qualifier
  streaming may only be used as an argument to a function
  parameter not qualified streaming.
• An object declared with an array size of n may only be used as
  an argument to a function parameter that is an array of unknown
  size or of size m where m <= n.
• An object passed to a parameter declared without the qualifier
  const must be an lvalue.

A variable which is changed in one argument may not appear in any
other argument. This rule applies recursively to all variables
appearing in functions called by the arguments.

The arguments passed by value are converted, as if by assignment,
to the types of the corresponding parameters of the function’s
declaration (or prototype). The number of arguments must be the
same as the number of parameters, unless the declaration’s
parameter list ends with the ellipsis notation (, ...). In that
case, the number of arguments must equal or exceed the number of
parameters; trailing integral arguments beyond the explicitly typed
parameters undergo integral promotion (Integral Promotion
).

The order of evaluation of arguments is unspecified, but the arguments
are completely evaluated, including all side effects, before the
function is entered. Recursive calls to any function are
permitted.

The creation of more than one reference to the same object of basic
type, a structure, a union or an array is invalid. The creation of
a reference to a structure, union or array, and to a member or
element recursively contained within is invalid. The creation of
more than one reference to objects contained within distinct
members of a union is invalid.

Structure References

A variable reference followed by a dot followed by an identifier is
a member reference. The variable reference must be a structure or
union, and the identifier must name a member of the structure or
union. The value is the named member of the structure or union, and
its type is the type of the member.

Structures and unions are discussed in Structure and Union Declarations
.

Reinterpretation

A left parenthesis followed by a variable reference followed by a
comma followed by a type name (Type Names
) followed by a
right parenthesis is a reinterpretation cast.

The variable reference must not specify a resource type; its type
must be complete or it must be an incomplete array with the first
dimension missing which, if provided, completes the type. The
variable type name must not be a resource type; it must be
complete.

If the size of the type of the variable reference is unknown
because it references an array parameter with unknown size then the
following two rules apply. First, if the size of the type name is a
compile-time constant T then at run-time if the size of the
variable reference is less than T then the reinterpret operation
is invalid. Second, if the size of the type name is not known at
compile-time because it is an array in which the largest dimension
is unspecified then at run-time the reinterpret operation provides
a value for the dimension d such that the size of the resulting
type is not larger than the size of the type of the variable
reference, but with a value of d + 1 it would be.

If the size of the type of the variable reference is a compile-time
constant V then the following two rules apply. First, if the size
of the type name is a compile-time constant T then T must not
be greater than V. Second, if the size of the type name is
unknown because it references an array in which the largest
dimension is unspecified then a value for this dimension d is
completed at compile-time such that the size of the resulting type
is not larger than V, but with a value of d + 1 it would be.

No arithmetic conversions are performed: the effect of the
reinterpretation is to treat the variable as if it had the
specified type. An array of size zero is a valid reinterpretation;
any attempted index into the array is invalid.

The use of a reinterpreted object may be invalid if it is not
suitably aligned in storage. It is guaranteed only that an object
may be reinterpreted to an object whose type requires less or
equally strict storage alignment; the notion of “alignment” is
implementation-defined, but objects of the char types have the
least strict alignment requirements.

Unary Operators

Expressions with unary operators group right-to-left.

unary-expression	::=	postfix-expression
	|	++ variable-reference
	|	-- variable-reference
	|	unary-operator cast-expression
	|	sizeof unary-expression
	|	sizeof ( type-name )
	|	isnull ( unary-expression )
unary-operator	::=	one of
		+ - ~ !

Prefix Incrementation Operators

A unary expression preceded by a ++ or -- operator is a
unary expression. The operand is incremented (++) or
decremented (--) by 1. The value of the expression is the value
after the incrementation (decrementation). The operand must be a
modifiable lvalue; see the discussion of additive operators
(Additive Operators
) and assignment (Assignment Expressions
) for
details of the operation. The result is not an lvalue.

Unary Plus Operator

The operand of the unary + operator must have arithmetic type,
and the result is the value of its operand. An integral operand
undergoes integral promotion; the type of the result is the type of
the promoted operand.

Unary Minus Operator

The operand of the unary - operator must have arithmetic type,
and the result is the negative of its operand. An integral operand
undergoes integral promotion. The negative of an unsigned quantity
is computed by subtracting the promoted value from the largest
value of the promoted type and adding one; but negative zero is
zero. The type of the result is the type of the promoted operand.

One’s (Bitwise) Complement Operator

The operand of the unary ~ operator must have integral type,
and the result is the one’s complement of its operand. The integral
promotions are performed. If the operand is unsigned, the result is
computed by subtracting the value from the largest value of the
promoted type. If the operand is signed, the result is computed by
converting the promoted operand to the corresponding unsigned type,
applying ~, and converting back to the signed type. The type of
the result is the type of the promoted operand.

Logical Negation Operator

The operand of the ! operator must have arithmetic type, and
the result is 1 if the value of its operand compares equal to 0,
and 0 otherwise. The type of the result is int.

Sizeof Operator

The sizeof operator yields the number of bytes required to
store an object of the type of its operand. The operand is either
an expression, which is not evaluated, or a parenthesised type
name. When sizeof is applied to a char, the result is 1;
when applied to an array, the result is the total number of bytes
in the array. When applied to a structure or union, the result is
the number of bytes in the object, including any padding required
to make the object tile an array: the size of an array of n
elements is n times the size of one element. When applied to a
reference, the result is the number of bytes in the object referred
to. The operator may not be applied to an operand of function type,
of resource type or of an incomplete type. The operator may not be
applied to an operand of reference type where the reference is to
an array of unknown size. The value of the result is
implementation-defined. The result is an unsigned integral
constant; the particular type is implementation-defined.

Isnull Operator

The operand of the isnull operator must be an lvalue. The
result is 1 if its operand has value null, and 0 otherwise. The
type of the result is int.

Casts

A unary expression preceded by the parenthesised name of a type
causes conversion of the value of the expression to the named
type.

cast-expression	::=	unary-expression
	|	( type-name ) cast-expression

This construction is called a cast. The cast must not specify a
structure, a union, an array, or a resource type; neither must the
expression. Type names are described in Type Names
. The
effects of arithmetic conversions are described in
Arithmetic Conversions
. An expression with a cast is not an lvalue.

Multiplicative Operators