#include <ddbe.h>
#include <astp.h>
#include <command.h>
#include <message.h>
#include <mtsbacke.h>
#include <nidlmsg.h>
#define DDBE_SUFFIX_TO_XMIT "_to_xmit"
#define DDBE_SUFFIX_FROM_XMIT "_from_xmit"
#define DDBE_SUFFIX_FREE_INST "_free_inst"
#define DDBE_SUFFIX_FREE_XMIT "_free_xmit"
#define DDBE_SUFFIX_FROM_LOCAL "_from_local"
#define DDBE_SUFFIX_TO_LOCAL "_to_local"
#define DDBE_SUFFIX_FREE_LOCAL "_free_local"
#define DDBE_SUFFIX_FREE_INST "_free_inst"
#define DDBE_SUFFIX_NET_SIZE "_net_size"
#define DDBE_SUFFIX_TO_NETCS "_to_netcs"
#define DDBE_SUFFIX_LOCAL_SIZE "_local_size"
#define DDBE_SUFFIX_FROM_NETCS "_from_netcs"
#ifdef DUMPERS
static void DDBE_test_marsh_spellers(
AST_interface_n_t *int_p,
boolean *cmd_opt,
void **cmd_val
);
#endif
boolean DDBE_stub_hex = FALSE;
boolean DDBE_little_endian = TRUE;
long DDBE_inst_num = 0;
static NAMETABLE_id_t
DDBE_dt_allocate,
DDBE_dt_allocate_ref,
DDBE_dt_begin_nested_struct,
DDBE_dt_boolean,
DDBE_dt_byte,
DDBE_dt_char,
DDBE_dt_conf_array,
DDBE_dt_conf_struct,
DDBE_dt_cs_array,
DDBE_dt_cs_attribute,
DDBE_dt_cs_rlse_shadow,
DDBE_dt_cs_shadow,
DDBE_dt_cs_type,
DDBE_dt_deleted_nodes,
DDBE_dt_does_not_exist,
DDBE_dt_double,
DDBE_dt_enc_union,
DDBE_dt_end_nested_struct,
DDBE_dt_enum,
DDBE_dt_eol,
DDBE_dt_error_status,
DDBE_dt_first_is_limit,
DDBE_dt_first_is_early_limit,
DDBE_dt_fixed_array,
DDBE_dt_fixed_bound,
DDBE_dt_fixed_limit,
DDBE_dt_fixed_struct,
DDBE_dt_float,
DDBE_dt_free_rep,
DDBE_dt_full_ptr,
DDBE_dt_hyper,
DDBE_dt_ignore,
DDBE_dt_interface,
DDBE_dt_in_context,
DDBE_dt_in_out_context,
DDBE_dt_last_is_limit,
DDBE_dt_last_is_early_limit,
DDBE_dt_length_is_limit,
DDBE_dt_length_is_early_limit,
DDBE_dt_long,
DDBE_dt_max_is_bound,
DDBE_dt_max_is_early_bound,
DDBE_dt_min_is_bound,
DDBE_dt_min_is_early_bound,
DDBE_dt_modified,
DDBE_dt_ndr_align_2,
DDBE_dt_ndr_align_4,
DDBE_dt_ndr_align_8,
DDBE_dt_n_e_union,
DDBE_dt_open_array,
DDBE_dt_out_context,
DDBE_dt_passed_by_ref,
DDBE_dt_pipe,
DDBE_dt_range,
DDBE_dt_ref_ptr,
DDBE_dt_represent_as,
DDBE_dt_size_is_bound,
DDBE_dt_size_is_early_bound,
DDBE_dt_small,
DDBE_dt_short,
DDBE_dt_string,
DDBE_dt_string_bound,
DDBE_dt_string_limit,
DDBE_dt_transmit_as,
DDBE_dt_unique_ptr,
DDBE_dt_uhyper,
DDBE_dt_ulong,
DDBE_dt_upper_conf_limit,
DDBE_dt_ushort,
DDBE_dt_usmall,
DDBE_dt_v1_array,
DDBE_dt_v1_conf_struct,
DDBE_dt_v1_enum,
DDBE_dt_v1_string,
DDBE_dt_varying_array,
DDBE_dt_void;
static void DDBE_func_code_vec_entry(
DDBE_vec_rep_t **p_defn_p,
byte func_code
);
#ifdef DUMPERS
#define DDBE_STRTAB_ENTRY(dest, comment)\
if (comment == NULL)\
dest = STRTAB_NULL_STR;\
else\
dest = STRTAB_add_string(comment)
#else
#define DDBE_STRTAB_ENTRY(dest, comment)\
dest = STRTAB_NULL_STR
#endif
#define DDBE_NEW_ENTRY(new_p, p_defn_p, _comment)\
{\
new_p = NEW (DDBE_vec_rep_t);\
DDBE_STRTAB_ENTRY(new_p->comment, _comment);\
\
new_p->next = (*(p_defn_p))->next;\
(*(p_defn_p))->next = new_p;\
*(p_defn_p) = new_p;\
}
#define DDBE_VEC_SENTINEL(vec_rep_p) \
{ \
(vec_rep_p) = NEW (DDBE_vec_rep_t); \
(vec_rep_p)->kind = DDBE_vec_noop_k; \
(vec_rep_p)->next = NULL; \
}
#define DDBE_VEC_INIT(vip) \
vip->p_cur_p = &vip->type_p; \
vip->conformant = FALSE; \
vip->saved_defn_p = NULL; \
vip->in_cfmt_struct_hdr = FALSE; \
vip->cfmt_info_tup_p = NULL; \
vip->in_flatarr = FALSE; \
vip->update_tup = TRUE;
boolean DDBE_param_is_array_of_kind
(
AST_parameter_n_t *param_p,
AST_type_k_t elem_kind,
boolean a_of_a
)
{
AST_type_n_t *type_p;
if (param_p->type->kind == AST_array_k)
type_p = param_p->type->type_structure.array->element_type;
else if (DDBE_param_is_p_array(param_p))
type_p = param_p->type->type_structure.pointer->pointee_type->
type_structure.array->element_type;
else if (DDBE_ARRAYIFIED(param_p))
type_p = param_p->type->type_structure.pointer->pointee_type;
else
return FALSE;
if (type_p->kind == AST_array_k && a_of_a)
do {
type_p = type_p->type_structure.array->element_type;
} while (type_p->kind == AST_array_k);
if (type_p->kind == elem_kind)
return TRUE;
return FALSE;
}
void DDBE_spell_type_kind
(
FILE *fid,
DDBE_vec_rep_t *vec_p
)
{
NAMETABLE_id_t nameid = 0;
char const *name;
AST_type_n_t *type_p;
char const *type_name;
#ifdef DUMPERS
char const *comment;
#endif
if (vec_p->kind != DDBE_vec_type_kind_k)
{
INTERNAL_ERROR("Unexpected vector entry kind");
return;
}
switch (vec_p->val.type_p->kind)
{
case AST_boolean_k:
nameid = DDBE_dt_boolean;
break;
case AST_byte_k:
nameid = DDBE_dt_byte;
break;
case AST_character_k:
nameid = DDBE_dt_char;
break;
case AST_small_integer_k:
nameid = DDBE_dt_small;
break;
case AST_short_integer_k:
nameid = DDBE_dt_short;
break;
case AST_long_integer_k:
nameid = DDBE_dt_long;
break;
case AST_hyper_integer_k:
nameid = DDBE_dt_hyper;
break;
case AST_small_unsigned_k:
nameid = DDBE_dt_usmall;
break;
case AST_short_unsigned_k:
nameid = DDBE_dt_ushort;
break;
case AST_long_unsigned_k:
if (vec_p->val.type_p->name != NAMETABLE_NIL_ID)
{
type_p = vec_p->val.type_p;
while (type_p->defined_as != NULL)
type_p = type_p->defined_as;
NAMETABLE_id_to_string(type_p->name, &type_name);
if (strcmp(type_name, "error_status_t") == 0)
{
nameid = DDBE_dt_error_status;
break;
}
}
nameid = DDBE_dt_ulong;
break;
case AST_hyper_unsigned_k:
nameid = DDBE_dt_uhyper;
break;
case AST_short_float_k:
nameid = DDBE_dt_float;
break;
case AST_long_float_k:
nameid = DDBE_dt_double;
break;
case AST_enum_k:
if (AST_V1_ENUM_SET(vec_p->val.type_p))
nameid = DDBE_dt_v1_enum;
else
nameid = DDBE_dt_enum;
break;
default:
INTERNAL_ERROR("Unexpected type kind");
}
NAMETABLE_id_to_string(nameid, &name);
#ifdef DUMPERS
if (vec_p->comment == STRTAB_NULL_STR)
#endif
fprintf(fid, "%s,\n", name);
#ifdef DUMPERS
else
{
STRTAB_str_to_string(vec_p->comment, &comment);
fprintf(fid, "%s,\t/* %s */\n", name, comment);
}
#endif
}
static void DDBE_tag_vec_entry
(
DDBE_vec_rep_t **p_defn_p,
NAMETABLE_id_t tag_name
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, NULL);
new_p->kind = DDBE_vec_tag_k;
new_p->val.name = tag_name;
}
static void DDBE_byte_vec_entry
(
DDBE_vec_rep_t **p_defn_p,
DDBE_vec_kind_t entry_kind,
byte value,
const char *comment ATTRIBUTE_UNUSED
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, comment);
new_p->kind = entry_kind;
new_p->val.byte_val = value;
}
static void DDBE_short_vec_entry
(
DDBE_vec_rep_t **p_defn_p,
DDBE_vec_kind_t entry_kind,
short value,
const char *comment ATTRIBUTE_UNUSED
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, comment);
new_p->kind = entry_kind;
new_p->val.short_val= value;
}
static void DDBE_long_vec_entry
(
DDBE_vec_rep_t **p_defn_p,
DDBE_vec_kind_t entry_kind,
long value,
const char *comment ATTRIBUTE_UNUSED
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, comment);
new_p->kind = entry_kind;
new_p->val.long_val = value;
}
static void DDBE_comment_vec_entry
(
DDBE_vec_rep_t **p_defn_p,
const char *comment ATTRIBUTE_UNUSED
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, comment);
new_p->kind = DDBE_vec_comment_k;
}
static void DDBE_expr_vec_entry
(
DDBE_vec_rep_t **p_defn_p,
DDBE_vec_kind_t expr_kind,
STRTAB_str_t expr,
const char *comment ATTRIBUTE_UNUSED
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, comment);
new_p->kind = expr_kind;
new_p->val.expr = expr;
}
static void DDBE_type_info_vec_entry
(
DDBE_vec_kind_t kind,
DDBE_vec_rep_t **p_defn_p,
AST_type_n_t *type_p,
const char *comment ATTRIBUTE_UNUSED
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, comment);
new_p->kind = kind;
new_p->val.type_p = type_p;
}
static void DDBE_name_vec_entry
(
DDBE_vec_rep_t **p_defn_p,
NAMETABLE_id_t name,
const char *comment ATTRIBUTE_UNUSED
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, comment);
new_p->kind = DDBE_vec_name_k;
new_p->val.name = name;
}
#if 0
static void DDBE_opt_name_vec_entry
(
DDBE_vec_rep_t **p_defn_p,
NAMETABLE_id_t name,
char *comment __attribute__((unused)),
boolean client_side
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, comment);
new_p->kind = (client_side ? DDBE_vec_name_client_k : DDBE_vec_name_server_k);
new_p->val.name = name;
}
#endif
static void DDBE_pad_vec_entry
(
DDBE_vec_rep_t **p_defn_p,
byte pad
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, NULL);
new_p->kind = DDBE_vec_pad_k;
new_p->val.byte_val = pad;
}
static void DDBE_noop_vec_entry
(
DDBE_vec_rep_t **p_defn_p
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, NULL);
new_p->kind = DDBE_vec_noop_k;
}
static void DDBE_scalar_vec_entry
(
DDBE_vec_rep_t **p_defn_p,
AST_type_n_t *type_p,
char const *inst_expr,
DDBE_vectors_t *vip ATTRIBUTE_UNUSED
)
{
DDBE_vec_rep_t *new_p;
char const *type_name;
char const *comment;
char comment_buf[DDBE_MAX_COMMENT];
comment_buf[0] = '\0';
if (type_p->name != NAMETABLE_NIL_ID)
{
NAMETABLE_id_to_string(type_p->name, &type_name);
strlcat(comment_buf, type_name, sizeof(comment_buf));
if (inst_expr != NULL)
strlcat(comment_buf, " ", sizeof(comment_buf));
}
if (inst_expr != NULL)
strlcat(comment_buf, inst_expr, sizeof(comment_buf));
else
inst_expr = "byte or char data";
comment = (comment_buf[0] == '\0') ? NULL : comment_buf;
DDBE_NEW_ENTRY(new_p, p_defn_p, comment);
new_p->kind = DDBE_vec_type_kind_k;
new_p->val.type_p = type_p;
}
static void DDBE_reference_vec_entry
(
DDBE_vec_rep_t **p_defn_p,
DDBE_vec_rep_t *ref_p,
const char *comment ATTRIBUTE_UNUSED
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, comment);
new_p->kind = DDBE_vec_reference_k;
new_p->val.ref_p = ref_p;
}
static void DDBE_indirect_vec_entry
(
DDBE_vec_rep_t **p_defn_p,
DDBE_vec_rep_t **p_ref_p,
const char *comment ATTRIBUTE_UNUSED
)
{
DDBE_vec_rep_t *new_p;
DDBE_NEW_ENTRY(new_p, p_defn_p, comment);
new_p->kind = DDBE_vec_indirect_k;
new_p->val.p_ref_p = p_ref_p;
}
static unsigned long DDBE_compute_vec_offsets
(
DDBE_vec_rep_t *vec_p,
unsigned long align_req,
unsigned long index_incr,
unsigned long start_index,
DDBE_vec_rep_t **end_vec_p
)
{
unsigned long offset;
unsigned long save_offset;
unsigned long align_val;
DDBE_vec_rep_t *prev_vec_p;
offset = start_index;
align_val = align_req - 1;
prev_vec_p = NULL;
while (vec_p != NULL)
{
switch (vec_p->kind)
{
case DDBE_vec_byte_k:
case DDBE_vec_expr_byte_k:
case DDBE_vec_tag_k:
case DDBE_vec_type_kind_k:
vec_p->index = offset;
offset++;
break;
case DDBE_vec_byte_3m4_k:
save_offset = offset;
offset = offset | 3;
if (offset != save_offset)
{
DDBE_pad_vec_entry(&prev_vec_p, (byte)offset-save_offset);
prev_vec_p->index = save_offset;
}
vec_p->index = offset;
offset++;
break;
case DDBE_vec_short_k:
save_offset = offset;
offset = (offset + 1) & ~1;
if (offset != save_offset)
{
DDBE_pad_vec_entry(&prev_vec_p, (byte)(offset-save_offset));
prev_vec_p->index = save_offset;
}
vec_p->index = offset;
offset += 2;
break;
case DDBE_vec_expr_arr_k:
case DDBE_vec_expr_k:
case DDBE_vec_expr_long_k:
case DDBE_vec_indirect_k:
case DDBE_vec_long_k:
case DDBE_vec_long_bool_k:
case DDBE_vec_name_k:
case DDBE_vec_name_client_k:
case DDBE_vec_name_server_k:
case DDBE_vec_reference_k:
case DDBE_vec_sizeof_k:
if (index_incr != 1)
{
save_offset = offset;
offset = (offset + align_val) & ~align_val;
if (offset != save_offset)
{
DDBE_pad_vec_entry(&prev_vec_p, (byte)(offset-save_offset));
prev_vec_p->index = save_offset;
}
}
vec_p->index = offset;
offset += index_incr;
break;
case DDBE_vec_noop_k:
case DDBE_vec_comment_k:
case DDBE_vec_offset_begin_k:
case DDBE_vec_offset_end_k:
vec_p->index = offset;
break;
case DDBE_vec_pad_k:
vec_p->index = offset;
offset += vec_p->val.byte_val;
break;
default:
INTERNAL_ERROR("Invalid vector entry kind");
}
prev_vec_p = vec_p;
vec_p = vec_p->next;
}
if (end_vec_p != NULL)
*end_vec_p = prev_vec_p;
return offset;
}
static void DDBE_patch_vec_refs
(
DDBE_vec_rep_t *vec_p
)
{
DDBE_vec_rep_t *ref_vec_p = NULL;
while (vec_p != NULL)
{
if (vec_p->kind == DDBE_vec_indirect_k)
ref_vec_p = *(vec_p->val.p_ref_p);
else if (vec_p->kind == DDBE_vec_reference_k)
ref_vec_p = vec_p->val.ref_p;
if (vec_p->kind == DDBE_vec_indirect_k
|| vec_p->kind == DDBE_vec_reference_k)
{
while (ref_vec_p != NULL
&& (ref_vec_p->kind == DDBE_vec_pad_k
|| ref_vec_p->kind == DDBE_vec_noop_k
|| ref_vec_p->kind == DDBE_vec_comment_k)) {
ref_vec_p = ref_vec_p->next;
}
assert(ref_vec_p != NULL);
vec_p->kind = DDBE_vec_long_k;
vec_p->val.long_val = ref_vec_p->index;
}
vec_p = vec_p->next;
}
}
static void DDBE_patch_oper_info
(
AST_interface_n_t *int_p
)
{
AST_export_n_t *export_p;
AST_operation_n_t *oper_p;
DDBE_oper_i_t *oper_i_p;
AST_parameter_n_t *param_p;
for (export_p = int_p->exports; export_p != NULL; export_p = export_p->next)
{
if (export_p->kind == AST_operation_k)
{
oper_p = export_p->thing_p.exported_operation;
oper_i_p = oper_p->be_info.dd_oper;
if (oper_i_p->ins_type_vec_p != NULL)
oper_i_p->ins_type_index = oper_i_p->ins_type_vec_p->index;
if (oper_i_p->outs_type_vec_p != NULL)
oper_i_p->outs_type_index = oper_i_p->outs_type_vec_p->index;
for (param_p = oper_p->parameters;
param_p != NULL;
param_p = param_p->next)
{
if (param_p->be_info.dd_param->type_vec_p != NULL)
param_p->be_info.dd_param->type_index =
param_p->be_info.dd_param->type_vec_p->index;
}
if (oper_p->result->be_info.dd_param->type_vec_p != NULL)
oper_p->result->be_info.dd_param->type_index =
oper_p->result->be_info.dd_param->type_vec_p->index;
}
}
}
static void DDBE_init_vectors
(
AST_interface_n_t *int_p,
DDBE_vectors_t **p_vip
)
{
DDBE_vectors_t *vip;
*p_vip = vip = NEW (DDBE_vectors_t);
DDBE_VEC_SENTINEL(vip->defn_p);
DDBE_VEC_SENTINEL(vip->type_p);
DDBE_VEC_SENTINEL(vip->offset_p);
DDBE_VEC_SENTINEL(vip->rtn_p);
DDBE_VEC_SENTINEL(vip->type_info_p);
vip->allocate = FALSE;
vip->allocate_ref = FALSE;
vip->free_rep = FALSE;
vip->ind_sp = NULL;
vip->tup_sp = NULL;
vip->ast_int_p = int_p;
DDBE_VEC_INIT(vip);
}
static void DDBE_init_tags
(void)
{
DDBE_dt_allocate = NAMETABLE_add_id("IDL_DT_ALLOCATE");
DDBE_dt_allocate_ref = NAMETABLE_add_id("IDL_DT_ALLOCATE_REF");
DDBE_dt_begin_nested_struct = NAMETABLE_add_id("IDL_DT_BEGIN_NESTED_STRUCT");
DDBE_dt_boolean = NAMETABLE_add_id("IDL_DT_BOOLEAN");
DDBE_dt_byte = NAMETABLE_add_id("IDL_DT_BYTE");
DDBE_dt_char = NAMETABLE_add_id("IDL_DT_CHAR");
DDBE_dt_conf_array = NAMETABLE_add_id("IDL_DT_CONF_ARRAY");
DDBE_dt_conf_struct = NAMETABLE_add_id("IDL_DT_CONF_STRUCT");
DDBE_dt_cs_array = NAMETABLE_add_id("IDL_DT_CS_ARRAY");
DDBE_dt_cs_attribute = NAMETABLE_add_id("IDL_DT_CS_ATTRIBUTE");
DDBE_dt_cs_rlse_shadow = NAMETABLE_add_id("IDL_DT_CS_RLSE_SHADOW");
DDBE_dt_cs_shadow = NAMETABLE_add_id("IDL_DT_CS_SHADOW");
DDBE_dt_cs_type = NAMETABLE_add_id("IDL_DT_CS_TYPE");
DDBE_dt_deleted_nodes = NAMETABLE_add_id("IDL_DT_DELETED_NODES");
DDBE_dt_does_not_exist = NAMETABLE_add_id("IDL_DT_DOES_NOT_EXIST");
DDBE_dt_double = NAMETABLE_add_id("IDL_DT_DOUBLE");
DDBE_dt_enc_union = NAMETABLE_add_id("IDL_DT_ENC_UNION");
DDBE_dt_end_nested_struct = NAMETABLE_add_id("IDL_DT_END_NESTED_STRUCT");
DDBE_dt_enum = NAMETABLE_add_id("IDL_DT_ENUM");
DDBE_dt_eol = NAMETABLE_add_id("IDL_DT_EOL");
DDBE_dt_error_status = NAMETABLE_add_id("IDL_DT_ERROR_STATUS");
DDBE_dt_first_is_limit = NAMETABLE_add_id("IDL_LIMIT_FIRST_IS");
DDBE_dt_first_is_early_limit = NAMETABLE_add_id("IDL_LIMIT_FIRST_IS | IDL_CF_EARLY");
DDBE_dt_fixed_array = NAMETABLE_add_id("IDL_DT_FIXED_ARRAY");
DDBE_dt_fixed_bound = NAMETABLE_add_id("IDL_BOUND_FIXED");
DDBE_dt_fixed_limit = NAMETABLE_add_id("IDL_LIMIT_FIXED");
DDBE_dt_fixed_struct = NAMETABLE_add_id("IDL_DT_FIXED_STRUCT");
DDBE_dt_float = NAMETABLE_add_id("IDL_DT_FLOAT");
DDBE_dt_free_rep = NAMETABLE_add_id("IDL_DT_FREE_REP");
DDBE_dt_full_ptr = NAMETABLE_add_id("IDL_DT_FULL_PTR");
DDBE_dt_hyper = NAMETABLE_add_id("IDL_DT_HYPER");
DDBE_dt_ignore = NAMETABLE_add_id("IDL_DT_IGNORE");
DDBE_dt_interface = NAMETABLE_add_id("IDL_DT_ORPC_INTERFACE");
DDBE_dt_in_context = NAMETABLE_add_id("IDL_DT_IN_CONTEXT");
DDBE_dt_in_out_context = NAMETABLE_add_id("IDL_DT_IN_OUT_CONTEXT");
DDBE_dt_last_is_limit = NAMETABLE_add_id("IDL_LIMIT_LAST_IS");
DDBE_dt_last_is_early_limit = NAMETABLE_add_id("IDL_LIMIT_LAST_IS | IDL_CF_EARLY");
DDBE_dt_length_is_limit = NAMETABLE_add_id("IDL_LIMIT_LENGTH_IS");
DDBE_dt_length_is_early_limit = NAMETABLE_add_id("IDL_LIMIT_LENGTH_IS | IDL_CF_EARLY");
DDBE_dt_long = NAMETABLE_add_id("IDL_DT_LONG");
DDBE_dt_max_is_bound = NAMETABLE_add_id("IDL_BOUND_MAX_IS");
DDBE_dt_max_is_early_bound = NAMETABLE_add_id("IDL_BOUND_MAX_IS | IDL_CF_EARLY");
DDBE_dt_min_is_bound = NAMETABLE_add_id("IDL_BOUND_MIN_IS");
DDBE_dt_min_is_early_bound = NAMETABLE_add_id("IDL_BOUND_MIN_IS | IDL_CF_EARLY");
DDBE_dt_modified = NAMETABLE_add_id("IDL_DT_MODIFIED");
DDBE_dt_ndr_align_2 = NAMETABLE_add_id("IDL_DT_NDR_ALIGN_2");
DDBE_dt_ndr_align_4 = NAMETABLE_add_id("IDL_DT_NDR_ALIGN_4");
DDBE_dt_ndr_align_8 = NAMETABLE_add_id("IDL_DT_NDR_ALIGN_8");
DDBE_dt_n_e_union = NAMETABLE_add_id("IDL_DT_N_E_UNION");
DDBE_dt_open_array = NAMETABLE_add_id("IDL_DT_OPEN_ARRAY");
DDBE_dt_out_context = NAMETABLE_add_id("IDL_DT_OUT_CONTEXT");
DDBE_dt_passed_by_ref = NAMETABLE_add_id("IDL_DT_PASSED_BY_REF");
DDBE_dt_pipe = NAMETABLE_add_id("IDL_DT_PIPE");
DDBE_dt_range = NAMETABLE_add_id("IDL_DT_RANGE");
DDBE_dt_ref_ptr = NAMETABLE_add_id("IDL_DT_REF_PTR");
DDBE_dt_represent_as = NAMETABLE_add_id("IDL_DT_REPRESENT_AS");
DDBE_dt_size_is_bound = NAMETABLE_add_id("IDL_BOUND_SIZE_IS");
DDBE_dt_size_is_early_bound = NAMETABLE_add_id("IDL_BOUND_SIZE_IS | IDL_CF_EARLY");
DDBE_dt_short = NAMETABLE_add_id("IDL_DT_SHORT");
DDBE_dt_small = NAMETABLE_add_id("IDL_DT_SMALL");
DDBE_dt_string = NAMETABLE_add_id("IDL_DT_STRING");
DDBE_dt_string_bound = NAMETABLE_add_id("IDL_BOUND_STRING");
DDBE_dt_string_limit = NAMETABLE_add_id("IDL_LIMIT_STRING");
DDBE_dt_transmit_as = NAMETABLE_add_id("IDL_DT_TRANSMIT_AS");
DDBE_dt_unique_ptr = NAMETABLE_add_id("IDL_DT_UNIQUE_PTR");
DDBE_dt_uhyper = NAMETABLE_add_id("IDL_DT_UHYPER");
DDBE_dt_ulong = NAMETABLE_add_id("IDL_DT_ULONG");
DDBE_dt_upper_conf_limit = NAMETABLE_add_id("IDL_LIMIT_UPPER_CONF");
DDBE_dt_ushort = NAMETABLE_add_id("IDL_DT_USHORT");
DDBE_dt_usmall = NAMETABLE_add_id("IDL_DT_USMALL");
DDBE_dt_v1_array = NAMETABLE_add_id("IDL_DT_V1_ARRAY");
DDBE_dt_v1_conf_struct = NAMETABLE_add_id("IDL_DT_V1_CONF_STRUCT");
DDBE_dt_v1_enum = NAMETABLE_add_id("IDL_DT_V1_ENUM");
DDBE_dt_v1_string = NAMETABLE_add_id("IDL_DT_V1_STRING");
DDBE_dt_varying_array = NAMETABLE_add_id("IDL_DT_VARYING_ARRAY");
DDBE_dt_void = NAMETABLE_add_id("IDL_DT_VOID");
}
static void DDBE_skip_to_tup
(
IR_tup_n_t **p_tup_p,
IR_opcode_k_t end_opcode
)
{
IR_tup_n_t *tup_p;
IR_opcode_k_t begin_opcode;
int scope;
tup_p = *p_tup_p;
scope = 0;
begin_opcode = tup_p->opcode;
while (TRUE)
{
if (tup_p->opcode == begin_opcode)
scope++;
else if (tup_p->opcode == end_opcode)
{
scope--;
if (scope == 0)
break;
}
tup_p = tup_p->next;
}
*p_tup_p = tup_p;
}
static void DDBE_push_indirection_scope
(
DDBE_vectors_t *vip
)
{
DDBE_ind_stack_t *new_p;
if (vip->p_cur_p == &vip->type_p && vip->ind_sp != NULL)
INTERNAL_ERROR("Current vector is type vector but *ind_sp != NULL");
new_p = NEW (DDBE_ind_stack_t);
new_p->ind_p = *(vip->p_cur_p);
new_p->off_p = vip->offset_p;
new_p->rtn_p = vip->rtn_p;
new_p->info_p= vip->type_info_p;
new_p->saved_defn_p = vip->saved_defn_p;
new_p->cfmt_info_tup_p = vip->cfmt_info_tup_p;
new_p->in_cfmt_struct_hdr = vip->in_cfmt_struct_hdr;
vip->in_cfmt_struct_hdr = FALSE;
new_p->in_flatarr = vip->in_flatarr;
vip->in_flatarr = FALSE;
new_p->next = vip->ind_sp;
vip->ind_sp = new_p;
vip->p_cur_p = &vip->defn_p;
}
static void DDBE_pop_indirection_scope
(
DDBE_vectors_t *vip
)
{
DDBE_ind_stack_t *top_p;
top_p = vip->ind_sp;
if (top_p == NULL)
{
INTERNAL_ERROR("Can't return from indirection scope");
return;
}
if (top_p->next == NULL)
{
vip->p_cur_p = &vip->type_p;
vip->type_p = top_p->ind_p;
}
else
{
if (vip->p_cur_p != &vip->defn_p)
INTERNAL_ERROR("Scope > 1 but current vector not definition vector");
vip->defn_p = top_p->ind_p;
}
vip->offset_p = top_p->off_p;
vip->rtn_p = top_p->rtn_p;
vip->type_info_p = top_p->info_p;
vip->saved_defn_p = top_p->saved_defn_p;
vip->cfmt_info_tup_p = top_p->cfmt_info_tup_p;
vip->in_cfmt_struct_hdr = top_p->in_cfmt_struct_hdr;
vip->in_flatarr = top_p->in_flatarr;
vip->ind_sp = top_p->next;
FREE(top_p);
}
static void DDBE_operation_info
(
AST_operation_n_t *oper_p
)
{
AST_parameter_n_t *param_p;
oper_p->be_info.dd_oper = NEW (DDBE_oper_i_t);
for (param_p = oper_p->parameters; param_p != NULL; param_p = param_p->next)
param_p->be_info.dd_param = NEW (DDBE_param_i_t);
oper_p->result->be_info.dd_param = NEW (DDBE_param_i_t);
}
static void DDBE_type_info
(
AST_type_n_t *type_p,
IR_flags_t flags
)
{
DDBE_type_i_t *type_i_p;
char inst_name[MAX_ID+1];
type_i_p = NEW (DDBE_type_i_t);
sprintf(inst_name, "%si_%ld", DDBE_PREFIX_IDL, DDBE_inst_num++);
type_i_p->inst_name = NAMETABLE_add_id(inst_name);
if (flags & IR_REP_AS)
type_p->rep_as_type->be_info.dd_type = type_i_p;
else if (flags & IR_CS_CHAR)
type_p->cs_char_type->be_info.dd_type = type_i_p;
else
type_p->be_info.dd_type = type_i_p;
}
static void DDBE_op_type_indirect
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip
)
{
AST_type_n_t *type_p;
DDBE_type_i_t *type_i_p;
DDBE_tup_stack_t *new_p;
IR_tup_n_t *tup_p;
tup_p = *p_tup_p;
type_p = tup_p->arg[IR_ARG_TYPE].type;
if (tup_p->flags & IR_REP_AS)
type_i_p = type_p->rep_as_type->be_info.dd_type;
else if (tup_p->flags & IR_CS_CHAR)
type_i_p = type_p->cs_char_type->be_info.dd_type;
else
type_i_p = type_p->be_info.dd_type;
if (type_i_p == NULL)
DDBE_type_info(type_p, tup_p->flags);
if (type_p->xmit_as_type != NULL
&& type_p->xmit_as_type->be_info.dd_type == NULL)
DDBE_type_info(type_p->xmit_as_type, 0);
DDBE_push_indirection_scope(vip);
IR_process_tup(vip->ir_ctx_p, tup_p);
new_p = NEW (DDBE_tup_stack_t);
new_p->tup_p = tup_p->next;
new_p->next = vip->tup_sp;
vip->tup_sp = new_p;
if (tup_p->flags & IR_REP_AS)
*p_tup_p = type_p->rep_as_type->data_tups;
else if (tup_p->flags & IR_CS_CHAR)
*p_tup_p = type_p->cs_char_type->data_tups;
else
*p_tup_p = type_p->data_tups;
vip->update_tup = FALSE;
}
static void DDBE_type_indirect_end
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip
)
{
DDBE_tup_stack_t *top_p;
top_p = vip->tup_sp;
if (top_p == NULL)
{
INTERNAL_ERROR("Can't return from indirect tuples");
return;
}
*p_tup_p = top_p->tup_p;
vip->tup_sp = top_p->next;
FREE(top_p);
DDBE_pop_indirection_scope(vip);
}
static void DDBE_properties_byte
(
AST_type_n_t *type_p,
DDBE_vec_rep_t **p_vec_p
)
{
char properties[DDBE_MAX_EXPR];
STRTAB_str_t prop_expr;
strlcpy(properties, "0", sizeof(properties));
if (FE_TEST(type_p->fe_info->flags, FE_HAS_CHAR))
strlcat(properties, "|IDL_PROP_DEP_CHAR", sizeof(properties));
if (FE_TEST(type_p->fe_info->flags, FE_HAS_FLOAT))
strlcat(properties, "|IDL_PROP_DEP_FLOAT", sizeof(properties));
if (FE_TEST(type_p->fe_info->flags, FE_HAS_INT))
strlcat(properties, "|IDL_PROP_DEP_INT", sizeof(properties));
if (FE_TEST(type_p->fe_info->flags, FE_MAYBE_WIRE_ALIGNED))
strlcat(properties, "|IDL_PROP_MAYBE_WIRE_ALIGNED", sizeof(properties));
if (type_p->xmit_as_type != NULL)
type_p = type_p->xmit_as_type;
if (FE_TEST(type_p->fe_info->flags, FE_HAS_PTR))
strlcat(properties, "|IDL_PROP_HAS_PTRS", sizeof(properties));
prop_expr = STRTAB_add_string(properties);
DDBE_expr_vec_entry(p_vec_p, DDBE_vec_expr_byte_k, prop_expr, "properties");
}
static void DDBE_op_marshall
(
IR_tup_n_t *tup_p,
DDBE_vectors_t *vip
)
{
char const *inst_name;
if (IR_cur_scope(vip->ir_ctx_p) == IR_SCP_STRUCT)
{
AST_field_n_t *field_p;
char const *field_name;
char comment[DDBE_MAX_COMMENT];
field_p = tup_p->arg[IR_ARG_FIELD].field;
NAMETABLE_id_to_string(field_p->name, &field_name);
sprintf(comment, "field %s offset", field_name);
DDBE_expr_vec_entry(&vip->offset_p, DDBE_vec_expr_k,
IR_field_expr(vip->ir_ctx_p, field_p), comment);
}
if (tup_p->flags & IR_CS_CHAR)
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_cs_attribute);
if (tup_p->arg[IR_ARG_INST].inst == NULL)
inst_name = NULL;
else
NAMETABLE_id_to_string(tup_p->arg[IR_ARG_INST].inst->name, &inst_name);
DDBE_scalar_vec_entry(vip->p_cur_p, tup_p->arg[IR_ARG_TYPE].type,
inst_name, vip);
if (IR_cur_scope(vip->ir_ctx_p) == IR_SCP_UNION && !vip->in_default_arm)
{
vip->arm_byte_cnt++;
DDBE_pad_vec_entry(vip->p_cur_p, DDBE_ARM_SIZE - vip->arm_byte_cnt);
}
}
static void DDBE_op_struct_begin
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip
)
{
IR_tup_n_t *tup_p;
AST_type_n_t *type_p;
char const *type_name;
boolean modified = FALSE;
boolean conformant;
char comment[DDBE_MAX_COMMENT];
boolean defn_done = TRUE;
tup_p = *p_tup_p;
type_p = tup_p->arg[IR_ARG_TYPE].type;
if (type_p->name == NAMETABLE_NIL_ID)
type_name = "anon_struct";
else
NAMETABLE_id_to_string(type_p->name, &type_name);
if (IR_cur_scope(vip->ir_ctx_p) != IR_SCP_STRUCT)
{
if (!type_p->be_info.dd_type->defn_done
&& IR_under_type(vip->ir_ctx_p, type_p) == 1)
{
defn_done = FALSE;
sprintf(comment, "struct %s size and offsets", type_name);
DDBE_comment_vec_entry(&vip->offset_p, comment);
sprintf(comment, "sizeof %s", type_name);
DDBE_type_info_vec_entry(DDBE_vec_sizeof_k, &vip->offset_p, type_p,
comment);
type_p->be_info.dd_type->offset_vec_p = vip->offset_p;
DDBE_type_info_vec_entry(DDBE_vec_offset_begin_k, &vip->offset_p,
type_p, NULL);
sprintf(comment, "struct %s definition", type_name);
DDBE_comment_vec_entry(&vip->defn_p, comment);
DDBE_indirect_vec_entry(&vip->defn_p,
&type_p->be_info.dd_type->offset_vec_p, "offset vector index");
type_p->be_info.dd_type->type_vec_p = vip->defn_p;
}
conformant = ((tup_p->flags & IR_CONFORMANT) != 0);
DDBE_tag_vec_entry(&vip->ind_sp->ind_p,
(conformant) ?
((AST_UNALIGN_SET(type_p)) ? DDBE_dt_v1_conf_struct
: DDBE_dt_conf_struct)
: DDBE_dt_fixed_struct);
if (!modified && !defn_done)
DDBE_reference_vec_entry(&vip->type_info_p, vip->ind_sp->ind_p, NULL);
DDBE_properties_byte(type_p, &vip->ind_sp->ind_p);
sprintf(comment, "type %s index", type_name);
DDBE_indirect_vec_entry(&vip->ind_sp->ind_p,
&type_p->be_info.dd_type->type_vec_p, comment);
if (IR_cur_scope(vip->ir_ctx_p) == IR_SCP_UNION && !vip->in_default_arm)
{
vip->arm_byte_cnt += 8;
DDBE_pad_vec_entry(&vip->ind_sp->ind_p,
DDBE_ARM_SIZE - vip->arm_byte_cnt);
}
if (defn_done)
{
DDBE_skip_to_tup(p_tup_p, IR_op_struct_end_k);
vip->update_tup = FALSE;
}
}
else
{
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_begin_nested_struct);
}
IR_process_tup(vip->ir_ctx_p, tup_p);
}
static void DDBE_op_struct_end
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip
)
{
AST_type_n_t *type_p;
type_p = (*p_tup_p)->arg[IR_ARG_TYPE].type;
IR_process_tup(vip->ir_ctx_p, *p_tup_p);
if (IR_cur_scope(vip->ir_ctx_p) != IR_SCP_STRUCT)
{
if (type_p->be_info.dd_type->defn_done
|| IR_under_type(vip->ir_ctx_p, type_p) > 0)
return;
type_p->be_info.dd_type->defn_done = TRUE;
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_eol);
DDBE_type_info_vec_entry(DDBE_vec_offset_end_k, &vip->offset_p, type_p,
NULL);
}
else
{
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_end_nested_struct);
}
}
static void DDBE_op_disc_union_begin
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip
)
{
IR_tup_n_t *tup_p;
IR_tup_n_t *sw_tup_p;
AST_type_n_t *type_p;
AST_disc_union_n_t *union_p;
char const *type_name;
char const *switch_name;
char const *union_name;
STRTAB_str_t union_expr;
char comment[DDBE_MAX_COMMENT];
boolean defn_done = TRUE;
tup_p = *p_tup_p;
type_p = tup_p->arg[IR_ARG_TYPE].type;
union_p = type_p->type_structure.disc_union;
if (type_p->name == NAMETABLE_NIL_ID)
type_name = "anon_union";
else
NAMETABLE_id_to_string(type_p->name, &type_name);
if (!type_p->be_info.dd_type->defn_done
&& IR_under_type(vip->ir_ctx_p, type_p) == 1)
{
defn_done = FALSE;
if (tup_p->flags & IR_ENCAPSULATED)
{
*p_tup_p = (*p_tup_p)->next;
sw_tup_p = *p_tup_p;
if (sw_tup_p->opcode != IR_op_switch_enc_k)
INTERNAL_ERROR("Expected encapsulated switch tuple");
vip->switch_name = sw_tup_p->arg[IR_ARG_NAME].name;
vip->switch_type = sw_tup_p->arg[IR_ARG_TYPE].type;
sprintf(comment, "union %s size and offset", type_name);
DDBE_comment_vec_entry(&vip->offset_p, comment);
sprintf(comment, "sizeof %s", type_name);
DDBE_type_info_vec_entry(DDBE_vec_sizeof_k, &vip->offset_p, type_p,
comment);
type_p->be_info.dd_type->offset_vec_p = vip->offset_p;
DDBE_type_info_vec_entry(DDBE_vec_offset_begin_k, &vip->offset_p,
type_p, NULL);
NAMETABLE_id_to_string(union_p->union_name, &union_name);
union_expr = STRTAB_add_string(union_name);
DDBE_expr_vec_entry(&vip->offset_p, DDBE_vec_expr_k, union_expr,
NULL);
DDBE_type_info_vec_entry(DDBE_vec_offset_end_k, &vip->offset_p,
type_p, NULL);
}
else
{
sprintf(comment, "n_e union %s size", type_name);
DDBE_comment_vec_entry(&vip->offset_p, comment);
sprintf(comment, "sizeof %s", type_name);
DDBE_type_info_vec_entry(DDBE_vec_sizeof_k, &vip->offset_p, type_p,
comment);
type_p->be_info.dd_type->offset_vec_p = vip->offset_p;
}
sprintf(comment, "union %s definition", type_name);
DDBE_comment_vec_entry(&vip->defn_p, comment);
DDBE_indirect_vec_entry(&vip->defn_p,
&type_p->be_info.dd_type->offset_vec_p, "offset vector index");
type_p->be_info.dd_type->type_vec_p = vip->defn_p;
DDBE_scalar_vec_entry(&vip->defn_p,
ASTP_chase_ptr_to_type(vip->switch_type), "switch type", vip);
DDBE_long_vec_entry(&vip->defn_p, DDBE_vec_long_k,
tup_p->arg[IR_ARG_INT].int_val, "number of arms");
}
DDBE_tag_vec_entry(&vip->ind_sp->ind_p, (tup_p->flags & IR_ENCAPSULATED) ?
DDBE_dt_enc_union : DDBE_dt_n_e_union);
if (!defn_done)
DDBE_reference_vec_entry(&vip->type_info_p, vip->ind_sp->ind_p, NULL);
DDBE_properties_byte(type_p, &vip->ind_sp->ind_p);
if (!(tup_p->flags & IR_ENCAPSULATED))
{
NAMETABLE_id_to_string(vip->switch_name, &switch_name);
sprintf(comment, "switch %s index", switch_name);
DDBE_long_vec_entry(&vip->ind_sp->ind_p, DDBE_vec_long_k,
vip->switch_index, comment);
}
sprintf(comment, "type %s index", type_name);
DDBE_indirect_vec_entry(&vip->ind_sp->ind_p,
&type_p->be_info.dd_type->type_vec_p, comment);
if (IR_cur_scope(vip->ir_ctx_p) == IR_SCP_UNION && !vip->in_default_arm)
{
vip->arm_byte_cnt += 8;
DDBE_pad_vec_entry(&vip->ind_sp->ind_p,
DDBE_ARM_SIZE - vip->arm_byte_cnt);
}
if (defn_done)
{
DDBE_skip_to_tup(p_tup_p, IR_op_disc_union_end_k);
vip->update_tup = FALSE;
}
IR_process_tup(vip->ir_ctx_p, tup_p);
if (IR_parent_scope(vip->ir_ctx_p) == IR_SCP_STRUCT)
{
AST_field_n_t *field_p;
char const *field_name;
field_p = (AST_field_n_t *)IR_cur_inst(vip->ir_ctx_p);
NAMETABLE_id_to_string(field_p->name, &field_name);
sprintf(comment, "field %s offset", field_name);
DDBE_expr_vec_entry(&vip->ind_sp->off_p, DDBE_vec_expr_k,
IR_field_expr(vip->ir_ctx_p, field_p), comment);
}
}
static void DDBE_op_disc_union_end
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip
)
{
AST_type_n_t *type_p;
type_p = (*p_tup_p)->arg[IR_ARG_TYPE].type;
IR_process_tup(vip->ir_ctx_p, *p_tup_p);
type_p->be_info.dd_type->defn_done = TRUE;
vip->in_default_arm = FALSE;
}
static void DDBE_op_pipe_begin
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip
)
{
IR_tup_n_t *tup_p;
AST_type_n_t *type_p;
char const *type_name;
char comment[DDBE_MAX_COMMENT];
tup_p = *p_tup_p;
type_p = tup_p->arg[IR_ARG_TYPE].type;
NAMETABLE_id_to_string(type_p->name, &type_name);
IR_process_tup(vip->ir_ctx_p, tup_p);
if (!type_p->be_info.dd_type->defn_done)
{
sprintf(comment, "pipe %s definition", type_name);
DDBE_comment_vec_entry(&vip->defn_p, comment);
type_p->be_info.dd_type->type_vec_p = vip->defn_p;
}
DDBE_tag_vec_entry(&vip->ind_sp->ind_p, DDBE_dt_pipe);
DDBE_properties_byte(type_p, &vip->ind_sp->ind_p);
sprintf(comment, "type %s index", type_name);
DDBE_indirect_vec_entry(&vip->ind_sp->ind_p,
&type_p->be_info.dd_type->type_vec_p, comment);
if (type_p->be_info.dd_type->defn_done)
{
DDBE_skip_to_tup(p_tup_p, IR_op_pipe_end_k);
vip->update_tup = FALSE;
}
}
static void DDBE_op_pipe_end
(
IR_tup_n_t *tup_p,
DDBE_vectors_t *vip
)
{
AST_type_n_t *type_p;
type_p = tup_p->arg[IR_ARG_TYPE].type;
IR_process_tup(vip->ir_ctx_p, tup_p);
type_p->be_info.dd_type->defn_done = TRUE;
}
static void DDBE_op_array
(
IR_tup_n_t *tup_p,
DDBE_vectors_t *vip
)
{
AST_type_n_t *type_p;
AST_type_n_t *base_type_p;
char comment[DDBE_MAX_COMMENT];
boolean flat_is_full;
boolean in_flatarr;
type_p = tup_p->arg[IR_ARG_TYPE].type;
base_type_p = type_p->type_structure.array->element_type;
in_flatarr = vip->in_flatarr;
if (IR_cur_scope(vip->ir_ctx_p) == IR_SCP_STRUCT && !in_flatarr)
{
AST_field_n_t *field_p;
char const *field_name;
field_p = tup_p->arg[IR_ARG_FIELD].field;
NAMETABLE_id_to_string(field_p->name, &field_name);
sprintf(comment, "field %s offset", field_name);
DDBE_expr_vec_entry(&vip->offset_p, DDBE_vec_expr_arr_k,
IR_field_expr(vip->ir_ctx_p, field_p), comment);
}
IR_process_tup(vip->ir_ctx_p, tup_p);
DDBE_push_indirection_scope(vip);
DDBE_noop_vec_entry(&vip->defn_p);
if (!in_flatarr)
DDBE_properties_byte(type_p, &vip->ind_sp->ind_p);
sprintf(comment, "%s array index", (in_flatarr) ? "flat" : "full");
DDBE_reference_vec_entry(&vip->ind_sp->ind_p, vip->defn_p, comment);
if (!in_flatarr &&
(base_type_p->kind != AST_array_k || IR_in_array(vip->ir_ctx_p) > 1))
{
DDBE_reference_vec_entry(&vip->ind_sp->ind_p, vip->defn_p,
"flat array index");
flat_is_full = TRUE;
}
else
flat_is_full = FALSE;
if ((in_flatarr || flat_is_full)
&& tup_p->opcode == IR_op_conformant_array_k
&& IR_parent_scope(vip->ir_ctx_p) == IR_SCP_STRUCT)
DDBE_reference_vec_entry(&vip->ind_sp->saved_defn_p, vip->defn_p,
"flat conformant array index");
}
static void DDBE_op_array_bounds
(
IR_tup_n_t *tup_p,
DDBE_vectors_t *vip
)
{
AST_type_n_t *type_p;
char const *type_name;
char comment[DDBE_MAX_COMMENT];
type_p = tup_p->arg[IR_ARG_TYPE].type;
if (type_p->name == NAMETABLE_NIL_ID)
type_name = "anon_array";
else
NAMETABLE_id_to_string(type_p->name, &type_name);
sprintf(comment, "array %s %s instance", type_name,
(vip->ind_sp->in_flatarr) ? "flat" : "full");
DDBE_comment_vec_entry(&vip->defn_p, comment);
DDBE_byte_vec_entry(&vip->defn_p, DDBE_vec_byte_3m4_k,
tup_p->arg[IR_ARG_INT].int_val, "num dimensions");
}
static void DDBE_func_code_vec_entry(
DDBE_vec_rep_t **p_defn_p,
byte func_code
)
{
const char * name = NULL;
STRTAB_str_t name_id;
switch(func_code)
{
case IR_EXP_FC_NONE: name = "IDL_FC_NONE"; break;
case IR_EXP_FC_DIV_2: name = "IDL_FC_DIV_2"; break;
case IR_EXP_FC_MUL_2: name = "IDL_FC_MUL_2"; break;
case IR_EXP_FC_SUB_1: name = "IDL_FC_SUB_1"; break;
case IR_EXP_FC_ADD_1: name = "IDL_FC_ADD_1"; break;
case IR_EXP_FC_ALIGN_2: name = "IDL_FC_ALIGN_2"; break;
case IR_EXP_FC_ALIGN_4: name = "IDL_FC_ALIGN_4"; break;
case IR_EXP_FC_ALIGN_8: name = "IDL_FC_ALIGN_8"; break;
case IR_EXP_FC_CALLBACK:name = "IDL_FC_CALLBACK"; break;
case IR_EXP_FC_DIV_4: name = "IDL_FC_DIV_4"; break;
case IR_EXP_FC_MUL_4: name = "IDL_FC_MUL_4"; break;
case IR_EXP_FC_DIV_8: name = "IDL_FC_DIV_8"; break;
case IR_EXP_FC_MUL_8: name = "IDL_FC_MUL_8"; break;
case IR_EXP_FC_FIXED: name = "IDL_FC_FIXED"; break;
default: return;
}
name_id = STRTAB_add_string(name);
DDBE_expr_vec_entry(p_defn_p, DDBE_vec_expr_byte_k, name_id, "bound info");
}
static void DDBE_op_bound
(
IR_tup_n_t *tup_p,
DDBE_vectors_t *vip
)
{
IR_bound_k_t bound_kind;
const char *bound_text = NULL;
AST_type_n_t *ref_type_p;
AST_parameter_n_t *ref_param_p;
AST_field_n_t *ref_field_p;
long ref_index;
NAMETABLE_id_t ref_name_id;
char const *ref_name;
char const *ref_text;
STRTAB_str_t octetsize_expr;
char ref_expr[DDBE_MAX_COMMENT];
bound_kind = tup_p->arg[IR_ARG_BOUND].bound_k;
if (bound_kind == IR_bnd_fixed_k)
{
if (vip->conformant)
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_fixed_bound);
DDBE_long_vec_entry(&vip->defn_p, DDBE_vec_long_k,
tup_p->arg[IR_ARG_INT].int_val, "fixed bound");
return;
}
switch (bound_kind)
{
case IR_bnd_min_is_k:
bound_text = "min_is";
if (tup_p->flags & IR_CF_EARLY)
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_min_is_early_bound);
else
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_min_is_bound);
break;
case IR_bnd_max_is_k:
bound_text = "max_is";
if (tup_p->flags & IR_CF_EARLY)
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_max_is_early_bound);
else
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_max_is_bound);
break;
case IR_bnd_size_is_k:
bound_text = "size_is";
if (tup_p->flags & IR_CF_EARLY)
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_size_is_early_bound);
else
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_size_is_bound);
DDBE_func_code_vec_entry(&vip->defn_p, tup_p->arg[IR_ARG_BOUND_XTRA].byt_val);
break;
case IR_bnd_string_k:
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_string_bound);
if (tup_p->flags & IR_REP_AS)
{
NAMETABLE_id_to_string(
tup_p->arg[IR_ARG_TYPE2].type->rep_as_type->type_name,
&ref_name);
sprintf(ref_expr, "sizeof(%s)", ref_name);
octetsize_expr = STRTAB_add_string(ref_expr);
DDBE_expr_vec_entry(&vip->defn_p, DDBE_vec_expr_byte_k,
octetsize_expr, "octetsize");
}
else
DDBE_byte_vec_entry(&vip->defn_p, DDBE_vec_byte_k,
tup_p->arg[IR_ARG_INT].int_val, "octetsize");
if (tup_p->arg[IR_ARG_PFNUM].int_val == 0)
DDBE_long_vec_entry(&vip->defn_p, DDBE_vec_long_k, -1,
"dummy value");
else
DDBE_long_vec_entry(&vip->defn_p, DDBE_vec_long_k,
tup_p->arg[IR_ARG_PFNUM].int_val, "string field number");
return;
default:
INTERNAL_ERROR("Invalid bound kind");
}
if (IR_under_struct(vip->ir_ctx_p))
{
ref_field_p = tup_p->arg[IR_ARG_FIELD].field;
ref_index = tup_p->arg[IR_ARG_PFNUM].int_val;
ref_type_p = ASTP_chase_ptr_to_type(ref_field_p->type);
ref_name_id = ref_field_p->name;
ref_text = "field";
}
else
{
ref_param_p = tup_p->arg[IR_ARG_PARAM].param;
ref_index = tup_p->arg[IR_ARG_PFNUM].int_val;
ref_type_p = ASTP_chase_ptr_to_type(ref_param_p->type);
ref_name_id = ref_param_p->name;
ref_text = "param";
}
DDBE_scalar_vec_entry(&vip->defn_p, ref_type_p, "bound type", vip);
NAMETABLE_id_to_string(ref_name_id, &ref_name);
sprintf(ref_expr, "%s number of %s reference", ref_text, bound_text);
DDBE_long_vec_entry(&vip->defn_p, DDBE_vec_long_k, ref_index, ref_expr);
}
static void DDBE_op_limit
(
IR_tup_n_t *tup_p,
DDBE_vectors_t *vip
)
{
IR_limit_k_t limit_kind;
char const *limit_text = NULL;
AST_type_n_t *ref_type_p;
AST_parameter_n_t *ref_param_p;
AST_field_n_t *ref_field_p;
long ref_index;
NAMETABLE_id_t ref_name_id;
char const *ref_name;
char const *ref_text;
STRTAB_str_t octetsize_expr;
char ref_expr[DDBE_MAX_COMMENT];
if (vip->in_cfmt_struct_hdr)
return;
limit_kind = tup_p->arg[IR_ARG_LIMIT].limit_k;
if (limit_kind == IR_lim_fixed_k)
{
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_fixed_limit);
DDBE_long_vec_entry(&vip->defn_p, DDBE_vec_long_k,
tup_p->arg[IR_ARG_INT].int_val, "fixed limit");
return;
}
if (limit_kind == IR_lim_string_k)
{
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_string_limit);
if (tup_p->flags & IR_REP_AS)
{
NAMETABLE_id_to_string(
tup_p->arg[IR_ARG_TYPE2].type->rep_as_type->type_name,
&ref_name);
sprintf(ref_expr, "sizeof(%s)", ref_name);
octetsize_expr = STRTAB_add_string(ref_expr);
DDBE_expr_vec_entry(&vip->defn_p, DDBE_vec_expr_byte_k,
octetsize_expr, "octetsize");
}
else
DDBE_byte_vec_entry(&vip->defn_p, DDBE_vec_byte_k,
tup_p->arg[IR_ARG_INT].int_val, "octetsize");
DDBE_long_vec_entry(&vip->defn_p, DDBE_vec_long_k, -1, "dummy value");
return;
}
if (limit_kind == IR_lim_upper_conf_k)
{
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_upper_conf_limit);
DDBE_long_vec_entry(&vip->defn_p, DDBE_vec_long_k, -1, "dummy value");
return;
}
switch (limit_kind)
{
case IR_lim_first_is_k:
limit_text = "first_is";
if (tup_p->flags & IR_CF_EARLY)
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_first_is_early_limit);
else
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_first_is_limit);
break;
case IR_lim_last_is_k:
limit_text = "last_is";
if (tup_p->flags & IR_CF_EARLY)
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_last_is_early_limit);
else
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_last_is_limit);
break;
case IR_lim_length_is_k:
limit_text = "length_is";
if (tup_p->flags & IR_CF_EARLY)
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_length_is_early_limit);
else
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_length_is_limit);
DDBE_func_code_vec_entry(&vip->defn_p, tup_p->arg[IR_ARG_BOUND_XTRA].byt_val);
break;
default:
INTERNAL_ERROR("Invalid data limit kind");
}
if (IR_under_struct(vip->ir_ctx_p))
{
ref_field_p = tup_p->arg[IR_ARG_FIELD].field;
ref_index = tup_p->arg[IR_ARG_PFNUM].int_val;
ref_type_p = ASTP_chase_ptr_to_type(ref_field_p->type);
ref_name_id = ref_field_p->name;
ref_text = "field";
}
else
{
ref_param_p = tup_p->arg[IR_ARG_PARAM].param;
ref_index = tup_p->arg[IR_ARG_PFNUM].int_val;
ref_type_p = ASTP_chase_ptr_to_type(ref_param_p->type);
ref_name_id = ref_param_p->name;
ref_text = "param";
}
DDBE_scalar_vec_entry(&vip->defn_p, ref_type_p, "limit type", vip);
NAMETABLE_id_to_string(ref_name_id, &ref_name);
sprintf(ref_expr, "%s number of %s reference", ref_text, limit_text);
DDBE_long_vec_entry(&vip->defn_p, DDBE_vec_long_k, ref_index, ref_expr);
}
static void DDBE_op_array_end
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip
)
{
if (vip->in_cfmt_struct_hdr && (*p_tup_p)->arg[IR_ARG_TYPE].type ==
vip->cfmt_info_tup_p->arg[IR_ARG_TUP].tup->arg[IR_ARG_TYPE].type)
{
IR_process_tup(vip->ir_ctx_p, *p_tup_p);
*p_tup_p = vip->cfmt_info_tup_p;
DDBE_pop_indirection_scope(vip);
}
else
{
IR_process_tup(vip->ir_ctx_p, *p_tup_p);
DDBE_pop_indirection_scope(vip);
}
}
static void DDBE_op_conformant_info
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip
)
{
IR_tup_n_t *tup_p;
tup_p = (*p_tup_p)->arg[IR_ARG_TUP].tup;
if (tup_p->opcode == IR_op_conformant_array_k)
vip->saved_defn_p = vip->defn_p;
else
{
IR_process_tup(vip->ir_ctx_p, tup_p);
DDBE_push_indirection_scope(vip);
DDBE_noop_vec_entry(&vip->defn_p);
DDBE_reference_vec_entry(&vip->ind_sp->ind_p, vip->defn_p,
"flat conformant array index");
vip->in_cfmt_struct_hdr = TRUE;
vip->cfmt_info_tup_p = *p_tup_p;
vip->conformant = TRUE;
tup_p = tup_p->next;
if (tup_p->opcode != IR_op_array_bounds_k)
INTERNAL_ERROR("Logic error for conformant struct");
*p_tup_p = tup_p;
vip->update_tup = FALSE;
}
}
static void DDBE_op_pointer
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip,
NAMETABLE_id_t pointer_tag
)
{
IR_tup_n_t *tup_p;
tup_p = *p_tup_p;
if (IR_cur_scope(vip->ir_ctx_p) == IR_SCP_STRUCT)
{
AST_field_n_t *field_p;
char const *field_name;
char comment[DDBE_MAX_COMMENT];
field_p = tup_p->arg[IR_ARG_FIELD].field;
NAMETABLE_id_to_string(field_p->name, &field_name);
sprintf(comment, "field %s offset", field_name);
DDBE_expr_vec_entry(&vip->offset_p, DDBE_vec_expr_k,
IR_field_expr(vip->ir_ctx_p, field_p), comment);
if (AST_IGNORE_SET(field_p))
{
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_ignore);
DDBE_skip_to_tup(p_tup_p, IR_op_pointee_end_k);
return;
}
}
DDBE_tag_vec_entry(vip->p_cur_p, pointer_tag);
IR_process_tup(vip->ir_ctx_p, tup_p);
if (IR_parent_scope(vip->ir_ctx_p) != IR_SCP_TOPLEVEL
&& IR_parent_scope(vip->ir_ctx_p) != IR_SCP_STRUCT
&& IR_parent_scope(vip->ir_ctx_p) != IR_SCP_UNION)
return;
DDBE_push_indirection_scope(vip);
DDBE_noop_vec_entry(&vip->defn_p);
DDBE_properties_byte(
tup_p->arg[IR_ARG_TYPE].type->type_structure.pointer->pointee_type,
&vip->ind_sp->ind_p);
DDBE_reference_vec_entry(&vip->ind_sp->ind_p, vip->defn_p, "pointee index");
if (IR_parent_scope(vip->ir_ctx_p) == IR_SCP_UNION && !vip->in_default_arm)
{
vip->arm_byte_cnt += 8;
DDBE_pad_vec_entry(&vip->ind_sp->ind_p,
DDBE_ARM_SIZE - vip->arm_byte_cnt);
}
}
static void DDBE_op_pointee_end
(
IR_tup_n_t *tup_p,
DDBE_vectors_t *vip
)
{
IR_process_tup(vip->ir_ctx_p, tup_p);
if (IR_cur_scope(vip->ir_ctx_p) == IR_SCP_TOPLEVEL
|| IR_cur_scope(vip->ir_ctx_p) == IR_SCP_STRUCT
|| IR_cur_scope(vip->ir_ctx_p) == IR_SCP_UNION)
DDBE_pop_indirection_scope(vip);
}
static void DDBE_op_transmit_as
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip
)
{
IR_tup_n_t *tup_p;
AST_type_n_t *type_p;
AST_type_n_t *pres_p;
char const *pres_name;
char rtn_name[MAX_ID];
char comment[DDBE_MAX_COMMENT];
tup_p = *p_tup_p;
type_p = tup_p->arg[IR_ARG_TYPE].type;
pres_p = tup_p->arg[IR_ARG_TYPE2].type;
if (pres_p->name == NAMETABLE_NIL_ID)
NAMETABLE_id_to_string(pres_p->type_structure.pointer->pointee_type->name, &pres_name);
else
NAMETABLE_id_to_string(pres_p->name, &pres_name);
if (vip->free_rep)
{
DDBE_tag_vec_entry(&vip->ind_sp->ind_p, DDBE_dt_free_rep);
DDBE_reference_vec_entry(&vip->ind_sp->ind_p,
pres_p->be_info.dd_type->rtn_vec_p->next->next, "_free_inst index");
DDBE_skip_to_tup(p_tup_p, IR_op_transmit_end_k);
return;
}
IR_process_tup(vip->ir_ctx_p, tup_p);
if (pres_p->be_info.dd_type->offset_vec_p == NULL)
{
sprintf(comment, "presented type %s size", pres_name);
DDBE_comment_vec_entry(&vip->offset_p, comment);
sprintf(comment, "sizeof %s", pres_name);
DDBE_type_info_vec_entry(DDBE_vec_sizeof_k, &vip->offset_p, pres_p,
comment);
pres_p->be_info.dd_type->offset_vec_p = vip->offset_p;
}
if (IR_parent_scope(vip->ir_ctx_p) == IR_SCP_STRUCT)
{
AST_field_n_t *field_p;
char const *field_name;
field_p = (AST_field_n_t *)IR_cur_inst(vip->ir_ctx_p);
NAMETABLE_id_to_string(field_p->name, &field_name);
sprintf(comment, "field %s offset", field_name);
DDBE_expr_vec_entry(&vip->ind_sp->off_p, DDBE_vec_expr_k,
IR_field_expr(vip->ir_ctx_p, field_p), comment);
}
if (!pres_p->be_info.dd_type->defn_done)
DDBE_noop_vec_entry(&vip->defn_p);
DDBE_tag_vec_entry(&vip->ind_sp->ind_p, DDBE_dt_transmit_as);
if (!pres_p->be_info.dd_type->defn_done)
DDBE_reference_vec_entry(&vip->type_info_p, vip->ind_sp->ind_p, NULL);
DDBE_properties_byte(type_p, &vip->ind_sp->ind_p);
sprintf(comment, "type %s index", pres_name);
DDBE_indirect_vec_entry(&vip->ind_sp->ind_p,
&pres_p->be_info.dd_type->type_vec_p, comment);
if (IR_parent_scope(vip->ir_ctx_p) == IR_SCP_UNION && !vip->in_default_arm)
{
vip->arm_byte_cnt += 8;
DDBE_pad_vec_entry(&vip->ind_sp->ind_p,
DDBE_ARM_SIZE - vip->arm_byte_cnt);
}
if (pres_p->be_info.dd_type->defn_done)
{
DDBE_skip_to_tup(p_tup_p, IR_op_transmit_end_k);
IR_process_tup(vip->ir_ctx_p, *p_tup_p);
return;
}
pres_p->be_info.dd_type->defn_done = TRUE;
sprintf(rtn_name, "%s%s", pres_name, DDBE_SUFFIX_TO_XMIT);
DDBE_name_vec_entry(&vip->rtn_p, NAMETABLE_add_id(rtn_name), "");
pres_p->be_info.dd_type->rtn_vec_p = vip->rtn_p;
sprintf(rtn_name, "%s%s", pres_name, DDBE_SUFFIX_FROM_XMIT);
DDBE_name_vec_entry(&vip->rtn_p, NAMETABLE_add_id(rtn_name), "");
sprintf(rtn_name, "%s%s", pres_name, DDBE_SUFFIX_FREE_INST);
DDBE_name_vec_entry(&vip->rtn_p, NAMETABLE_add_id(rtn_name), "");
sprintf(rtn_name, "%s%s", pres_name, DDBE_SUFFIX_FREE_XMIT);
DDBE_name_vec_entry(&vip->rtn_p, NAMETABLE_add_id(rtn_name), "");
sprintf(comment, "presented type %s definition", pres_name);
DDBE_comment_vec_entry(&vip->defn_p, comment);
sprintf(comment, "%s offset vector index", pres_name);
DDBE_indirect_vec_entry(&vip->defn_p,
&pres_p->be_info.dd_type->offset_vec_p, comment);
pres_p->be_info.dd_type->type_vec_p = vip->defn_p;
sprintf(comment, "%s routine vector index", pres_name);
DDBE_indirect_vec_entry(&vip->defn_p,
&pres_p->be_info.dd_type->rtn_vec_p, comment);
}
static void DDBE_op_represent_as
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip
)
{
IR_tup_n_t *tup_p;
AST_type_n_t *type_p;
AST_rep_as_n_t *rep_p;
char const *type_name;
char const *local_name;
char rtn_name[MAX_ID];
char comment[DDBE_MAX_COMMENT];
char local_size[DDBE_MAX_EXPR];
STRTAB_str_t size_expr;
tup_p = *p_tup_p;
type_p = tup_p->arg[IR_ARG_TYPE].type;
rep_p = tup_p->arg[IR_ARG_REP_AS].rep_as;
NAMETABLE_id_to_string(type_p->name, &type_name);
NAMETABLE_id_to_string(rep_p->type_name, &local_name);
if (vip->free_rep)
{
DDBE_tag_vec_entry(&vip->ind_sp->ind_p, DDBE_dt_free_rep);
DDBE_reference_vec_entry(&vip->ind_sp->ind_p,
rep_p->be_info.dd_type->rtn_vec_p->next->next, "_free_local index");
DDBE_skip_to_tup(p_tup_p, IR_op_represent_end_k);
return;
}
IR_process_tup(vip->ir_ctx_p, tup_p);
if (rep_p->be_info.dd_type->offset_vec_p == NULL)
{
sprintf(comment, "local type %s size", local_name);
DDBE_comment_vec_entry(&vip->offset_p, comment);
sprintf(local_size, "sizeof(%s)", local_name);
size_expr = STRTAB_add_string(local_size);
sprintf(comment, "local type size");
DDBE_expr_vec_entry(&vip->offset_p, DDBE_vec_expr_long_k, size_expr,
comment);
rep_p->be_info.dd_type->offset_vec_p = vip->offset_p;
}
if (IR_parent_scope(vip->ir_ctx_p) == IR_SCP_STRUCT)
{
AST_field_n_t *field_p;
char const *field_name;
field_p = (AST_field_n_t *)IR_cur_inst(vip->ir_ctx_p);
NAMETABLE_id_to_string(field_p->name, &field_name);
sprintf(comment, "field %s offset", field_name);
DDBE_expr_vec_entry(&vip->ind_sp->off_p, DDBE_vec_expr_k,
IR_field_expr(vip->ir_ctx_p, field_p), comment);
}
if (!rep_p->be_info.dd_type->defn_done)
DDBE_noop_vec_entry(&vip->defn_p);
DDBE_tag_vec_entry(&vip->ind_sp->ind_p, DDBE_dt_represent_as);
if (!rep_p->be_info.dd_type->defn_done)
DDBE_reference_vec_entry(&vip->type_info_p, vip->ind_sp->ind_p, NULL);
DDBE_properties_byte(type_p, &vip->ind_sp->ind_p);
sprintf(comment, "type %s index", type_name);
DDBE_indirect_vec_entry(&vip->ind_sp->ind_p,
&rep_p->be_info.dd_type->type_vec_p, comment);
if (IR_parent_scope(vip->ir_ctx_p) == IR_SCP_UNION && !vip->in_default_arm)
{
vip->arm_byte_cnt += 8;
DDBE_pad_vec_entry(&vip->ind_sp->ind_p,
DDBE_ARM_SIZE - vip->arm_byte_cnt);
}
if (rep_p->be_info.dd_type->defn_done)
{
DDBE_skip_to_tup(p_tup_p, IR_op_represent_end_k);
IR_process_tup(vip->ir_ctx_p, *p_tup_p);
return;
}
rep_p->be_info.dd_type->defn_done = TRUE;
sprintf(rtn_name, "%s%s", type_name, DDBE_SUFFIX_FROM_LOCAL);
DDBE_name_vec_entry(&vip->rtn_p, NAMETABLE_add_id(rtn_name), "");
rep_p->be_info.dd_type->rtn_vec_p = vip->rtn_p;
sprintf(rtn_name, "%s%s", type_name, DDBE_SUFFIX_TO_LOCAL);
DDBE_name_vec_entry(&vip->rtn_p, NAMETABLE_add_id(rtn_name), "");
sprintf(rtn_name, "%s%s", type_name, DDBE_SUFFIX_FREE_LOCAL);
DDBE_name_vec_entry(&vip->rtn_p, NAMETABLE_add_id(rtn_name), "");
sprintf(rtn_name, "%s%s", type_name, DDBE_SUFFIX_FREE_INST);
DDBE_name_vec_entry(&vip->rtn_p, NAMETABLE_add_id(rtn_name), "");
sprintf(comment, "network type %s definition", type_name);
DDBE_comment_vec_entry(&vip->defn_p, comment);
sprintf(comment, "%s offset vector index", local_name);
DDBE_indirect_vec_entry(&vip->defn_p,
&rep_p->be_info.dd_type->offset_vec_p, comment);
rep_p->be_info.dd_type->type_vec_p = vip->defn_p;
sprintf(comment, "%s routine vector index", type_name);
DDBE_indirect_vec_entry(&vip->defn_p,
&rep_p->be_info.dd_type->rtn_vec_p, comment);
}
static void DDBE_op_cs_char
(
IR_tup_n_t **p_tup_p,
DDBE_vectors_t *vip
)
{
IR_tup_n_t *tup_p;
AST_type_n_t *type_p;
AST_cs_char_n_t *ichar_p;
char const *type_name;
char const *local_name;
char rtn_name[MAX_ID];
char comment[DDBE_MAX_COMMENT];
char local_size[DDBE_MAX_EXPR];
STRTAB_str_t size_expr;
tup_p = *p_tup_p;
type_p = tup_p->arg[IR_ARG_TYPE].type;
ichar_p = tup_p->arg[IR_ARG_CS_CHAR].cs_char;
NAMETABLE_id_to_string(type_p->name, &type_name);
NAMETABLE_id_to_string(ichar_p->type_name, &local_name);
IR_process_tup(vip->ir_ctx_p, tup_p);
if (ichar_p->be_info.dd_type->offset_vec_p == NULL)
{
sprintf(comment, "local type %s size", local_name);
DDBE_comment_vec_entry(&vip->offset_p, comment);
sprintf(local_size, "sizeof(%s)", local_name);
size_expr = STRTAB_add_string(local_size);
sprintf(comment, "local type size");
DDBE_expr_vec_entry(&vip->offset_p, DDBE_vec_expr_long_k, size_expr,
comment);
ichar_p->be_info.dd_type->offset_vec_p = vip->offset_p;
}
if (IR_parent_scope(vip->ir_ctx_p) == IR_SCP_STRUCT)
{
AST_field_n_t *field_p;
char const *field_name;
field_p = (AST_field_n_t *)IR_cur_inst(vip->ir_ctx_p);
NAMETABLE_id_to_string(field_p->name, &field_name);
sprintf(comment, "field %s offset", field_name);
DDBE_expr_vec_entry(&vip->ind_sp->off_p, DDBE_vec_expr_k,
IR_field_expr(vip->ir_ctx_p, field_p), comment);
}
if (!ichar_p->be_info.dd_type->defn_done)
DDBE_noop_vec_entry(&vip->defn_p);
DDBE_tag_vec_entry(&vip->ind_sp->ind_p, DDBE_dt_cs_type);
if (!ichar_p->be_info.dd_type->defn_done)
DDBE_reference_vec_entry(&vip->type_info_p, vip->ind_sp->ind_p, NULL);
DDBE_properties_byte(type_p, &vip->ind_sp->ind_p);
sprintf(comment, "type %s index", type_name);
DDBE_indirect_vec_entry(&vip->ind_sp->ind_p,
&ichar_p->be_info.dd_type->type_vec_p, comment);
if (IR_parent_scope(vip->ir_ctx_p) == IR_SCP_UNION && !vip->in_default_arm)
{
vip->arm_byte_cnt += 8;
DDBE_pad_vec_entry(&vip->ind_sp->ind_p,
DDBE_ARM_SIZE - vip->arm_byte_cnt);
}
if (ichar_p->be_info.dd_type->defn_done)
{
DDBE_skip_to_tup(p_tup_p, IR_op_cs_char_end_k);
IR_process_tup(vip->ir_ctx_p, *p_tup_p);
return;
}
ichar_p->be_info.dd_type->defn_done = TRUE;
sprintf(rtn_name, "%s%s", local_name, DDBE_SUFFIX_NET_SIZE);
DDBE_name_vec_entry(&vip->rtn_p, NAMETABLE_add_id(rtn_name), "");
ichar_p->be_info.dd_type->rtn_vec_p = vip->rtn_p;
sprintf(rtn_name, "%s%s", local_name, DDBE_SUFFIX_TO_NETCS);
DDBE_name_vec_entry(&vip->rtn_p, NAMETABLE_add_id(rtn_name), "");
sprintf(rtn_name, "%s%s", local_name, DDBE_SUFFIX_LOCAL_SIZE);
DDBE_name_vec_entry(&vip->rtn_p, NAMETABLE_add_id(rtn_name), "");
sprintf(rtn_name, "%s%s", local_name, DDBE_SUFFIX_FROM_NETCS);
DDBE_name_vec_entry(&vip->rtn_p, NAMETABLE_add_id(rtn_name), "");
sprintf(comment, "network type %s definition", type_name);
DDBE_comment_vec_entry(&vip->defn_p, comment);
sprintf(comment, "%s offset vector index", local_name);
DDBE_indirect_vec_entry(&vip->defn_p,
&ichar_p->be_info.dd_type->offset_vec_p, comment);
ichar_p->be_info.dd_type->type_vec_p = vip->defn_p;
sprintf(comment, "%s routine vector index", type_name);
DDBE_indirect_vec_entry(&vip->defn_p,
&ichar_p->be_info.dd_type->rtn_vec_p, comment);
}
static void DDBE_op_interface
(
IR_tup_n_t *tup_p,
DDBE_vectors_t *vip
)
{
AST_interface_n_t *int_p;
AST_type_n_t *type_p;
DDBE_type_i_t *type_i_p;
char const *type_name;
int i;
char comment[DDBE_MAX_COMMENT];
int_p = tup_p->arg[IR_ARG_INTFC].intfc;
type_p = tup_p->arg[IR_ARG_TYPE].type;
NAMETABLE_id_to_string(type_p->name, &type_name);
if (type_p->be_info.dd_type == NULL)
DDBE_type_info(type_p, tup_p->flags);
type_i_p = type_p->be_info.dd_type;
if (!type_i_p->defn_done)
{
DDBE_push_indirection_scope(vip);
sprintf(comment, "interface %s type definition", type_name);
DDBE_comment_vec_entry(&vip->defn_p, comment);
type_i_p->type_vec_p = vip->defn_p;
DDBE_long_vec_entry(&vip->defn_p, DDBE_vec_long_k,
int_p->uuid.time_low, NULL);
DDBE_short_vec_entry(&vip->defn_p, DDBE_vec_short_k,
int_p->uuid.time_mid, NULL);
DDBE_short_vec_entry(&vip->defn_p, DDBE_vec_short_k,
int_p->uuid.time_hi_and_version, NULL);
DDBE_byte_vec_entry(&vip->defn_p, DDBE_vec_byte_k,
int_p->uuid.clock_seq_hi_and_reserved, NULL);
DDBE_byte_vec_entry(&vip->defn_p, DDBE_vec_byte_k,
int_p->uuid.clock_seq_low, NULL);
for (i = 0; i < 6; i++)
{
DDBE_byte_vec_entry(&vip->defn_p, DDBE_vec_byte_k,
int_p->uuid.node[i], NULL);
}
DDBE_name_vec_entry(&vip->rtn_p,
NAMETABLE_add_id("rpc_ss_ndr_orpc_oref_to_wire_rep"), "");
type_i_p->rtn_vec_p = vip->rtn_p;
DDBE_name_vec_entry(&vip->rtn_p,
NAMETABLE_add_id("rpc_ss_ndr_orpc_wire_rep_to_oref"), "");
sprintf(comment, "interface %s routines", type_name);
DDBE_reference_vec_entry(&vip->defn_p, type_i_p->rtn_vec_p, comment);
DDBE_pop_indirection_scope(vip);
type_i_p->defn_done = TRUE;
}
if (IR_cur_scope(vip->ir_ctx_p) == IR_SCP_STRUCT)
{
AST_field_n_t *field_p;
char const *field_name;
field_p = tup_p->arg[IR_ARG_FIELD].field;
NAMETABLE_id_to_string(field_p->name, &field_name);
sprintf(comment, "field %s offset", field_name);
DDBE_expr_vec_entry(&vip->offset_p, DDBE_vec_expr_k,
IR_field_expr(vip->ir_ctx_p, field_p), comment);
}
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_interface);
DDBE_properties_byte(type_p, vip->p_cur_p);
sprintf(comment, "interface %s index", type_name);
DDBE_reference_vec_entry(vip->p_cur_p, type_i_p->type_vec_p, comment);
}
static void DDBE_op_range
(
IR_tup_n_t *tup_p,
DDBE_vectors_t *vip
)
{
char comment[DDBE_MAX_COMMENT];
sprintf(comment, "range(%lu,%lu)",
tup_p->arg[IR_ARG_INT].int_val,
tup_p->arg[IR_ARG_BOUND_XTRA].int_val);
DDBE_comment_vec_entry(&vip->defn_p, comment);
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_range);
DDBE_long_vec_entry(vip->p_cur_p, DDBE_vec_long_k,
tup_p->arg[IR_ARG_INT].int_val, "[range] low-val");
DDBE_long_vec_entry(vip->p_cur_p, DDBE_vec_long_k,
tup_p->arg[IR_ARG_BOUND_XTRA].int_val, "[range] high-val");
}
static DDBE_vec_rep_t *DDBE_gen_param_reps
(
AST_interface_n_t *int_p ATTRIBUTE_UNUSED,
AST_operation_n_t *oper_p,
AST_parameter_n_t *param_p,
DDBE_vectors_t *vip,
boolean *cmd_opt ATTRIBUTE_UNUSED,
void **cmd_val ATTRIBUTE_UNUSED
)
{
AST_type_n_t *type_p;
char const *name;
char const *oper_name;
IR_tup_n_t *tup_p;
DDBE_vec_rep_t *first_entry;
char comment[DDBE_MAX_COMMENT];
tup_p = param_p->data_tups;
if (IR_NO_IREP(tup_p))
return NULL;
if (AST_ADD_COMM_STATUS_SET(param_p) || AST_ADD_FAULT_STATUS_SET(param_p))
return NULL;
if (vip->param_num == 1 && param_p->type->kind == AST_handle_k
&& param_p->type->rep_as_type != NULL)
return NULL;
DDBE_VEC_INIT(vip);
NAMETABLE_id_to_string(param_p->name, &name);
NAMETABLE_id_to_string(oper_p->name, &oper_name);
sprintf(comment, "Operation %s parameter %s", oper_name, name);
DDBE_comment_vec_entry(&vip->type_p, comment);
sprintf(comment, "index of parameter %s", name);
DDBE_long_vec_entry(&vip->type_p, DDBE_vec_long_k, vip->param_num, comment);
first_entry = vip->type_p;
while (TRUE)
{
vip->update_tup = TRUE;
if (tup_p == NULL && vip->tup_sp != NULL)
DDBE_type_indirect_end(&tup_p, vip);
if (tup_p == NULL)
break;
type_p = tup_p->arg[IR_ARG_TYPE].type;
switch (tup_p->opcode)
{
case IR_op_align_k:
switch (tup_p->arg[IR_ARG_INT].int_val)
{
case 2:
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_ndr_align_2);
break;
case 4:
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_ndr_align_4);
break;
case 8:
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_ndr_align_8);
break;
default:
INTERNAL_ERROR("Invalid alignment value");
}
break;
case IR_op_allocate_k:
break;
case IR_op_array_bounds_k:
DDBE_op_array_bounds(tup_p, vip);
break;
case IR_op_array_end_k:
DDBE_op_array_end(&tup_p, vip);
break;
case IR_op_bound_k:
DDBE_op_bound(tup_p, vip);
break;
case IR_op_call_k:
case IR_op_call_param_k:
break;
case IR_op_case_k:
DDBE_long_vec_entry(&vip->defn_p, (tup_p->flags & IR_BOOLEAN) ?
DDBE_vec_long_bool_k : DDBE_vec_long_k,
tup_p->arg[IR_ARG_INT].int_val, "switch value");
vip->in_default_arm = FALSE;
vip->arm_byte_cnt = 4;
if (tup_p->flags & IR_VOID)
{
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_void);
vip->arm_byte_cnt++;
DDBE_pad_vec_entry(&vip->defn_p,
DDBE_ARM_SIZE - vip->arm_byte_cnt);
}
break;
case IR_op_codeset_shadow_k:
if (IR_cur_scope(vip->ir_ctx_p) == IR_SCP_TOPLEVEL)
{
if ((tup_p->flags & IR_IN_ONLY) && vip->processing_outs)
break;
if ((tup_p->flags & IR_OUT_ONLY) && vip->processing_ins)
break;
}
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_cs_shadow);
if (IR_cur_scope(vip->ir_ctx_p) == IR_SCP_TOPLEVEL)
{
AST_parameter_n_t *pp;
unsigned long num_params = 1;
for (pp = oper_p->parameters; pp != NULL; pp = pp->next)
num_params++;
DDBE_long_vec_entry(vip->p_cur_p, DDBE_vec_long_k,
num_params, "number of parameters");
}
else
{
DDBE_long_vec_entry(vip->p_cur_p, DDBE_vec_long_k,
tup_p->arg[IR_ARG_INT].int_val, "number of fields");
}
break;
case IR_op_conformant_array_k:
if (!vip->in_flatarr)
{
if (tup_p->flags & IR_CS_CHAR)
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_cs_array);
if (vip->allocate
&& IR_cur_scope(vip->ir_ctx_p) == IR_SCP_TOPLEVEL)
DDBE_tag_vec_entry(&vip->type_p, DDBE_dt_allocate);
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_conf_array);
}
DDBE_op_array(tup_p, vip);
vip->conformant = TRUE;
break;
case IR_op_conformant_info_k:
DDBE_op_conformant_info(&tup_p, vip);
break;
case IR_op_context_handle_k:
if (param_p != tup_p->arg[IR_ARG_PARAM].param)
INTERNAL_ERROR("Unsupported context handle instance");
if (!AST_OUT_SET(param_p))
DDBE_tag_vec_entry(&vip->type_p, DDBE_dt_in_context);
else if (!AST_IN_SET(param_p))
DDBE_tag_vec_entry(&vip->type_p, DDBE_dt_out_context);
else
DDBE_tag_vec_entry(&vip->type_p, DDBE_dt_in_out_context);
break;
case IR_op_cs_char_k:
DDBE_op_cs_char(&tup_p, vip);
break;
case IR_op_cs_char_end_k:
IR_process_tup(vip->ir_ctx_p, tup_p);
break;
case IR_op_declare_k:
break;
case IR_op_default_k:
if (tup_p->flags & IR_VOID)
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_void);
else if (type_p == NULL)
DDBE_tag_vec_entry(&vip->defn_p, DDBE_dt_does_not_exist);
else
vip->in_default_arm = TRUE;
break;
case IR_op_disc_union_begin_k:
DDBE_op_disc_union_begin(&tup_p, vip);
break;
case IR_op_disc_union_end_k:
DDBE_op_disc_union_end(&tup_p, vip);
break;
case IR_op_fixed_array_k:
if (!vip->in_flatarr)
{
if (tup_p->flags & IR_CS_CHAR)
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_cs_array);
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_fixed_array);
}
DDBE_op_array(tup_p, vip);
vip->conformant = FALSE;
break;
case IR_op_flat_array_k:
vip->in_flatarr = TRUE;
break;
case IR_op_free_k:
break;
case IR_op_full_array_end_k:
vip->in_flatarr = FALSE;
break;
case IR_op_full_array_k:
break;
case IR_op_full_ptr_k:
DDBE_op_pointer(&tup_p, vip, DDBE_dt_full_ptr);
break;
case IR_op_interface_k:
DDBE_op_interface(tup_p, vip);
break;
case IR_op_limit_k:
DDBE_op_limit(tup_p, vip);
break;
case IR_op_marshall_k:
DDBE_op_marshall(tup_p, vip);
break;
case IR_op_noop_k:
break;
case IR_op_open_array_k:
if (tup_p->flags & IR_STRING)
vip->in_flatarr = FALSE;
if (!vip->in_flatarr)
{
if (tup_p->flags & IR_CS_CHAR)
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_cs_array);
if (vip->allocate
&& IR_cur_scope(vip->ir_ctx_p) == IR_SCP_TOPLEVEL)
DDBE_tag_vec_entry(&vip->type_p, DDBE_dt_allocate);
if (tup_p->flags & IR_STRING)
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_string);
if (AST_SMALL_SET(type_p)
|| (tup_p->arg[IR_ARG_INST].inst != NULL
&& AST_SMALL_SET(tup_p->arg[IR_ARG_INST].inst)))
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_v1_array);
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_open_array);
}
DDBE_op_array(tup_p, vip);
vip->conformant = TRUE;
break;
case IR_op_passed_by_ref_k:
DDBE_tag_vec_entry(&vip->type_p, DDBE_dt_passed_by_ref);
if (vip->allocate_ref)
DDBE_tag_vec_entry(&vip->type_p, DDBE_dt_allocate_ref);
break;
case IR_op_pipe_begin_k:
DDBE_op_pipe_begin(&tup_p, vip);
break;
case IR_op_pipe_end_k:
DDBE_op_pipe_end(tup_p, vip);
break;
case IR_op_pointee_end_k:
if (IR_cur_scope(vip->ir_ctx_p) != IR_SCP_TOPLEVEL)
DDBE_op_pointee_end(tup_p, vip);
break;
case IR_op_ref_ptr_k:
DDBE_op_pointer(&tup_p, vip, DDBE_dt_ref_ptr);
break;
case IR_op_release_shadow_k:
if (IR_cur_scope(vip->ir_ctx_p) == IR_SCP_TOPLEVEL)
{
if ((tup_p->flags & IR_IN_ONLY) && vip->processing_outs)
break;
if ((tup_p->flags & IR_OUT_ONLY) && vip->processing_ins)
break;
}
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_cs_rlse_shadow);
break;
case IR_op_represent_as_k:
DDBE_op_represent_as(&tup_p, vip);
break;
case IR_op_represent_end_k:
IR_process_tup(vip->ir_ctx_p, tup_p);
break;
case IR_op_struct_begin_k:
DDBE_op_struct_begin(&tup_p, vip);
break;
case IR_op_struct_end_k:
DDBE_op_struct_end(&tup_p, vip);
break;
case IR_op_switch_enc_k:
INTERNAL_ERROR("switch_enc_k tuple outside of union processing");
break;
case IR_op_switch_n_e_k:
vip->switch_name = tup_p->arg[IR_ARG_INST].inst->name;
vip->switch_type = tup_p->arg[IR_ARG_INST].inst->type;
vip->switch_index = tup_p->arg[IR_ARG_PFNUM].int_val;
break;
case IR_op_transmit_as_k:
DDBE_op_transmit_as(&tup_p, vip);
break;
case IR_op_transmit_end_k:
IR_process_tup(vip->ir_ctx_p, tup_p);
break;
case IR_op_type_indirect_k:
DDBE_op_type_indirect(&tup_p, vip);
break;
case IR_op_unique_ptr_k:
DDBE_op_pointer(&tup_p, vip, DDBE_dt_unique_ptr);
break;
case IR_op_varying_array_k:
if (tup_p->flags & IR_STRING)
vip->in_flatarr = FALSE;
if (!vip->in_flatarr)
{
if (tup_p->flags & IR_CS_CHAR)
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_cs_array);
if ((tup_p->flags & IR_STRING) != 0)
{
if (AST_STRING0_SET(type_p)
|| (tup_p->arg[IR_ARG_INST].inst != NULL
&& AST_STRING0_SET(tup_p->arg[IR_ARG_INST].inst)))
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_v1_string);
else
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_string);
}
else
{
if (AST_SMALL_SET(type_p)
|| (tup_p->arg[IR_ARG_INST].inst != NULL
&& AST_SMALL_SET(tup_p->arg[IR_ARG_INST].inst)))
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_v1_array);
}
DDBE_tag_vec_entry(vip->p_cur_p, DDBE_dt_varying_array);
}
DDBE_op_array(tup_p, vip);
vip->conformant = FALSE;
break;
case IR_op_range_k:
DDBE_op_range(tup_p, vip);
break;
default:
INTERNAL_ERROR("Unknown intermediate rep tuple skipped");
break;
}
if (vip->update_tup)
{
tup_p = tup_p->next;
}
}
DDBE_tag_vec_entry(&vip->type_p, DDBE_dt_eol);
param_p->be_info.dd_param->type_vec_p = first_entry;
return first_entry;
}
static boolean DDBE_oper_in_out_opt
(
AST_operation_n_t *oper_p
)
{
AST_parameter_n_t *param_p;
if (AST_HAS_IN_PIPES_SET(oper_p) || AST_HAS_OUT_PIPES_SET(oper_p))
return FALSE;
for (param_p = oper_p->parameters; param_p != NULL; param_p = param_p->next)
{
if (param_p->ir_info->allocate_ref || DDBE_ALLOCATE(param_p))
return FALSE;
if (AST_IN_SET(param_p) && !AST_OUT_SET(param_p)
&& DDBE_XMIT_REP(param_p))
return FALSE;
}
for (param_p = oper_p->parameters; param_p != NULL; param_p = param_p->next)
{
if (AST_IN_SET(param_p) && AST_OUT_SET(param_p))
{
if (FE_TEST(param_p->fe_info->flags, FE_FIRST_IN_NF_CS_ARR))
{
if (!FE_TEST(param_p->fe_info->flags, FE_FIRST_OUT_NF_CS_ARR))
return FALSE;
}
else
{
if (FE_TEST(param_p->fe_info->flags, FE_FIRST_OUT_NF_CS_ARR))
return FALSE;
}
if (FE_TEST(param_p->fe_info->flags, FE_LAST_IN_NF_CS_ARR))
{
if (!FE_TEST(param_p->fe_info->flags, FE_LAST_OUT_NF_CS_ARR))
return FALSE;
}
else
{
if (FE_TEST(param_p->fe_info->flags, FE_LAST_OUT_NF_CS_ARR))
return FALSE;
}
}
}
param_p = oper_p->parameters;
while (param_p != NULL
&& ( (AST_IN_SET(param_p) && !AST_OUT_SET(param_p))
|| IR_NO_IREP(param_p->data_tups) ))
param_p = param_p->next;
while (param_p != NULL
&& ( (AST_IN_SET(param_p) && AST_OUT_SET(param_p))
|| IR_NO_IREP(param_p->data_tups) ))
param_p = param_p->next;
if (param_p == NULL)
return TRUE;
if (AST_OUT_SET(param_p))
{
while (param_p != NULL
&& ( (!AST_IN_SET(param_p) && AST_OUT_SET(param_p))
|| IR_NO_IREP(param_p->data_tups) ))
param_p = param_p->next;
}
else
{
if (oper_p->result == NULL || IR_NO_IREP(oper_p->result->data_tups))
{
while (param_p != NULL
&& ( (AST_IN_SET(param_p) && !AST_OUT_SET(param_p))
|| IR_NO_IREP(param_p->data_tups) ))
param_p = param_p->next;
}
}
if (param_p == NULL)
return TRUE;
param_p = oper_p->parameters;
while (param_p != NULL
&& ( (!AST_IN_SET(param_p) && AST_OUT_SET(param_p))
|| IR_NO_IREP(param_p->data_tups) ))
param_p = param_p->next;
while (param_p != NULL
&& ( (AST_IN_SET(param_p) && AST_OUT_SET(param_p))
|| IR_NO_IREP(param_p->data_tups) ))
param_p = param_p->next;
if (param_p == NULL)
return TRUE;
if (AST_IN_SET(param_p))
{
if (oper_p->result != NULL && !IR_NO_IREP(oper_p->result->data_tups))
return FALSE;
while (param_p != NULL
&& ( (AST_IN_SET(param_p) && !AST_OUT_SET(param_p))
|| IR_NO_IREP(param_p->data_tups) ))
param_p = param_p->next;
}
else
{
while (param_p != NULL
&& ( (!AST_IN_SET(param_p) && AST_OUT_SET(param_p))
|| IR_NO_IREP(param_p->data_tups) ))
param_p = param_p->next;
}
if (param_p == NULL)
return TRUE;
return FALSE;
}
static void DDBE_gen_vector_reps
(
AST_interface_n_t *int_p,
DDBE_vectors_t *vip,
boolean *cmd_opt,
void **cmd_val
)
{
DDBE_vec_rep_t *defn_h;
DDBE_vec_rep_t *type_h;
DDBE_vec_rep_t *type_l;
DDBE_vec_rep_t *offset_h;
DDBE_vec_rep_t *rtn_h;
DDBE_vec_rep_t *info_h;
DDBE_vec_rep_t *param_h;
AST_export_n_t *export_p;
AST_operation_n_t *oper_p;
AST_parameter_n_t *param_p;
unsigned long start_type_vec_index;
unsigned long addenda_offset;
defn_h = vip->defn_p;
type_h = vip->type_p;
offset_h = vip->offset_p;
rtn_h = vip->rtn_p;
info_h = vip->type_info_p;
for (export_p = int_p->exports; export_p != NULL; export_p = export_p->next)
{
if (export_p->kind == AST_operation_k)
{
oper_p = export_p->thing_p.exported_operation;
DDBE_operation_info(oper_p);
if (DDBE_oper_in_out_opt(oper_p))
{
vip->processing_ins = FALSE;
vip->processing_outs = FALSE;
vip->param_num = 0;
for (param_p = oper_p->parameters;
param_p != NULL;
param_p = param_p->next)
{
vip->param_num++;
vip->ir_ctx_p = IR_init_scope(
(struct AST_parameter_n_t *)param_p);
param_h = DDBE_gen_param_reps(int_p, oper_p, param_p, vip,
cmd_opt, cmd_val);
if (param_h != NULL)
{
if (AST_IN_SET(param_p))
{
oper_p->be_info.dd_oper->num_ins++;
if (oper_p->be_info.dd_oper->ins_type_vec_p == NULL)
oper_p->be_info.dd_oper->ins_type_vec_p = param_h;
}
if (AST_OUT_SET(param_p))
{
oper_p->be_info.dd_oper->num_outs++;
if (oper_p->be_info.dd_oper->outs_type_vec_p == NULL)
oper_p->be_info.dd_oper->outs_type_vec_p = param_h;
}
}
IR_finish_scope(vip->ir_ctx_p);
}
oper_p->be_info.dd_oper->num_srv_ins =
oper_p->be_info.dd_oper->num_ins;
}
else
{
vip->param_num = 0;
vip->processing_ins = TRUE;
vip->processing_outs = FALSE;
for (param_p = oper_p->parameters;
param_p != NULL;
param_p = param_p->next)
{
vip->param_num++;
if (!AST_IN_SET(param_p) || DDBE_PIPE(param_p))
continue;
vip->ir_ctx_p = IR_init_scope(
(struct AST_parameter_n_t *)param_p);
param_h = DDBE_gen_param_reps(int_p, oper_p, param_p, vip,
cmd_opt, cmd_val);
if (param_h != NULL)
{
oper_p->be_info.dd_oper->num_ins++;
if (oper_p->be_info.dd_oper->ins_type_vec_p == NULL)
oper_p->be_info.dd_oper->ins_type_vec_p = param_h;
}
IR_finish_scope(vip->ir_ctx_p);
}
oper_p->be_info.dd_oper->num_srv_ins =
oper_p->be_info.dd_oper->num_ins;
vip->param_num = 0;
for (param_p = oper_p->parameters;
param_p != NULL;
param_p = param_p->next)
{
vip->param_num++;
vip->allocate = DDBE_ALLOCATE(param_p);
vip->allocate_ref = (!vip->allocate
&& param_p->ir_info->allocate_ref);
if (!vip->allocate && !vip->allocate_ref)
continue;
vip->ir_ctx_p = IR_init_scope(
(struct AST_parameter_n_t *)param_p);
param_h = DDBE_gen_param_reps(int_p, oper_p, param_p, vip,
cmd_opt, cmd_val);
if (oper_p->be_info.dd_oper->ins_type_vec_p == NULL)
oper_p->be_info.dd_oper->ins_type_vec_p = param_h;
oper_p->be_info.dd_oper->num_srv_ins++;
if (AST_HAS_IN_PIPES_SET(oper_p))
oper_p->be_info.dd_oper->num_ins++;
IR_finish_scope(vip->ir_ctx_p);
vip->allocate = FALSE;
vip->allocate_ref = FALSE;
}
if (AST_HAS_IN_PIPES_SET(oper_p))
{
vip->param_num = 0;
for (param_p = oper_p->parameters;
param_p != NULL;
param_p = param_p->next)
{
vip->param_num++;
if (!AST_IN_SET(param_p) || !DDBE_PIPE(param_p))
continue;
vip->ir_ctx_p = IR_init_scope(
(struct AST_parameter_n_t *)param_p);
param_h = DDBE_gen_param_reps(int_p, oper_p, param_p, vip,
cmd_opt, cmd_val);
oper_p->be_info.dd_oper->num_ins++;
oper_p->be_info.dd_oper->num_srv_ins++;
if (oper_p->be_info.dd_oper->ins_type_vec_p == NULL)
oper_p->be_info.dd_oper->ins_type_vec_p = param_h;
IR_finish_scope(vip->ir_ctx_p);
}
}
vip->processing_ins = FALSE;
vip->processing_outs = TRUE;
if (AST_HAS_OUT_PIPES_SET(oper_p))
{
vip->param_num = 0;
for (param_p = oper_p->parameters;
param_p != NULL;
param_p = param_p->next)
{
vip->param_num++;
if (!AST_OUT_SET(param_p) || !DDBE_PIPE(param_p))
continue;
vip->ir_ctx_p = IR_init_scope(
(struct AST_parameter_n_t *)param_p);
param_h = DDBE_gen_param_reps(int_p, oper_p, param_p, vip,
cmd_opt, cmd_val);
oper_p->be_info.dd_oper->num_outs++;
if (oper_p->be_info.dd_oper->outs_type_vec_p == NULL)
oper_p->be_info.dd_oper->outs_type_vec_p = param_h;
IR_finish_scope(vip->ir_ctx_p);
}
}
vip->param_num = 0;
for (param_p = oper_p->parameters;
param_p != NULL;
param_p = param_p->next)
{
vip->param_num++;
if (!AST_OUT_SET(param_p) || DDBE_PIPE(param_p))
continue;
vip->ir_ctx_p = IR_init_scope(
(struct AST_parameter_n_t *)param_p);
param_h = DDBE_gen_param_reps(int_p, oper_p, param_p, vip,
cmd_opt, cmd_val);
if (param_h != NULL)
{
oper_p->be_info.dd_oper->num_outs++;
if (oper_p->be_info.dd_oper->outs_type_vec_p == NULL)
oper_p->be_info.dd_oper->outs_type_vec_p = param_h;
}
IR_finish_scope(vip->ir_ctx_p);
}
vip->param_num = 0;
for (param_p = oper_p->parameters;
param_p != NULL;
param_p = param_p->next)
{
vip->param_num++;
vip->free_rep =
(AST_IN_SET(param_p) && !AST_OUT_SET(param_p)
&& DDBE_XMIT_REP(param_p));
if (!vip->free_rep)
continue;
vip->ir_ctx_p = IR_init_scope(
(struct AST_parameter_n_t *)param_p);
param_h = DDBE_gen_param_reps(int_p, oper_p, param_p, vip,
cmd_opt, cmd_val);
if (param_h != NULL)
{
oper_p->be_info.dd_oper->num_outs++;
if (oper_p->be_info.dd_oper->outs_type_vec_p == NULL)
oper_p->be_info.dd_oper->outs_type_vec_p = param_h;
}
IR_finish_scope(vip->ir_ctx_p);
vip->free_rep = FALSE;
}
}
oper_p->be_info.dd_oper->num_params = vip->param_num + 1;
vip->param_num = 0;
vip->ir_ctx_p = IR_init_scope(
(struct AST_parameter_n_t *)oper_p->result);
param_h = DDBE_gen_param_reps(int_p, oper_p, oper_p->result,
vip, cmd_opt, cmd_val);
if (param_h != NULL)
{
oper_p->be_info.dd_oper->num_outs++;
if (oper_p->be_info.dd_oper->outs_type_vec_p == NULL)
oper_p->be_info.dd_oper->outs_type_vec_p = param_h;
}
if (AST_REFLECT_DELETIONS_SET(oper_p))
{
oper_p->be_info.dd_oper->num_outs++;
DDBE_long_vec_entry(&vip->type_p, DDBE_vec_long_k, 0,
"dummy parameter index");
if (oper_p->be_info.dd_oper->outs_type_vec_p == NULL)
oper_p->be_info.dd_oper->outs_type_vec_p = vip->type_p;
DDBE_tag_vec_entry(&vip->type_p, DDBE_dt_deleted_nodes);
DDBE_tag_vec_entry(&vip->type_p, DDBE_dt_eol);
}
IR_finish_scope(vip->ir_ctx_p);
}
}
vip->type_p->next = defn_h;
vip->defn_p = NULL;
vip->type_p = type_h;
vip->offset_p = offset_h;
vip->rtn_p = rtn_h;
vip->type_info_p = info_h;
start_type_vec_index = DDBE_PARAM_START +
DDBE_OPER_ENTRIES * 4 * int_p->op_count;
vip->type_vec_size =
DDBE_compute_vec_offsets(vip->type_p, 4, 4,
start_type_vec_index, &type_l);
vip->offset_vec_size =
DDBE_compute_vec_offsets(vip->offset_p, sizeof(int), 1, 1, NULL) + 1;
vip->rtn_vec_size =
DDBE_compute_vec_offsets(vip->rtn_p, sizeof(void(*)(void)), 1, 1, NULL) + 1;
addenda_offset = vip->type_vec_size;
addenda_offset = (addenda_offset + DDBE_ADDENDA_ALIGN-1)
& ~(DDBE_ADDENDA_ALIGN-1);
if (addenda_offset != vip->type_vec_size)
{
DDBE_pad_vec_entry(&type_l, (byte)addenda_offset-vip->type_vec_size);
type_l->index = vip->type_vec_size;
vip->type_vec_size = addenda_offset;
}
DDBE_patch_vec_refs(vip->type_p);
DDBE_patch_oper_info(int_p);
}
boolean DDBE_main
(
boolean *cmd_opt,
void **cmd_val,
AST_interface_n_t *int_p,
DDBE_vectors_t **p_vip
)
{
DDBE_vectors_t *vip;
long endian = 1;
if (*(unsigned char *)&endian != 1) DDBE_little_endian = FALSE;
DDBE_init_vectors(int_p, p_vip);
vip = *p_vip;
DDBE_init_tags();
DDBE_gen_vector_reps(int_p, vip, cmd_opt, cmd_val);
#ifdef DUMPERS
DDBE_stub_hex = (getenv("IDL_STUB_HEX") != NULL);
if (cmd_opt[opt_dump_recs])
{
printf("\nDump of DDBE instance definitions:\n");
printf( "----------------------------------\n");
DDBE_spell_offset_instances(stdout, vip, cmd_opt, cmd_val);
printf("\nDump of DDBE statically initialized offset vector:\n");
printf( "--------------------------------------------------\n");
DDBE_spell_offset_vec_use_inst(stdout, vip, cmd_opt, cmd_val);
printf("\nDump of DDBE uninitialized offset vector and init rtn:\n");
printf( "------------------------------------------------------\n");
DDBE_init_offset_vec(stdout, vip, cmd_opt, cmd_val);
printf("\nDump of DDBE routine vector data:\n");
printf( "---------------------------------\n");
DDBE_spell_rtn_vec(stdout, vip, cmd_opt, cmd_val, TRUE);
printf("\nDump of DDBE type/definition vector data:\n");
printf( "-----------------------------------------\n");
DDBE_spell_type_vec(stdout, vip, cmd_opt, cmd_val);
}
if (cmd_opt[opt_dump_mnode])
DDBE_test_marsh_spellers(int_p, cmd_opt, cmd_val);
#endif
return TRUE;
}
#ifdef DUMPERS
static void DDBE_test_marsh_spellers
(
AST_interface_n_t *int_p,
boolean *cmd_opt,
void **cmd_val
)
{
AST_export_n_t *export_p;
AST_operation_n_t *oper_p;
char const *oper_name;
printf("\nDump of generated marshalling code:\n");
printf( "-----------------------------------\n");
for (export_p = int_p->exports; export_p != NULL; export_p = export_p->next)
{
if (export_p->kind == AST_operation_k)
{
oper_p = export_p->thing_p.exported_operation;
NAMETABLE_id_to_string(oper_p->name, &oper_name);
printf("\nOperation %s:\n\n", oper_name);
DDBE_spell_param_vec_def(stdout, oper_p, BE_client_side,
cmd_opt, cmd_val);
printf("\n");
DDBE_spell_param_vec_init(stdout, oper_p, BE_client_side,
cmd_opt, cmd_val);
printf("\n");
DDBE_spell_param_vec_init(stdout, oper_p, BE_server_side,
cmd_opt, cmd_val);
printf("\n");
DDBE_spell_marsh_or_unmar(stdout, oper_p, "test_marsh_interp",
"state_ptr", BE_client_side, BE_marshalling_k);
printf("\n");
DDBE_spell_marsh_or_unmar(stdout, oper_p, "test_unmar_interp",
"state_ptr", BE_client_side, BE_unmarshalling_k);
}
}
}
#endif