Subversion Repositories tendra.SVN

/*

 * 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

    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.

*/

#include "config.h"

#include "c_types.h"

#include "ctype_ops.h"

#include "etype_ops.h"

#include "exp_ops.h"

#include "ftype_ops.h"

#include "graph_ops.h"

#include "hashid_ops.h"

#include "id_ops.h"

#include "member_ops.h"

#include "nat_ops.h"

#include "nspace_ops.h"

#include "str_ops.h"

#include "type_ops.h"

#include "error.h"

#include "catalog.h"

#include "option.h"

#include "tdf.h"

#include "access.h"

#include "assign.h"

#include "basetype.h"

#include "buffer.h"

#include "cast.h"

#include "check.h"

#include "chktype.h"

#include "class.h"

#include "compile.h"

#include "constant.h"

#include "construct.h"

#include "convert.h"

#include "declare.h"

#include "derive.h"

#include "destroy.h"

#include "dump.h"

#include "exception.h"

#include "expression.h"

#include "file.h"

#include "function.h"

#include "hash.h"

#include "identifier.h"

#include "initialise.h"

#include "instance.h"

#include "inttype.h"

#include "literal.h"

#include "namespace.h"

#include "overload.h"

#include "parse.h"

#include "predict.h"

#include "print.h"

#include "statement.h"

#include "syntax.h"

#include "template.h"

#include "tok.h"

#include "tokdef.h"

#include "token.h"

#include "ustring.h"

/*

    INLINE MEMBER DEFINITIONS

    A static member can be defined inline in its class.  This is only a

    provisional definition for use in constant expressions etc.  The real

    definition (which cannot contain an initialiser) must be provided

    elsewhere.  This value is used to indicate such members.

*/

#define dspec_stat_inline	dspec_explicit

#define dspec_ignore_mem	(dspec_alias | dspec_inherit | dspec_token)

/*

    MEMBER NUMBER

    This variable is used to keep track of the number of data members

    within next_data_member.  Anonymous unions, rather than their members,

    are counted.

*/

unsigned long member_no = 0;

/*

    FIND NEXT DATA MEMBER

    This routine returns the first non-static, non-function member of a

    class following mem.  Anonymous unions are included if bit 1 of bf

    is false, but their members if it is true.  Anonymous bitfields are

    included if bit 0 of bf is true.  The null member is returned if there

    are no further members.

*/

MEMBER

next_data_member(MEMBER mem, int bf)

{

	while (!IS_NULL_member(mem)) {

		IDENTIFIER id = DEREF_id(member_id(mem));

		if (!IS_NULL_id(id) && IS_id_member(id)) {

			DECL_SPEC ds = DEREF_dspec(id_storage(id));

			if (!(ds & dspec_ignore_mem)) {

				int ok = 1;

				HASHID nm = DEREF_hashid(id_name(id));

				if (ds & dspec_reserve) {

					/* Anonymous union members */

					if (!(bf & 2)) {

						ok = 0;

					}

				} else {

					member_no++;

				}

				if (IS_hashid_anon(nm)) {

					TYPE t = DEREF_type(id_member_type(id));

					unsigned tag = TAG_type(t);

					if (tag == type_bitfield_tag) {

						/* Anonymous bitfield */

						if (!(bf & 1)) {

							ok = 0;

						}

					} else if (tag == type_compound_tag) {

						/* Anonymous union */

						if (bf & 2) {

							ok = 0;

						}

					}

				}

				if (ok) {

					return (mem);

				}

			}

		}

		mem = DEREF_member(member_next(mem));

	}

	return (NULL_member);

}

/*

    CONSTRUCT A DYNAMIC INITIALISER

    This routine checks whether the expression e is a non-constant

    initialiser for id (or a component of id if off is not null).  If so

    it is embedded in a dynamic initialiser expression and an error is

    reported.

*/

EXP

dynamic_init(IDENTIFIER id, string off, EXP e)

