%prefixes%

terminal = lex_;


%maps%


/*
 *  ENTRY POINT
 *
 *  The main entry point for is mapped onto a function named read_spec.
 */

specification -> read_spec;


/*
 *  TYPE MAPPINGS
 *
 *  These maps give the relationship between the types used in the syntax
 *  and in the C implementation.
 */

BOOLEAN -> int;
COMMAND -> SID_COMMAND;
COMMAND_KEY -> int;
IDENTIFIER -> SID_IDENTIFIER;
STRING -> SID_STRING;
SUBSET_KEY -> SID_STRING;
TYPE -> SID_TYPE;
TYPE_KEY -> int;
TYPE_LIST -> SID_TYPE;
TYPE_QUAL -> unsigned;
TYPE_SPEC -> unsigned;
VERSION -> int;


%header% @{
/*
 * Copyright (c) 2002, The Tendra Project <http://www.ten15.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 unmodified, 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 *
 *  		 Crown Copyright (c) 1997
 *
 *  This TenDRA(r) Computer Program is subject to Copyright
 *  owned by the United Kingdom Secretary of State for Defence
 *  acting through the Defence Evaluation and Research Agency
 *  (DERA).  It is made available to Recipients with a
 *  royalty-free licence for its use, reproduction, transfer
 *  to other parties and amendment for any purpose not excluding
 *  product development provided that any such use et cetera
 *  shall be deemed to be acceptance of the following conditions:-
 *
 *      (1) Its Recipients shall ensure that this Notice is
 *      reproduced upon any copies or amended versions of it;
 *
 *      (2) Any amended version of it shall be clearly marked to
 *      show both the nature of and the organisation responsible
 *      for the relevant amendment or amendments;
 *
 *      (3) Its onward transfer from a recipient to another
 *      party shall be deemed to be that party's acceptance of
 *      these conditions;
 *
 *      (4) DERA gives no warranty or assurance as to its
 *      quality or suitability for any purpose and DERA accepts
 *      no liability whatsoever in relation to any use to which
 *      it may be put.
 *
 * $TenDRA: tendra/src/tools/tspec/syntax.act,v 1.9 2005/10/31 10:17:01 stefanf Exp $
 */


#include "config.h"
#include "cstring.h"
#include "msgcat.h"

#include "object.h"
#include "hash.h"
#include "lex.h"
#include "name.h"
#include "syntax.h"
#include "type.h"
#include "utility.h"
#include "variable.h"


/*
 *  PARSER TYPES
 *
 *  These types give the implementations of the various types used
 *  in the syntax.
 */

typedef char *SID_STRING;
typedef type *SID_TYPE;

typedef struct {
    char *iname;
    char *ename;
    int ivers;
    int evers;
} SID_IDENTIFIER;


/*
 *  CURRENT FIELD NAME
 *
 *  The name of the current structure is stored during a +FIELD
 *  construct.
 */

static char *crt_field_name = null;
static int anon_no = 0;


/*
 *  CV-QUALIFIER NAMES
 *
 *  This table gives the mapping between the values used to represent
 *  cv-qualifiers in the parser and the qualifier names used in the
 *  internal representation.
 */

static char *cv_qualifier [] = {
    null, "const", "restrict", "const restrict",
    "volatile", "const volatile", "const restrict volatile"
};

/*
 *  COMPILATION MODE
 *
 *  We allow unreached code in the automatically generated sections.
 */

#ifdef __TenDRA__
#pragma TenDRA begin
#pragma TenDRA unreachable code allow
#pragma TenDRA variable analysis off
#endif


@}, @{
/*
 * Copyright (c) 2002, The Tendra Project <http://www.ten15.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 unmodified, 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 *
 *  		 Crown Copyright (c) 1997
 *
 *  This TenDRA(r) Computer Program is subject to Copyright
 *  owned by the United Kingdom Secretary of State for Defence
 *  acting through the Defence Evaluation and Research Agency
 *  (DERA).  It is made available to Recipients with a
 *  royalty-free licence for its use, reproduction, transfer
 *  to other parties and amendment for any purpose not excluding
 *  product development provided that any such use et cetera
 *  shall be deemed to be acceptance of the following conditions:-
 *
 *      (1) Its Recipients shall ensure that this Notice is
 *      reproduced upon any copies or amended versions of it;
 *
 *      (2) Any amended version of it shall be clearly marked to
 *      show both the nature of and the organisation responsible
 *      for the relevant amendment or amendments;
 *
 *      (3) Its onward transfer from a recipient to another
 *      party shall be deemed to be that party's acceptance of
 *      these conditions;
 *
 *      (4) DERA gives no warranty or assurance as to its
 *      quality or suitability for any purpose and DERA accepts
 *      no liability whatsoever in relation to any use to which
 *      it may be put.
 *
 * $TenDRA: tendra/src/tools/tspec/syntax.act,v 1.9 2005/10/31 10:17:01 stefanf Exp $
 */


#ifndef SYNTAX_INCLUDED
#define SYNTAX_INCLUDED

typedef object *SID_COMMAND;
@};


