WebSVN – tendra.SVN – Diff – /trunk/src/producers/common/c_class.alg

+/*
+ * Copyright (c) 2002-2006 The TenDRA Project <http://www.tendra.org/>.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. Neither the name of The TenDRA Project nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific, prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+ * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $Id$
+ */
 /*
     		 Crown Copyright (c) 1997, 1998
     This TenDRA(r) Computer Program is subject to Copyright
     owned by the United Kingdom Secretary of State for Defence
         it may be put.
 */
 /*
-    TYPE SYSTEM SPECIFICATION
+ * TYPE SYSTEM SPECIFICATION
+ *
-    The main type system for the program is specified using the calculus
+ * The main type system for the program is specified using the calculus tool.
-    tool.  This generates two representations of the type algebra, c_class.
+ * This generates two representations of the type algebra, c_class. The files
-    The files in obj_tok describe the output type system abstractly in terms
+ * in obj_tok describe the output type system abstractly in terms of the TenDRA
-    of the TenDRA '#pragma token' constructs.  These may be used to apply
+ * '#pragma token' constructs. These may be used to apply extremely rigorous
-    extremely rigorous type checking to the program.  The files in obj_c
+ * type checking to the program. The files in obj_c give the implementation of
-    give the implementation of the type system in C terms.  The
+ * the type system in C terms. The implementation specific parts of the
-    implementation specific parts of the program, including the memory
-    management, is handled in obj_c/c_class.c.
+ * program, including the memory management, is handled in obj_c/c_class.c.
-*/
+ */
 ALGEBRA c_class (1.1) :
 /*
-    PRIMITIVE TYPES
+ * PRIMITIVE TYPES
+ *
-    These are the primitive types from which the algebra is built.  int,
+ * These are the primitive types from which the algebra is built. int, unsigned
-    unsigned and string are self-explanitory.  BITSTREAM_P represents a
+ * and string are self-explanitory. BITSTREAM_P represents a series of bits,
-    series of bits, and is used to hold any compiled code.  PPTOKEN_P
+ * and is used to hold any compiled code. PPTOKEN_P represents a list of
-    represents a list of preprocessing tokens, and is used in macro
+ * preprocessing tokens, and is used in macro definitions etc.
-    definitions etc.
-*/
+ */
 int =			"int" ;
 unsigned =		"unsigned" ;
 string =		"character *" ;
 ulong_type (ulong) =	"unsigned long" ;
 BITSTREAM_P (bits) =	"struct bits_tag *" ;
 PPTOKEN_P (pptok) =	"struct pptok_tag *" ;
 /*
-    TYPE REPRESENTING A CONST-VOLATILE SPECIFIER
+ * TYPE REPRESENTING A CONST-VOLATILE SPECIFIER
+ *
-    The const and volatile type qualifiers are represented by an
+ * The const and volatile type qualifiers are represented by an enumeration
-    enumeration type (which is actually a bit pattern).  An additional
+ * type (which is actually a bit pattern). An additional value is used to
-    value is used to indicate lvalues.  Type linkage specifiers are also
+ * indicate lvalues. Type linkage specifiers are also included.
-    included.
-*/
+ */
 enum !CV_SPEC (cv) = {
     none =		0,
     const =		1 << 0,
     volatile =		1 << 1,
     lvalue =		1 << 2,
     c =			1 << 3,
     cpp =		1 << 4,
     qual =		const | volatile,
     mask =		qual | lvalue,
     language =		c | cpp
 } ;
 /*
-    TYPE REPRESENTING A BUILT-IN TYPE
+ * TYPE REPRESENTING A BUILT-IN TYPE
+ *
-    The built-in types have two representations - as a BASE_TYPE (see below)
+ * The built-in types have two representations - as a BASE_TYPE (see below) or
-    or as a BUILTIN_TYPE.  The latter is used primarily as an index into
+ * as a BUILTIN_TYPE. The latter is used primarily as an index into various
-    various tables.
+ * tables.
-*/
+ */
 enum !BUILTIN_TYPE (ntype) = {
     none =		0,
     char =		1,
     schar =		2,
     uchar =		3,
     ellipsis =		21
 } ;
 /*
-    TYPE REPRESENTING A BASIC TYPE
+ * TYPE REPRESENTING A BASIC TYPE
+ *
-    The basic types are represented by an enumeration type (which is
+ * The basic types are represented by an enumeration type (which is actually a
-    actually a bit pattern except for the named type component).  The
+ * bit pattern except for the named type component). The composite bitpatterns
-    composite bitpatterns for the maximally valid combinations are also
+ * for the maximally valid combinations are also given. The elaborated type
-    given.  The elaborated type keys are also represented by this type.
+ * keys are also represented by this type.
-*/
+ */
 enum !BASE_TYPE (btype) = {
     none =		0,
     class =		1,
     struct_ =		2,
     scalar =		int | float | star
 } ;
 /*
-    TYPE REPRESENTING AN INTEGRAL TYPE
+ * TYPE REPRESENTING AN INTEGRAL TYPE
+ *
-    An integral type can be one of the built-in types, an integral promotion
+ * An integral type can be one of the built-in types, an integral promotion
-    type or an arithmetic conversion type.  The promotion type for each
+ * type or an arithmetic conversion type. The promotion type for each integral
-    integral type is stored as part of its definition.
+ * type is stored as part of its definition.
-*/
+ */
 union INT_TYPE (itype) = {
     TYPE prom ;
     LIST TYPE cases ;
     BUILTIN_TYPE unprom = "ntype_none" ;
 	NAT size ;
 	DECL_SPEC info ;
     },
     promote -> {
 	/* Promotion types */
 	INT_TYPE arg ;
     },
     arith -> {
 	/* Arithmetic conversion types */
 	INT_TYPE arg1, arg2 ;
     },
     literal -> {
 	/* Target dependent literal type */
 	NAT nat ;
 	int spec ;
 	int form, suff ;
 	IDENTIFIER tok ;
     },
     token -> {
 	/* Tokenised integral type */
 	IDENTIFIER tok ;
 	LIST TOKEN args ;
     }
 } ;
 /*
-    TYPE REPRESENTING A FLOATING POINT TYPE
+ * TYPE REPRESENTING A FLOATING POINT TYPE
+ *
-    A floating point type can be one of the built-in types or an arithmetic
+ * A floating point type can be one of the built-in types or an arithmetic
-    conversion type.  Note that all floating point types are their own
+ * conversion type. Note that all floating point types are their own arithmetic
-    arithmetic promotions, but they do have distinct argument promotions.
+ * promotions, but they do have distinct argument promotions.
-*/
+ */
 union FLOAT_TYPE (ftype) = {
     TYPE arg_prom ;
     ulong_type ftok = "LINK_NONE" ;
     ulong_type ntok = "LINK_NONE" ;
     ulong_type diag = "LINK_NONE" ;
+    }
 } ;
 /*
-    TYPE REPRESENTING CLASS INFORMATION
+ * TYPE REPRESENTING CLASS INFORMATION
+ *
-    This type is a bitpattern giving information about a class, for example,
+ * This type is a bitpattern giving information about a class, for example, if
-    if it is complete, whether it has base classes, non-static data members,
+ * it is complete, whether it has base classes, non-static data members, and so
-    and so on.
+ * on.
-*/
+ */
 enum !CLASS_INFO (cinfo) = {
     none =		0,
     complete =		1 << 0,		/* completed definition */
     defined =		1 << 1,		/* started definition */
     default =		implicit | empty | pod
 } ;
 /*
-    TYPE REPRESENTING CLASS USAGE INFORMATION
+ * TYPE REPRESENTING CLASS USAGE INFORMATION
+ *
-    This type is a bitpattern used to represent information on how a class
+ * This type is a bitpattern used to represent information on how a class is
-    is used.
+ * used.
-*/
+ */
 enum !CLASS_USAGE (cusage) = {
     none =		0,
     address =		1 << 0,		/* address of incomplete */
     destr =		1 << 1,		/* destroyed incomplete */
     delete_array =	1 << 3		/* deleted incomplete array */
 } ;
 /*
-    TYPE REPRESENTING A CLASS TYPE
+ * TYPE REPRESENTING A CLASS TYPE
+ *
-    A class type has an associated type name, type key (class, struct or
+ * A class type has an associated type name, type key (class, struct or union),
-    union), and class information.  The hash table entries for the
+ * and class information. The hash table entries for the constructors and
-    constructors and destructors, plus a list of the conversion functions
+ * destructors, plus a list of the conversion functions on the class are
-    on the class are maintained within the class definition.  The class
+ * maintained within the class definition. The class members themselves are
-    members themselves are just a namespace.  The base classes are
+ * just a namespace. The base classes are represented by a graph.
-    represented by a graph.
-*/
+ */
 union CLASS_TYPE (ctype) = {
     IDENTIFIER name ;
     CLASS_INFO info ;
     CLASS_USAGE usage ;
+    }
 } ;
 /*
-    TYPE REPRESENTING A GRAPH OF DERIVED CLASSES
+ * TYPE REPRESENTING A GRAPH OF DERIVED CLASSES
+ *
-    This type is used to represent the directed acyclic graphs of base
+ * This type is used to represent the directed acyclic graphs of base classes
-    classes associated with a class.  Each node of this graph consists
+ * associated with a class. Each node of this graph consists of a class and a
-    of a class and a list of its base classes.  The access of each base
+ * list of its base classes. The access of each base class, and other
-    class, and other information, is recorded.  Identical virtual bases
+ * information, is recorded. Identical virtual bases are linked using the equal
-    are linked using the equal field.  The next field is used to link
+ * field. The next field is used to link all instances of a class within a
-    all instances of a class within a graph, whether virtual or not.
+ * graph, whether virtual or not.
-*/
+ */
 union GRAPH (graph) = {
     CLASS_TYPE head ;
     DECL_SPEC access ;
     LIST GRAPH tails = "NULL_list ( GRAPH )" ;
+    }
 } ;
 /*
-    TYPE REPRESENTING A VIRTUAL FUNCTION
+ * TYPE REPRESENTING A VIRTUAL FUNCTION
+ *
-    This type is used to represent a virtual function table or an entry
+ * This type is used to represent a virtual function table or an entry of such
-    of such a table.  Each table entry has an associated function plus
+ * a table. Each table entry has an associated function plus information on
-    information on where this was inherited from and any difference in
+ * where this was inherited from and any difference in the return type of an
-    the return type of an overriding function.
+ * overriding function.
-*/
+ */
 union VIRTUAL (virt) = {
     IDENTIFIER func ;
     ulong_type no ;
     GRAPH base ;
+    }
 } ;
 /*
-    TYPE REPRESENTING AN ENUMERATION TYPE
+ * TYPE REPRESENTING AN ENUMERATION TYPE
+ *
-    An enumeration type has an associated type name, a class information
+ * An enumeration type has an associated type name, a class information field
-    field (which is only used to indicate whether the type is complete),
+ * (which is only used to indicate whether the type is complete), and an
-    and an underlying integral type.  The enumerators themselves are given
+ * underlying integral type. The enumerators themselves are given as a simple
-    as a simple list (note that they do not form a namespace).
+ * list (note that they do not form a namespace).
-*/
+ */
 union ENUM_TYPE (etype) = {
     IDENTIFIER name ;
     CLASS_INFO info ;
     TYPE rep ;
     EXP value = "NULL_exp" ;
     ulong_type plus = "0" ;
 } + {
     basic -> {
 	/* empty */
     }
 } ;
 /*
-    TYPE REPRESENTING A TYPE
+ * TYPE REPRESENTING A TYPE
+ *
-    The types are represented by a union type, with one field per type
+ * The types are represented by a union type, with one field per type
-    class.  Any type may be qualified using const, volatile and lvalue.
+ * class. Any type may be qualified using const, volatile and lvalue.
-*/
+ */
 union TYPE (type) = {
     /* Type qualifiers */
     CV_SPEC qual ;
     IDENTIFIER name = "NULL_id" ;
 } + {
     pre -> {
 	/* Pre-types (used during parsing only) */
 	BASE_TYPE rep ;
 	QUALIFIER nqual ;
     },
     integer -> {
 	/* Integer types */
 	INT_TYPE rep ;
 	INT_TYPE sem ;
     },
 	FLOAT_TYPE rep ;
 	FLOAT_TYPE sem ;
     },
     top, bottom -> {
 	/* The void types */
     },
     ptr, ref -> {
 	/* Pointer and reference types */
 	TYPE sub ;
     },
     ptr_mem -> {
+    }
 } ;
 /*
-    TYPE REPRESENTING A DECLARATION SPECIFIER
+ * TYPE REPRESENTING A DECLARATION SPECIFIER
+ *
-    The basic declaration specifiers (i.e. the storage class specifiers,
+ * The basic declaration specifiers (i.e. the storage class specifiers, the
-    the function specifiers, friend and typedef) are represented by an
+ * function specifiers, friend and typedef) are represented by an enumeration
-    enumeration type (which is actually a bit pattern).  Other declaration
+ * type (which is actually a bit pattern). Other declaration and linkage
-    and linkage information is also included, including access specifiers.
+ * information is also included, including access specifiers. The fact that
-    The fact that public < protected < private is used extensively.  The
+ * public < protected < private is used extensively. The values none, static
-    values none, static and extern are also used to specify the linkage of
+ * and extern are also used to specify the linkage of an object.
-    an object.
-*/
+ */
 enum DECL_SPEC (dspec) = {
     none =		0,
     used =		1 << 0,
     called =		1 << 1,
 			reserve | temp | template | token | trivial
 } ;
 /*
-    TYPE REPRESENTING A HASH TABLE ENTRY
+ * TYPE REPRESENTING A HASH TABLE ENTRY
+ *
-    Identifier names are represented by a hash table entry.  There are
+ * Identifier names are represented by a hash table entry. There are several
-    several different types of names (simp1e strings, destructor names and
+ * different types of names (simp1e strings, destructor names and so on). Each
-    so on).  Each hash table entry contains, in effect, a built-in namespace
+ * hash table entry contains, in effect, a built-in namespace member indicating
-    member indicating the underlying meaning of this name.  It also contains
+ * the underlying meaning of this name. It also contains the hash value for
-    the hash value for this entry.
+ * this entry.
-*/
+ */
 union HASHID (hashid) = {
     IDENTIFIER id = "NULL_id" ;
     IDENTIFIER cache = "NULL_id" ;
     HASHID next ;
+    }
 } ;
 /*
-    TYPE REPRESENTING AN IDENTIFIER QUALIFIER
+ * TYPE REPRESENTING AN IDENTIFIER QUALIFIER
+ *
-    These values are used to identify how an identifier is qualified,
+ * These values are used to identify how an identifier is qualified, either
-    either unqualified, a nested qualifier (for example A::B::n), a full
+ * unqualified, a nested qualifier (for example A::B::n), a full nested
-    nested qualifier (for example ::A::B::n), or a top nested qualifier
+ * qualifier (for example ::A::B::n), or a top nested qualifier (for example
-    (for example ::n).  A value to mark resolved overloaded functions
+ * ::n). A value to mark resolved overloaded functions is also included.
-    is also included.
-*/
+ */
 enum !QUALIFIER (qual) = {
     none =		0,
     nested =		1,
     full =		2,
     top =		3,
     mark =		4,
     explicit =		nested | full | top
 } ;
 /*
-    TYPE REPRESENTING AN IDENTIFIER
+ * TYPE REPRESENTING AN IDENTIFIER
+ *
-    Identifiers have an associated hash table entry, indicating the
+ * Identifiers have an associated hash table entry, indicating the identifier
-    identifier name, plus a location indicating where the identifier was
+ * name, plus a location indicating where the identifier was first declared.
-    first declared.  The various things an identifier can represent are
+ * The various things an identifier can represent are given by the different
-    given by the different fields of the union.
+ * fields of the union.
-*/
+ */
 union IDENTIFIER (id) = {
     HASHID name ;
     DECL_SPEC storage ;
     NAMESPACE parent ;
     member -> {
 	/* Simple data member */
 	TYPE type ;
 	OFFSET off = "NULL_off" ;
 	GRAPH base = "NULL_graph" ;
     },
     enumerator -> {
 	/* Enumerators */
 	TYPE etype ;
 	EXP value ;
     },
+    }
 } ;
 /*
-    TYPE REPRESENTING A NAMESPACE MEMBER
+ * TYPE REPRESENTING A NAMESPACE MEMBER
+ *
-    There are two kinds of namespace member, small and large, corresponding
+ * There are two kinds of namespace member, small and large, corresponding to
-    to the two kinds of namespace.  The important section consists of two
+ * the two kinds of namespace. The important section consists of two
-    identifiers, giving the current meanings of a name in the namespace.
+ * identifiers, giving the current meanings of a name in the namespace.
-    Everything else is just links to other members.
+ * Everything else is just links to other members.
-*/
+ */
 union MEMBER (member) = {
     IDENTIFIER id = "NULL_id" ;
     IDENTIFIER alt = "NULL_id" ;
     MEMBER next ;
+    }
 } ;
 /*
-    TYPE REPRESENTING A NAMESPACE
+ * TYPE REPRESENTING A NAMESPACE
+ *
-    There are two kinds of namespace, small and large.  The small namespaces
+ * There are two kinds of namespace, small and large. The small namespaces are
-    are the block and parameter spaces, the large ones are the class and
+ * the block and parameter spaces, the large ones are the class and namespace
-    namespace spaces.  Every namespace has an associated namespace name
+ * spaces. Every namespace has an associated namespace name (which may be the
-    (which may be the null identifier).  A small namespace consists of a
+ * null identifier). A small namespace consists of a simple linked list of
-    simple linked list of small members (in reverse order of declaration).
+ * small members (in reverse order of declaration). A large namespace consists
-    A large namespace consists of a hash table of large members, plus a list
+ * of a hash table of large members, plus a list of all such members in order
-    of all such members in order of declaration.  The distinct orders reflect
+ * of declaration. The distinct orders reflect the distinct purposes the two
-    the distinct purposes the two kinds of namespace are put to.
+ * kinds of namespace are put to.
-*/
+ */
 union NAMESPACE (nspace) = {
     IDENTIFIER name ;
     MEMBER last = "NULL_member" ;
     MEMBER prev = "NULL_member" ;
+    }
 } ;
 /*
-    TYPE REPRESENTING AN INTEGER LITERAL
+ * TYPE REPRESENTING AN INTEGER LITERAL
+ *
-    An integer literal (or constant integral expression) is represented by
+ * An integer literal (or constant integral expression) is represented by a
-    a sign and a list of numbers in the range [0,0xffff] representing the
+ * sign and a list of numbers in the range [0,0xffff] representing the value
-    value base 0x10000.  The case where there is only one digit is dealt
+ * base 0x10000. The case where there is only one digit is dealt with
-    with separately.  It is also possible to form an integer literal from
+ * separately. It is also possible to form an integer literal from an
-    an expression.
+ * expression.
-*/
+ */
 union NAT (nat) = {
     /* empty */
 } + {
     small -> {
+    }
 } ;
 /*
-    TYPE REPRESENTING A FLOATING POINT LITERAL
+ * TYPE REPRESENTING A FLOATING POINT LITERAL
+ *
-    A floating point literal is represented by a sign, two strings giving
+ * A floating point literal is represented by a sign, two strings giving the
-    the digits before and after the decimal point, plus an exponent.
+ * digits before and after the decimal point, plus an exponent.
-*/
+ */
 union FLOAT (flt) = {
     ulong_type tok = "LINK_NONE" ;
 } + {
     simple -> {
 	/* Simple literal */
 	string int_part ;
 	string frac_part ;
 	NAT exponent ;
+    }
 } ;
 /*
-    TYPE REPRESENTING A STRING LITERAL
+ * TYPE REPRESENTING A STRING LITERAL
+ *
-    A string literal consists of a sequence of characters of a given length.
+ * A string literal consists of a sequence of characters of a given length.
-    Characters, wide characters, strings and wide strings are represented
+ * Characters, wide characters, strings and wide strings are represented by
-    by distinct fields of the union.
+ * distinct fields of the union.
-*/
+ */
 union STRING (str) = {
     STRING next = "NULL_str" ;
 } + {
     simple -> {
+    }
 } ;
 /*
-    TYPE REPRESENTING A TEST
+ * TYPE REPRESENTING A TEST
+ *
-    Test and comparison operators are represented by an enumeration type
+ * Test and comparison operators are represented by an enumeration type which
-    which happen to be in the same order as the TDF encoding.  Complementary
+ * happen to be in the same order as the TDF encoding. Complementary tests
-    tests (for example '<' and '>=') always add up to the same value, negate.
+ * (for example '<' and '>=') always add up to the same value, negate.
-*/
+ */
 enum !NTEST (ntest) = {
     eq =		0,
     greater =		1,
     greater_eq =	2,
     not_not_eq =	10,
     none =		11,
     negate =		eq + not_eq,
     not =		not_eq,
     not_not =		not_not_eq
 } ;
 /*
-    TYPE REPRESENTING A ROUNDING MODE
+ * TYPE REPRESENTING A ROUNDING MODE
+ *
-    Floating point rounding modes are represented by an enumeration type
+ * Floating point rounding modes are represented by an enumeration type which
-    which happen to be in the same order as the TDF encoding.
+ * happen to be in the same order as the TDF encoding.
-*/
+ */
 enum !RMODE (rmode) = {
     as_state =		0,
     to_nearest =	1,
     to_larger =		2,
     to_smaller =	3,
     to_zero =		4
 } ;
 /*
-    TYPE REPRESENTING AN EXPRESSION OR STATEMENT
+ * TYPE REPRESENTING AN EXPRESSION OR STATEMENT
+ *
-    The expressions and statements are represented by a union type, with one
+ * The expressions and statements are represented by a union type, with one
-    field per expression or statement class.  Every expression has an
+ * field per expression or statement class. Every expression has an associated
-    associated type.
+ * type.
-*/
+ */
 union EXP (exp) = {
     /* Expression type */
     TYPE type ;
 } + {
 	/* Variable analysis operators */
 	EXP arg ;
     },
     reach, unreach -> {
 	/* Flow analysis operators */
 	EXP parent = "NULL_exp" ;
 	EXP body ;
     },
     sequence -> {
 	/* Sequence of statements */
 	EXP parent = "NULL_exp" ;
 	LIST EXP first, last ;
 	EXP body ;
 	ulong_type diag = "LINK_NONE" ;
     },
     exception -> {
 	/* Throw expression */
 	EXP arg ;
 	EXP size, destr ;
 	int expl ;
     },
     thrown -> {
 	/* Caught expression */
+    }
 } ;
 /*
-    TYPE REPRESENTING AN OFFSET
+ * TYPE REPRESENTING AN OFFSET
+ *
-    This type is used to represent an offset between two pointers.  The
+ * This type is used to represent an offset between two pointers. The type
-    type construct gives the offset between successive elements of an
+ * construct gives the offset between successive elements of an array of that
-    array of that type.  The other constructs are fairly obvious.
+ * type. The other constructs are fairly obvious.
-*/
+ */
 union OFFSET (off) = {
     /* empty */
 } + {
     zero -> {
 	/* Zero offset */
 	TYPE type ;
     },
     type -> {
 	/* Type offset */
 	TYPE type ;
     },
     array -> {
 	/* Array offset */
+    }
 } ;
 /*
-    TYPE REPRESENTING A TOKEN
+ * TYPE REPRESENTING A TOKEN
+ *
-    This type is used to represent a TDF token.  The various fields
+ * This type is used to represent a TDF token. The various fields correspond to
-    correspond to the kinds of token - expressions, statements, types etc.
+ * the kinds of token - expressions, statements, types etc. Each simple
-    Each simple component also contains a field for holding a value of
+ * component also contains a field for holding a value of that kind, thus a
-    that kind, thus a list of token arguments can themselves be expressed
+ * list of token arguments can themselves be expressed as a list of tokens.
-    as a list of tokens.
-*/
+ */
 union TOKEN (tok) = {
     /* empty */
 } + {
     exp -> {
 	/* Expression tokens */
 	TYPE type ;
 	int constant ;
 	EXP value ;
     },
     stmt -> {
 	/* Statement tokens */
+    }
 } ;
 /*
-    TYPE REPRESENTING A TEMPLATE INSTANCE
+ * TYPE REPRESENTING A TEMPLATE INSTANCE
+ *
-    A template instance consists of an identifier, a type giving the
+ * A template instance consists of an identifier, a type giving the template
-    template form and a specifier giving declaration information.
+ * form and a specifier giving declaration information.
-*/
+ */
 union INSTANCE (inst) = {
     TYPE form ;
     INSTANCE alias = "%0" ;
     INSTANCE next ;
+    }
 } ;
 /*
-    TYPE REPRESENTING A VARIABLE ANALYSIS STATE
+ * TYPE REPRESENTING A VARIABLE ANALYSIS STATE
+ *
-    This type is used in the variable analysis routines to record the
+ * This type is used in the variable analysis routines to record the state of a
-    state of a local variable.
+ * local variable.
-*/
+ */
 struct VARIABLE (var) = {
     IDENTIFIER id ;
     DECL_SPEC info ;
 } ;
 /*
-    TYPE REPRESENTING AN ERROR
+ * TYPE REPRESENTING AN ERROR
+ *
-    An error can be either a simple message, described by an error number,
+ * An error can be either a simple message, described by an error number, or a
-    or a compound formed from two other errors.  Some trickery is used to
+ * compound formed from two other errors. Some trickery is used to store the
-    store the arguments for a simple error after its size field.
+ * arguments for a simple error after its size field.
-*/
+ */
 union ERROR (err) = {
     int severity ;
 } + {
     simple -> {
     compound -> {
 	/* Compound errors */
 	ERROR head, tail ;
+    }
 } ;
 /*
-    TYPE REPRESENTING A FILE POSITION
+ * TYPE REPRESENTING A FILE POSITION
+ *
-    A file position consists of a line number plus a pointer to a type
+ * A file position consists of a line number plus a pointer to a type giving
-    giving the file name.
+ * the file name.
-*/
+ */
 struct LOCATION (loc) = {
     ulong_type line ;
     ulong_type column ;
     PTR POSITION posn ;

Subversion Repositories tendra.SVN

(root)/trunk/src/producers/common/c_class.alg – Rev 2 → 7