{

	int fs = 0;

	int c = -1;

	if (!IS_NULL_id(id)) {

		switch (TAG_id(id)) {

		case id_variable_tag: {

			DECL_SPEC ds = DEREF_dspec(id_storage(id));

			if (ds & dspec_auto) {

				if (off == NULL) {

					return (e);

				}

			} else {

				if (!(ds & dspec_linkage)) {

					fs = 1;

				}

			}

			break;

		}

		case id_stat_member_tag:

			/* Check static members */

			break;

		default:

			/* Ignore other identifiers */

			return (e);

		}

	}

	if (option(OPT_init_dynamic)) {

		/* Dynamic initialisation not allowed */

		c = 1;

	}

	if (!is_const_exp(e, c)) {

		/* Non-constant initialiser */

		TYPE t = DEREF_type(exp_type(e));

		if (!is_templ_type(t)) {

			ERROR err;

			if (off) {

				err = ERR_dcl_init_aggr_dynamic();

			} else {

				err = ERR_dcl_init_dynamic();

			}

			if (!IS_NULL_err(err)) {

				ERROR err2 = ERR_dcl_init_decl(id, off);

				err = concat_error(err2, err);

				report(crt_loc, err);

			}

			if (fs) {

				/* Check function statics */

				e = check_return_exp(e, lex_static);

			}

			MAKE_exp_dynamic(t, e, e);

		}

	}

	return (e);

}

/*

    CHECK A VARIABLE INITIALISER

    This routine is called to check the initialiser for a variable or static

    data member.  Its primary purpose is to mark those temporaries which

    are bound to variables.

*/

EXP

check_init(EXP e)

{

	if (!IS_NULL_exp(e)) {

		switch (TAG_exp(e)) {

		case exp_identifier_tag: {

			IDENTIFIER id = DEREF_id(exp_identifier_id(e));

			DECL_SPEC ds = DEREF_dspec(id_storage(id));

			if (ds & dspec_temp) {

				ds &= ~dspec_register;

				COPY_dspec(id_storage(id), ds);

			}

			break;

		}

		case exp_init_tag: {

			IDENTIFIER id = DEREF_id(exp_init_id(e));

			DECL_SPEC ds = DEREF_dspec(id_storage(id));

			if (ds & dspec_temp) {

				ds &= ~dspec_register;

				COPY_dspec(id_storage(id), ds);

			}

			break;

		}

		case exp_indir_tag: {

			EXP a = DEREF_exp(exp_indir_ptr(e));

			a = check_init(a);

			COPY_exp(exp_indir_ptr(e), a);

			break;

		}

		case exp_address_tag: {

			EXP a = DEREF_exp(exp_address_arg(e));

			a = check_init(a);

			COPY_exp(exp_address_arg(e), a);

			break;

		}

		case exp_base_cast_tag: {

			EXP a = DEREF_exp(exp_base_cast_arg(e));

			a = check_init(a);

			COPY_exp(exp_base_cast_arg(e), a);

			break;

		}

		case exp_add_ptr_tag: {

			EXP a = DEREF_exp(exp_add_ptr_ptr(e));

			a = check_init(a);

			COPY_exp(exp_add_ptr_ptr(e), a);

			break;

		}

		case exp_dynamic_tag: {

			EXP a = DEREF_exp(exp_dynamic_arg(e));

			a = check_init(a);

			COPY_exp(exp_dynamic_arg(e), a);

			break;

		}

		case exp_aggregate_tag: {

			LIST(EXP) p = DEREF_list(exp_aggregate_args(e));

			while (!IS_NULL_list(p)) {

				EXP a = DEREF_exp(HEAD_list(p));

				a = check_init(a);

				COPY_exp(HEAD_list(p), a);

				p = TAIL_list(p);

			}

			break;

		}

		case exp_nof_tag: {

			EXP a = DEREF_exp(exp_nof_start(e));

			EXP b = DEREF_exp(exp_nof_pad(e));

			EXP c = DEREF_exp(exp_nof_end(e));

			a = check_init(a);

			b = check_init(b);

			c = check_init(c);

			COPY_exp(exp_nof_start(e), a);

			COPY_exp(exp_nof_pad(e), b);

			COPY_exp(exp_nof_end(e), c);

			break;

		}

		}

	}

	return (e);

}

/*

    TEMPORARY VARIABLE FLAG

    The variable made_temporary is set to the temporary variable whenever

    a temporary variable is created.  temp_storage is used to determine

    the storage class for a local variable.

*/

IDENTIFIER made_temporary = NULL_id;

int keep_temporary = 0;

static DECL_SPEC temp_storage = dspec_auto;

/*

    DECLARE A TEMPORARY VARIABLE

    This routine declares a temporary variable of type t, initial value

    e, and destructor d (the implicit destructor will be created if this

    is the null expression).  It returns an expression giving the value of

    this temporary.  Note the use of an assignment expression to ensure

    that the temporary gets initialised in the right place.

*/

EXP

make_temporary(TYPE t, EXP e, EXP d, int ref, ERROR *err)