%terminals%


/*
 *  TERMINALS
 *
 *  The mapping of the terminals is trivial.
 */

name: () -> (s) = @{ @s = token_value; @};
number: () -> (s) = @{ @s = token_value; @};
string: () -> (s) = @{ @s = token_value; @};
variable: () -> (s) = @{ @s = token_value; @};
comment: () -> (s) = @{ @s = token_value; @};
insert: () -> (s) = @{ @s = token_value; @};
build-insert: () -> (s) = @{ @s = token_value; @};


%actions%


/*
 *  BOOLEAN CONSTANTS
 *
 *  These actions describe the boolean constants.
 */

<bool_false>: () -> (b) = @{ @b = 0; @};
<bool_true>: () -> (b) = @{ @b = 1; @};


/*
 *  BASIC TYPE SPECIFIERS
 *
 *  These actions describe the basic type specifiers.
 */

<btype_char>: () -> (b) = @{ @b = BTYPE_CHAR; @};
<btype_short>: () -> (b) = @{ @b = BTYPE_SHORT; @};
<btype_int>: () -> (b) = @{ @b = BTYPE_INT; @};
<btype_long>: () -> (b) = @{ @b = BTYPE_LONG; @};
<btype_signed>: () -> (b) = @{ @b = BTYPE_SIGNED; @};
<btype_unsigned>: () -> (b) = @{ @b = BTYPE_UNSIGNED; @};
<btype_float>: () -> (b) = @{ @b = BTYPE_FLOAT; @};
<btype_double>: () -> (b) = @{ @b = BTYPE_DOUBLE; @};
<btype_void>: () -> (b) = @{ @b = BTYPE_VOID; @};

<btype_join>: (a, b) -> (c) = @{
    while (@a & @b) {
	if (@a == BTYPE_LONG && allow_long_long) {
	    @a = BTYPE_LLONG;
	} else {
	    MSG_duplicate_type_specifier ();
	    break;
	}
    }
    @c = (@a | @b);
@};


/*
 *  TYPE KEYS
 *
 *  These actions describe the type keys.
 */

<key_type>: () -> (t) = @{ @t = TYPE_GENERIC; @};
<key_struct_tag>: () -> (t) = @{ @t = TYPE_STRUCT_TAG; @};
<key_union_tag>: () -> (t) = @{ @t = TYPE_UNION_TAG; @};
<key_enum_tag>: () -> (t) = @{ @t = TYPE_ENUM_TAG; @};
<key_struct>: () -> (t) = @{ @t = TYPE_STRUCT; @};
<key_union>: () -> (t) = @{ @t = TYPE_UNION; @};
<key_enum>: () -> (t) = @{ @t = TYPE_ENUM; @};
<key_int>: () -> (t) = @{ @t = TYPE_INT; @};
<key_signed>: () -> (t) = @{ @t = TYPE_SIGNED; @};
<key_unsigned>: () -> (t) = @{ @t = TYPE_UNSIGNED; @};
<key_float>: () -> (t) = @{ @t = TYPE_FLOAT; @};
<key_arith>: () -> (t) = @{ @t = TYPE_ARITH; @};
<key_scalar>: () -> (t) = @{ @t = TYPE_SCALAR; @};
<key_lvalue>: () -> (t) = @{ @t = TYPE_LVALUE; @};
<key_rvalue>: () -> (t) = @{ @t = TYPE_RVALUE; @};