{

	LOCATION loc;

	DECL_SPEC ds;

	EXP c = NULL_exp;

	HASHID nm = lookup_anon();

	NAMESPACE ns = crt_namespace;

	QUALIFIER cq = crt_id_qualifier;

	int tq = crt_templ_qualifier;

	int fn = in_function_defn;

	IDENTIFIER id = DEREF_id(hashid_id(nm));

	loc = decl_loc;

	decl_loc = crt_loc;

	crt_id_qualifier = qual_none;

	crt_templ_qualifier = 0;

	/* Declare the temporary object */

	if (IS_type_ref(t)) {

		t = DEREF_type(type_ref_sub(t));

	}

	if (in_default_arg) {

		/* NOT YET IMPLEMENTED */

		crt_namespace = global_namespace;

		in_function_defn = 0;

	}

	t = qualify_type(t, cv_none, 0);

	if (IS_type_compound(t)) {

		add_error(err, ERR_dcl_init_ref_tmp(t));

	}

	id = make_object_decl(dspec_temp, t, id, 0);

	ds = DEREF_dspec(id_storage(id));

	if (temp_storage != dspec_auto) {

		/* Set storage class */

		ds &= ~dspec_storage;

		ds |= temp_storage;

	}

	if (ds & dspec_auto) {

		ds |= dspec_register;

	}

	COPY_dspec(id_storage(id), ds);

	made_temporary = id;

	/* Check initialiser */

	if (!is_const_exp(e, -1)) {

		if (ds & dspec_auto) {

			c = e;

			e = NULL_exp;

		} else if (ref) {

			TYPE s = DEREF_type(exp_type(e));

			MAKE_exp_dynamic(s, e, e);

			add_error(err, ERR_dcl_init_dynamic());

		} else {

			TYPE s = DEREF_type(exp_type(e));

			c = e;

			e = make_null_exp(s);

		}

	}

	if (IS_NULL_exp(d)) {

		/* Create destructor */

		int du = do_usage;

		do_usage = 0;

		d = init_default(t, &d, DEFAULT_DESTR, EXTRA_DESTR, err);

		do_usage = du;

	}

	COPY_exp(id_variable_init(id), e);

	COPY_exp(id_variable_term(id), d);

	define_id(id);

	/* Construct the result expression */

	if (!IS_NULL_exp(c)) {

		/* Assign initial value */

		t = DEREF_type(id_variable_type(id));

		MAKE_exp_init(t, id, c, e);

		ds = DEREF_dspec(id_storage(id));

		ds |= dspec_explicit;

		COPY_dspec(id_storage(id), ds);

	} else {

		e = make_id_exp(id);

	}

	/* Define variable */

	if (!(ds & dspec_auto)) {

		if (!really_in_function_defn && !in_template_decl) {

			/* Compile variable definition */

			compile_variable(id, 0);

		}

	}

	if (do_dump) {

		dump_implicit = 1;

		dump_declare(id, &decl_loc, 1);

	}

	crt_templ_qualifier = tq;

	crt_id_qualifier = cq;

	in_function_defn = fn;

	crt_namespace = ns;

	decl_loc = loc;

	return (e);

}

/*

    IS A VARIABLE ALIASED IN AN EXPRESSION

    This routine checks whether the variable expression d is aliased in

    the expression e.

*/

static int

involves_alias(EXP e, EXP d)

{

	if (!IS_NULL_exp(d)) {

		/* NOT YET IMPLEMENTED */

		UNUSED(e);

		return (1);

	}

	return (0);

}

/*

    ELIMINATE A TEMPORARY VARIABLE

    This routine is called to eliminate any temporary variables from the

    value e which is to be assigned to a variable given by d.  d is the

    null expression in a variable initialisation, otherwise care needs

    to be taken if d is aliased in e.  Note that creating a temporary and

    then removing it ensures that the accesses for the copy constructor

    and destructor are checked correctly.

*/

EXP

remove_temporary(EXP e, EXP d)