<key_exp>: (c, a) -> (t) = @{
    if (@c == OBJ_CONST) {
	if (@a == TYPE_LVALUE) {
	    MSG_constant_cant_be_lvalue ();
	}
	@t = TYPE_RVALUE;
    } else if (@c == OBJ_EXTERN) {
	@t = TYPE_LVALUE;
    } else {
	@t = @a;
    }
@};


/*
 *  TYPE QUALIFIERS
 *
 *  These actions describe the type qualifiers.  const is represented by 1,
 *  restrict by 2 and volatile by 4.
 */

<cv_none>: () -> (c) = @{
    @c = 0;
@};

<cv_const>: (a) -> (c) = @{
    if (@a & 1) MSG_duplicate_type_qualifier ();
    @c = (@a | 1);
@};

<cv_restrict>: (a) -> (c) = @{
    if (@a & 2) MSG_duplicate_type_qualifier ();
    @c = (@a | 2);
@};

<cv_volatile>: (a) -> (c) = @{
    if (@a & 4) MSG_duplicate_type_qualifier ();
    @c = (@a | 4);
@};

/*
 *  TYPE CONSTRUCTORS
 *
 *  These actions describe the type constructors.
 */

<type_none>: () -> (t) = @{
    @t = null;
@};

<type_builtin>: (b) -> (t) = @{
    @t = basic_type (@b);
@};

<type_name>: (s, tag) -> (t) = @{
    @t = find_type (@s, any_version, @tag, 1);
@};

<type_special>: (s) -> (t) = @{
    @t = special_type (@s);
@};

<type_inject>: (s, p) -> (t) = @{
    @t = inject_type (@s, @p);
@};

<type_ptr>: (c) -> (t) = @{
    @t = make_subtype ((type *) null, TYPE_PTR);
    @t->v.str = cv_qualifier [@c];
@};

<type_array>: (a) -> (t) = @{
    @t = make_subtype ((type *) null, TYPE_ARRAY);
    @t->v.str = @a;
@};

<type_bitfield>: (a) -> (t) = @{
    @t = make_subtype ((type *) null, TYPE_BITFIELD);
    @t->v.str = @a;
@};

<type_func>: (p) -> (t) = @{
    @t = make_subtype ((type *) null, TYPE_PROC);
    @t->v.next = @p;
@};

<type_macro>: (p) -> (t) = @{
    @t = make_subtype ((type *) null, TYPE_PROC);
    @t->v.next = @p;
@};

<type_qualify>: (s, c) -> (t) = @{
    @t = make_subtype (@s, TYPE_QUALIFIER);
    @t->v.str = cv_qualifier [@c];
@};

<type_lvalue>: (s, lv) -> (t) = @{
    @t = make_subtype (@s, @lv);
@};


/*
 *  TYPE LISTS
 *
 *  These actions describe the parameter type lists.
 */

<type_list_none>: () -> (p) = @{
    @p = null;
@};

<type_list_empty>: () -> (p) = @{
    MSG_empty_parameter_list ();
    @p = null;
@};

<type_list_cons>: (t, q) -> (p) = @{
    @p = make_subtype (@t, TYPE_LIST);
    @p->v.next = @q;
@};

<type_list_ellipsis>: () -> (p) = @{
    @p = make_subtype (type_ellipsis, TYPE_LIST);
    @p->v.next = null;
@};

<param_name>: (nm) -> () = @{
    UNUSED (@nm);
@};


/*
 *  CONSTANT EXPRESSIONS
 *
 *  These actions describe the constant expressions.
 */

<value_none>: () -> (s) = @{
    @s = "";
@};

<value_negate>: (a) -> (s) = @{
    @s = string_concat ("-", @a);
@};

<value_not>: (a) -> (s) = @{
    @s = string_concat ("!", @a);
@};

<value_nat>: (a) -> (s) = @{
    object *p = search_hash (exps, @a, any_version);
    if (p == null) {
	MSG_undefined_nat (@a);
    } else if (p->objtype != OBJ_NAT) {
	MSG_not_a_nat (@a);
    }
    @s = @a;
@};


/*
 *  CONDITIONAL COMPILATION MACROS
 *
 *  These rules describe the special macros which can be used in
 *  conditional compilation.
 */

<cond_building>: () -> (s) = @{
    @s = BUILDING_MACRO;
@};

<cond_protect>: (a, b) -> (s) = @{
    @s = macro_name (PROTECT_PREFIX, @a, @b, NULL);
@};


/*
 *  MACRO DEFINITION PARAMETERS
 *
 *  These rules describe the macro definition parameter lists.
 */

<param_none>: () -> (p) = @{ @p = null; @};
<param_empty>: () -> (p) = @{ @p = ""; @};

<param_join>: (n, q) -> (p) = @{
    @p = string_printf ("%s, %s", @n, @q);
@};


/*
 *  IDENTIFIERS
 *
 *  These actions describe the identifier names.
 */

<name_none>: () -> (nm) = @{
    @nm = null;
@};

<field_name>: (fnm) -> (nm) = @{
    if (crt_field_name) {
	@nm = string_printf ("%s.%s", crt_field_name, @fnm);
    } else {
	@nm = @fnm;
    }
@};

<token_name>: (tnm) -> (nm) = @{
    @nm = token_name (@tnm);
@};

<make_id>: (a, va, b, vb) -> (id) = @{
    @id.iname = @a;
    @id.ivers = @va;
    @id.ename = @b;
    @id.evers = @vb;
@};

<id_anon>: () -> (id) = @{
    char *nm = string_printf ("%s%d", HIDDEN_NAME, anon_no++);
    if (crt_field_name) {
	nm = string_printf ("%s.%s", crt_field_name, nm);
    }
    @id.iname = nm;
    @id.ivers = no_version;
    @id.ename = token_name (nm);
    @id.evers = no_version;
@};

<version_none>: () -> (v) = @{
    @v = no_version;
@};

<version_number>: (n) -> (v) = @{
    @v = atoi (@n);
@};


/*
 *  SUBSET NAMES
 *
 *  These actions describe the subset names.
 */

<subset_none>: () -> (s) = @{ @s = "00"; @};
<subset_first>: () -> (s) = @{ @s = "10"; @};
<subset_second>: () -> (s) = @{ @s = "01"; @};
<subset_both>: () -> (s) = @{ @s = "11"; @};
<subset_next>: (a) -> (s) = @{ @s = string_concat (@a, "G"); @};

<api_name>: (a) -> (s) = @{
    @s = subset_name (@a, NULL, NULL);
@};

<file_name>: (a, b) -> (s) = @{
    @s = subset_name (@a, @b, NULL);
@};

<subset_name>: (a, b, c) -> (s) = @{
    if (@b [0] == 0) @b = null;
    @s = subset_name (@a, @b, @c);
@};


/*
 *  COMMAND KEYS
 *
 *  These actions describe the command keys.
 */

<cmd_constant>: () -> (c) = @{ @c = OBJ_CONST; @};
<cmd_exp>: () -> (c) = @{ @c = OBJ_EXP; @};
<cmd_exp_extern>: () -> (c) = @{ @c = OBJ_EXTERN; @};
<cmd_func>: () -> (c) = @{ @c = OBJ_FUNC; @};
<cmd_func_extern>: () -> (c) = @{ @c = OBJ_EXTERN; @};
<cmd_func_weak>: () -> (c) = @{ @c = OBJ_WEAK; @};
<cmd_implement>: () -> (c) = @{ @c = OBJ_IMPLEMENT; @};
<cmd_use>: () -> (c) = @{ @c = OBJ_USE; @};


/*
 *  COMMANDS
 *
 *  These actions describe the basic command constructs.
 */

<command_none>: () -> (c) = @{
    @c = null;
@};

<command_join>: (a, b) -> (c) = @{
    @c = join_object (@a, @b);
@};

<begin_subset>: (s) -> (c) = @{
    object *p = make_subset (@s);
    info *i = p->u.u_info;
    if (i->subset) {
	char *nm = subset_name (i->api, i->file, NULL);
	object *q = search_hash (subsets, nm, no_version);
	update_time (p, q);
    }
    @c = crt_object;
    crt_object = p;
@};

<end_subset>: (a, b) -> (c) = @{
    object *p = crt_object;
    if (p) p->u.u_info->elements = @b;
    @c = make_object (NULL, OBJ_SET);
    @c->u.u_obj = p;
    crt_object = @a;
@};