{

	if (!IS_NULL_exp(e)) {

		EXP a = NULL_exp;

		unsigned tag = TAG_exp(e);

		if (tag == exp_constr_tag) {

			LIST(EXP)p;

			int info = DEREF_int(exp_constr_info(e));

			if (info != DEFAULT_COPY) {

				return (e);

			}

			a = DEREF_exp(exp_constr_call(e));

			p = DEREF_list(exp_func_id_args(a));

			if (IS_NULL_list(p)) {

				return (e);

			}

			p = TAIL_list(p);

			if (IS_NULL_list(p)) {

				return (e);

			}

			a = DEREF_exp(HEAD_list(p));

			if (!IS_exp_address(a)) {

				return (e);

			}

			a = DEREF_exp(exp_address_arg(a));

		} else if (tag == exp_contents_tag) {

			a = DEREF_exp(exp_contents_ptr(e));

		}

		if (!IS_NULL_exp(a) && IS_exp_init(a)) {

			/* Check for temporary variable */

			IDENTIFIER id = DEREF_id(exp_init_id(a));

			if (IS_id_variable(id)) {

				DECL_SPEC ds = DEREF_dspec(id_storage(id));

				if ((ds & dspec_temp) && !keep_temporary) {

					/* Eliminate temporary variable */

					EXP b = DEREF_exp(exp_init_arg(a));

					if (IS_NULL_exp(b)) {

						b = DEREF_exp(id_variable_init(id));

					}

					if (!involves_alias(b, d)) {

						ds |= dspec_ignore;

						COPY_dspec(id_storage(id), ds);

						return (b);

					}

				}

			}

		}

	}

	return (e);

}

/*

    FORCE A REFERENCE INITIALISATION

    This flag forces a reference to be initialised by a less cv-qualified

    version of the same type.  Values of greater than 1 can arise in

    copy constructors.

*/

int init_ref_force = 1;

/*

    INITIALISE A REFERENCE WITH AN LVALUE

    This routine checks whether e is a suitable lvalue initialiser for a

    reference to type t.  If so a suitably converted version of e is

    returned.  The null expression is returned otherwise.

*/

EXP

init_ref_lvalue(TYPE t, EXP e, ERROR *err)

{

	EXP a = NULL_exp;

	if (!IS_NULL_exp(e)) {

		TYPE s = DEREF_type(exp_type(e));

		CV_SPEC qual = DEREF_cv(type_qual(s));

		if (qual & cv_lvalue) {

			/* Check whether t is reference compatible with s */

			unsigned nt = TAG_type(t);

			unsigned ns = TAG_type(s);

			CV_SPEC cv = cv_compare(t, s);

			if (nt == ns) {

				if (nt == type_compound_tag) {

					/* Check for base class conversions */

					if (cv == cv_none || init_ref_force) {

						a = cast_class_class(t, e, err, CAST_IMPLICIT, 1);

					}

				} else if (nt == type_func_tag) {

					/* Allow for overloading */

					LIST(IDENTIFIER) pids =

					    NULL_list(IDENTIFIER);

					e = resolve_cast(t, e, err, 1, 0, pids);

					if (!IS_exp_member(e)) {

						s = DEREF_type(exp_type(e));

						if (eq_type_unqual(t, s)) {

							if (eq_except(t, s) != 2) {

								add_error(err, ERR_except_spec_init());

							}

							a = e;

						}

					}

				} else {

					/* Otherwise check for equal types */

					if (eq_type_unqual(t, s)) {

						a = e;

						if (cv != cv_none) {

							add_error(err, ERR_dcl_init_ref_qual(cv));

						}

					}

				}

			}

		}

		if (is_templ_type(s)) {

			/* Allow for template parameters */

			a = cast_templ_type(t, e, CAST_IMPLICIT);

		}

	}

	return (a);

}

/*

    INITIALISE A REFERENCE WITH AN RVALUE

    This routine checks whether e is a suitable rvalue initialiser for a

    reference to type t.  It is firstly checked that t is a const reference

    and not a reference to function.  If t is reference compatible with the

    type of s then a temporary is created to hold the value of e and the

    contents of this temporary are returned.  Otherwise the null expression

    is returned.

*/

static EXP

init_ref_rvalue(TYPE t, EXP e, ERROR *err)