<include_subset>: (cmd, s, key) -> (c) = @{
    object *p = make_subset (@s);
    update_time (crt_object, p);
    @c = make_object (@key, @cmd);
    @c->u.u_obj = p;
@};


/*
 *  VARIABLE COMMANDS
 *
 *  These commands describe the variable assignment commands.
 */

<variable_string>: (a, b) -> () = @{
    set_string (@a, @b);
@};

<variable_plus>: (a, b) -> () = @{
    set_integer (@a, atoi (@b));
@};

<variable_minus>: (a, b) -> () = @{
    set_integer (@a, -atoi (@b));
@};


/*
 *  SPECIFICATION COMMANDS
 *
 *  These actions describe the constructs for the various specification
 *  commands.
 */

<declare_base>: () -> (c) = @{
    @c = null;
@};

<declare_comment>: (s) -> (c) = @{
    @c = make_object (@s, OBJ_TEXT_INCL);
@};

<declare_insert>: (s) -> (c) = @{
    @c = make_object (@s, OBJ_TEXT_INCL);
@};

<declare_build_insert>: (s) -> (c) = @{
    @c = make_object (@s, OBJ_TEXT_SRC);
@};

<declare_define>: (id, p, def) -> (c) = @{
    char *def;
    object *p = make_exp (@id.iname, @id.ivers, OBJ_DEFINE);
    if (@p) {
	if (*@p) {
	    def = string_printf ("(%s) %s", @p, @def);
	} else {
	    def = string_printf ("() %s", @def);
	}
    } else {
	def = string_printf (" %s", @def);
    }
    p->u.u_str = def;
    @c = make_token (@id.ename, @id.evers, p, OBJ_EXTERN);
@};

<declare_enum>: (tag, id, e) -> (c) = @{
    type *t = make_type (@id.iname, @id.ivers, @tag);
    t->v.obj2 = @e;
    @c = make_token (@id.ename, @id.evers, t->u.obj, OBJ_TYPE);
@};

<declare_enumerator>: (id, s) -> (c) = @{
    object *p = make_exp (@id.iname, @id.ivers, OBJ_ENUMVAL);
    p->u.u_str = @s;
    @c = make_token (@id.ename, @id.evers, p, OBJ_EXTERN);
@};

<declare_exp>: (cmd, id, t) -> (c) = @{
    object *p = make_exp (@id.iname, @id.ivers, @cmd);
    p->u.u_type = check_type (@t, @cmd);
    @c = make_token (@id.ename, @id.evers, p, @cmd);
@};

<declare_field>: (id, m, t) -> (c) = @{
    type *t = check_type (@t, OBJ_FIELD);
    field *f = make_field (@id.iname, @id.ivers, @m, t);
    @c = make_token (@id.ename, @id.evers, f->obj, OBJ_FIELD);
@};

<declare_func>: (cmd, id, t) -> (c) = @{
    object *p = make_exp (@id.iname, @id.ivers, @cmd);
    p->u.u_type = check_type (@t, OBJ_FUNC);
    @c = make_token (@id.ename, @id.evers, p, @cmd);
@};

<declare_macro>: (id, t) -> (c) = @{
    object *p;
    int cmd = OBJ_MACRO;
    if (@t->id != TYPE_PROC) cmd = OBJ_EXP;
    p = make_exp (@id.iname, @id.ivers, cmd);
    p->u.u_type = check_type (@t, cmd);
    @c = make_token (@id.ename, @id.evers, p, cmd);
@};

<declare_nat>: (id) -> (c) = @{
    object *p = make_exp (@id.iname, @id.ivers, OBJ_NAT);
    @c = make_token (@id.ename, @id.evers, p, OBJ_NAT);
@};

<declare_promote>: (id, t) -> (c) = @{
    type *t = make_type (@id.iname, @id.ivers, TYPE_PROMOTE);
    type *s = expand_type (@t);
    switch (s->id) {
	case TYPE_INT :
	case TYPE_SIGNED :
	case TYPE_UNSIGNED : {
	    break;
	}
	default : {
	    MSG_non_integral_promotion_type ();
	    break;
	}
    }
    t->v.next = s;
    @c = make_token (@id.ename, @id.evers, t->u.obj, OBJ_EXTERN);
@};

<declare_stmt>: (id, t) -> (c) = @{
    object *p = make_exp (@id.iname, @id.ivers, OBJ_STATEMENT);
    p->u.u_type = check_type (@t, OBJ_STATEMENT);
    @c = make_token (@id.ename, @id.evers, p, OBJ_STATEMENT);
@};

<declare_token>: (id, s) -> (c) = @{
    object *p = make_exp (@id.iname, @id.ivers, OBJ_TOKEN);
    p->u.u_str = @s;
    @c = make_token (@id.ename, @id.evers, p, OBJ_TOKEN);
@};

<declare_type>: (tag, id) -> (c) = @{
    type *t = make_type (@id.iname, @id.ivers, @tag);
    @c = make_token (@id.ename, @id.evers, t->u.obj, OBJ_TYPE);
@};

<declare_typedef>: (id, t) -> (c) = @{
    type *t = make_type (@id.iname, @id.ivers, TYPE_DEFINED);
    t->v.next = check_type (@t, OBJ_TYPE);
    @c = make_token (@id.ename, @id.evers, t->u.obj, OBJ_EXTERN);
@};


/*
 *  FIELD SPECIFICATION COMMANDS
 *
 *  These actions describe the member specification constructs.
 */

<begin_field>: (id, tag) -> (t, c) = @{
    @t = find_type (@id.iname, any_version, @tag, 0);
    if (@t == null) {
	@t = make_type (@id.iname, @id.ivers, @tag);
	@c = make_token (@id.ename, @id.evers, @t->u.obj, OBJ_TYPE);
    } else {
	@c = null;
    }
    @t = expand_type (@t);
    switch (@t->id) {
	case TYPE_STRUCT :
	case TYPE_UNION :
	case TYPE_STRUCT_TAG :
	case TYPE_UNION_TAG : {
	    break;
	}
	default : {
	    MSG_illegal_field_type (@id.iname);
	    break;
	}
    }
    crt_field_name = @t->u.obj->name;
@};

<end_field>: (t, a, b, e) -> (c) = @{
    if (@e) {
	if (@t->v.obj2) {
	    char *nm = crt_field_name;
	    MSG_redefinition_of_type (nm);
	}
	if (@b == null) {
	    MSG_empty_struct_union_definition ();
	} else {
	    @t->v.obj2 = @b;
	}
	if (@a == null) {
	    /* This is a hack, do properly later */
	    @c = make_object (NULL, OBJ_TYPE);
	    @c->u.u_type = @t;
	    if (streq (@c->filename, @t->u.obj->filename)) {
		@t->state = 1;
	    } else {
		@t->state = 3;
	    }
	} else {
	    @c = @a;
	}
    } else {
	@c = join_object (@a, @b);
    }
    crt_field_name = null;
@};


/*
 *  CONDITIONAL COMPILATION COMMANDS
 *
 *  These actions describe the conditional compilation constructs.
 */

<command_if>: (s) -> (c) = @{
    @c = make_object (@s, OBJ_IF);
    @c->u.u_num = CMD_IF;
@};

<command_ifdef>: (s) -> (c) = @{
    @c = make_object (@s, OBJ_IF);
    @c->u.u_num = CMD_IFDEF;
@};

<command_ifndef>: (s) -> (c) = @{
    @c = make_object (@s, OBJ_IF);
    @c->u.u_num = CMD_IFNDEF;
@};

<command_endif>: (i, s, a, b) -> (c) = @{
    object *p, *q;
    p = join_object (@i, @a);
    if (@b) {
	q = make_object (@s, OBJ_IF);
	q->u.u_num = CMD_ELSE;
	p = join_object (p, q);
	p = join_object (p, @b);
    }
    q = make_object (@s, OBJ_IF);
    q->u.u_num = CMD_ENDIF;
    @c = join_object (p, q);
@};


/*
 *  SYNTAX ERROR
 *
 *  This action describes the error message which is printed if a parse
 *  error occurs.
 */

<syntax_error>: () -> () = @{
    MSG_syntax_error ();
@};


%trailer% @{
@}, @{
#endif
@};