{

	/* Check for reference to functions */

	CV_SPEC qual;

	unsigned nt = TAG_type(t);

	if (nt == type_func_tag) {

		add_error(err, ERR_dcl_init_ref_func());

		e = make_null_exp(t);

		return (e);

	}

	/* Check for const references */

	qual = find_cv_qual(t);

	qual &= cv_qual;

	if (qual != cv_const) {

		int ok = 0;

		if (!IS_NULL_exp(e)) {

			TYPE s = DEREF_type(exp_type(e));

			if (IS_type_error(s)) {

				ok = 1;

			}

		}

		if (!ok) {

			add_error(err, ERR_dcl_init_ref_const());

		}

	}

	/* Check the initialiser */

	if (!IS_NULL_exp(e)) {

		/* Check whether t is reference compatible with s */

		int force = init_ref_force;

		TYPE s = DEREF_type(exp_type(e));

		unsigned ns = TAG_type(s);

		CV_SPEC cv = cv_compare(t, s);

		if (nt == ns && (cv == cv_none || force)) {

			TYPE r = t;

			if (nt == type_compound_tag) {

				/* t must be a base class of s */

				CLASS_TYPE ct =

				    DEREF_ctype(type_compound_defn(t));

				CLASS_TYPE cs =

				    DEREF_ctype(type_compound_defn(s));

				GRAPH gr = find_base_class(cs, ct, 1);

				if (IS_NULL_graph(gr)) {

					return (NULL_exp);

				}

				r = qualify_type(s, qual, 0);

				/* NOT YET IMPLEMENTED: copy e */

			} else {

				/* Otherwise check for equal types */

				if (!eq_type_unqual(t, s)) {

					return (NULL_exp);

				}

			}

			if (cv != cv_none) {

				/* Binding from more qualified type */

				add_error(err, ERR_dcl_init_ref_qual(cv));

			}

			e = make_temporary(r, e, NULL_exp, 1, err);

			if (nt == type_compound_tag) {

				/* Bind temporary to reference */

				e = cast_class_class(t, e, err, CAST_IMPLICIT, 1);

			}

			return (e);

		}

	}

	return (NULL_exp);

}

/*

    CREATE A REFERENCE INITIALISER

    This routine creates a reference initialiser of type t out of the

    expression e.

*/

EXP

make_ref_init(TYPE t, EXP e)

{

	if (!IS_NULL_exp(e)) {

		if (IS_exp_op(e)) {

			/* Allow for template parameters */

			COPY_type(exp_type(e), t);

		} else {

			TYPE s = t;

			unsigned tag = TAG_type(s);

			if (tag == type_ref_tag) {

				s = DEREF_type(type_ref_sub(s));

				tag = TAG_type(s);

			}

			if (tag == type_token_tag && is_templ_type(s)) {

				/* Check again later */

				/* EMPTY */

			} else {

				MAKE_exp_address(t, e, e);

			}

		}

	}

	return (e);

}

/*

    CREATE A NULL EXPRESSION

    This routine creates a null expression (i.e. all zeros) for the type t.

    This is the default value for a non-explicitly initialised variable with

    internal or external linkage.

*/

EXP

make_null_exp(TYPE t)

{

	EXP e;

	switch (TAG_type(t)) {

	case type_integer_tag:

	case type_enumerate_tag: {

		NAT n = small_nat[0];

		MAKE_exp_int_lit(t, n, exp_int_lit_tag, e);

		break;

	}

	case type_floating_tag: {

		FLOAT f = get_float(t, 0);

		MAKE_exp_float_lit(t, f, e);

		break;

	}

	case type_bitfield_tag: {

		TYPE s = find_bitfield_type(t);

		e = make_null_exp(s);

		MAKE_exp_cast(t, (CONV_BITFIELD | CONV_REVERSE), e, e);

		break;

	}

	default:

		MAKE_exp_null(t, e);

		break;

	}

	return (e);

}

/*

    CREATE A UNIT EXPRESSION

    This routine creates a unit expression (i.e. one) for the type t.

*/

EXP

make_unit_exp(TYPE t)

{

	EXP e;

	switch (TAG_type(t)) {

	case type_integer_tag:

	case type_enumerate_tag: {

		NAT n = small_nat[1];

		MAKE_exp_int_lit(t, n, exp_int_lit_tag, e);

		break;

	}

	case type_floating_tag: {

		FLOAT f = get_float(t, 1);

		MAKE_exp_float_lit(t, f, e);

		break;

	}

	case type_bitfield_tag: {

		TYPE s = find_bitfield_type(t);

		e = make_unit_exp(s);

		MAKE_exp_cast(t,(CONV_BITFIELD | CONV_REVERSE), e, e);

		break;

	}

	default:

		FAIL(Invalid unit type);

		MAKE_exp_null(t, e);

		break;

	}

	return (e);

}

/*

    IS AN EXPRESSION NULL?

    This routine checks whether the expression e is a null expression.

*/

int

is_null_exp(EXP e)

{

	if (IS_NULL_exp(e)) {

		return (1);

	}

	switch (TAG_exp(e)) {

	case exp_int_lit_tag: {

		NAT n = DEREF_nat(exp_int_lit_nat(e));

		return (is_zero_nat(n));

	}

	case exp_float_lit_tag: {

		FLOAT f = DEREF_flt(exp_float_lit_flt(e));

		return (is_zero_float(f));

	}

	case exp_null_tag:

	case exp_zero_tag:

		return (1);

	case exp_aggregate_tag: {