#include <nidl.h>
#include <propagat.h>
#include <ast.h>
#include <astp.h>
#include <checker.h>
#include <command.h>
#include <errors.h>
#include <nidlmsg.h>
#include <ddbe.h>
static AST_type_p_n_t *PROP_up_types_list;
static boolean *cmd_opt;
static void **cmd_val;
#define type_can_contain_context(type_p) \
( (type_p)->kind == AST_array_k \
|| (type_p)->kind == AST_pointer_k )
#define MAX(a,b) ((a) > (b))?(a):(b)
#define COPY_IF_LARGER(a,b) {if ((b) > (a)) (a) = (b);}
#define type_can_contain_pointer(type_p) \
( (type_p)->kind == AST_array_k \
|| (type_p)->kind == AST_structure_k \
|| ((type_p)->kind == AST_pointer_k \
&& (type_p)->type_structure.pointer->pointee_type->kind != AST_void_k \
&& (type_p)->type_structure.pointer->pointee_type->kind != AST_interface_k \
) \
|| (type_p)->kind == AST_disc_union_k)
typedef struct visit_t
{
struct visit_t *next;
AST_type_n_t *type;
} visit_t;
static visit_t *visited_list;
typedef struct
{
AST_interface_n_t *int_p;
ASTP_node_t *instance_p;
AST_type_n_t *parent_type_p;
AST_parameter_n_t *param_p;
boolean toplevel_ref_param;
boolean toplevel_param;
boolean typedef_dcl;
boolean has_rep_as;
boolean ct_cs_char;
boolean has_xmit_as;
boolean in_xmitted;
boolean has_v1_attr;
boolean has_v2_attr;
boolean in_aux;
boolean under_ptr;
boolean has_enum;
boolean has_union;
boolean has_vary_array;
boolean has_char;
boolean has_float;
boolean has_int;
boolean has_error_status;
boolean has_v1_struct;
boolean has_interface;
} prop_ctx_t;
static void PROP_type_info(
AST_type_n_t *type_p,
prop_ctx_t *ctx
);
static void type_visit
(
AST_type_n_t *type_p
)
{
visit_t *visit_p;
visit_p = NEW (visit_t);
visit_p->next = visited_list;
visit_p->type = type_p;
visited_list = visit_p;
}
static void type_unvisit
(
AST_type_n_t *type_p
)
{
visit_t *visit_p, *prev_p;
prev_p = NULL;
for (visit_p = visited_list ; visit_p != NULL ; visit_p = visit_p->next)
{
if (visit_p->type == type_p)
{
if (prev_p == NULL)
visited_list = visit_p->next;
else
prev_p->next = visit_p->next;
FREE(visit_p);
return;
}
prev_p = visit_p;
}
}
static boolean type_visited
(
AST_type_n_t *type_p
)
{
visit_t *visit_p;
for (visit_p = visited_list ; visit_p != NULL ; visit_p = visit_p->next)
if (visit_p->type == type_p)
return TRUE;
return FALSE;
}
static void type_visit_free
(void)
{
visit_t *visit_p;
visit_t *t_visit_p;
visit_p = visited_list;
while (visit_p != NULL)
{
t_visit_p = visit_p;
visit_p = visit_p->next;
FREE(t_visit_p);
}
}
static void PROP_set_nf_cs_char_param
(
AST_parameter_n_t *cs_param_p
)
{
AST_operation_n_t *op_p;
AST_parameter_n_t *param_p, *last_param_p;
boolean done_first, got_out_allocate;
op_p = cs_param_p->uplink;
if (AST_IN_SET(cs_param_p) || DDBE_ALLOCATE(cs_param_p))
{
done_first = FALSE;
got_out_allocate = FALSE;
last_param_p = NULL;
for (param_p = op_p->parameters; param_p; param_p = param_p->next)
{
if (param_p == op_p->parameters
&& (param_p->type->kind == AST_handle_k
|| (param_p->type->kind == AST_pointer_k
&& param_p->type->type_structure.pointer->pointee_type
->kind == AST_handle_k)))
continue;
if (AST_IN_SET(param_p))
{
if (!done_first)
{
FE_SET(param_p->fe_info->flags, FE_FIRST_IN_NF_CS_ARR);
done_first = TRUE;
}
}
if (DDBE_ALLOCATE(param_p))
{
last_param_p = param_p;
got_out_allocate = TRUE;
}
else if (AST_IN_SET(param_p) && !got_out_allocate)
last_param_p = param_p;
}
if (last_param_p != NULL)
FE_SET(last_param_p->fe_info->flags, FE_LAST_IN_NF_CS_ARR);
}
if (AST_OUT_SET(cs_param_p))
{
done_first = FALSE;
last_param_p = NULL;
for (param_p = op_p->parameters; param_p; param_p = param_p->next)
{
if (AST_ADD_COMM_STATUS_SET(param_p)
|| AST_ADD_FAULT_STATUS_SET(param_p))
continue;
if (AST_OUT_SET(param_p))
{
if (!done_first)
{
FE_SET(param_p->fe_info->flags, FE_FIRST_OUT_NF_CS_ARR);
done_first = TRUE;
}
last_param_p = param_p;
}
}
if (last_param_p != NULL)
FE_SET(last_param_p->fe_info->flags, FE_LAST_OUT_NF_CS_ARR);
}
if (DDBE_ALLOCATE(cs_param_p)
&& cs_param_p->field_attrs != NULL
&& cs_param_p->field_attrs->size_is_vec != NULL
&& cs_param_p->field_attrs->size_is_vec[0].valid
&& cs_param_p->field_attrs->size_is_vec[0].constant == false)
{
(cs_param_p->field_attrs->size_is_vec[0].ref.p_ref->
fe_info->ref_count_a)++;
}
}
static void PROP_set_used_as_reg_fld_attr
(
AST_instance_n_t *inst_p
)
{
AST_field_attr_n_t *fattr_p;
unsigned short max_dim;
unsigned short dim;
fattr_p = inst_p->field_attrs;
if (inst_p->type->kind == AST_array_k)
max_dim = inst_p->type->type_structure.array->index_count;
else
max_dim = 1;
for (dim = 0; dim < max_dim; dim++)
{
if (fattr_p->min_is_vec != NULL && fattr_p->min_is_vec[dim].valid &&
fattr_p->min_is_vec[dim].constant == false)
FE_SET(fattr_p->min_is_vec[dim].ref.p_ref->fe_info->flags,
FE_USED_AS_REG_FLD_ATTR);
if (fattr_p->max_is_vec != NULL && fattr_p->max_is_vec[dim].valid &&
fattr_p->max_is_vec[dim].constant == false)
FE_SET(fattr_p->max_is_vec[dim].ref.p_ref->fe_info->flags,
FE_USED_AS_REG_FLD_ATTR);
if (fattr_p->size_is_vec != NULL && fattr_p->size_is_vec[dim].valid &&
fattr_p->size_is_vec[dim].constant == false)
FE_SET(fattr_p->size_is_vec[dim].ref.p_ref->fe_info->flags,
FE_USED_AS_REG_FLD_ATTR);
if (fattr_p->first_is_vec != NULL && fattr_p->first_is_vec[dim].valid &&
fattr_p->first_is_vec[dim].constant == false)
FE_SET(fattr_p->first_is_vec[dim].ref.p_ref->fe_info->flags,
FE_USED_AS_REG_FLD_ATTR);
if (fattr_p->last_is_vec != NULL && fattr_p->last_is_vec[dim].valid &&
fattr_p->last_is_vec[dim].constant == false)
FE_SET(fattr_p->last_is_vec[dim].ref.p_ref->fe_info->flags,
FE_USED_AS_REG_FLD_ATTR);
if (fattr_p->length_is_vec != NULL && fattr_p->length_is_vec[dim].valid &&
fattr_p->length_is_vec[dim].constant == false)
FE_SET(fattr_p->length_is_vec[dim].ref.p_ref->fe_info->flags,
FE_USED_AS_REG_FLD_ATTR);
}
}
void PROP_set_type_attr
(
AST_type_n_t *type_node_ptr,
AST_flags_t type_attr
)
{
type_node_ptr->flags |= type_attr;
if (type_node_ptr->fe_info->tag_ptr != NULL)
type_node_ptr->fe_info->tag_ptr->flags |= type_attr;
if (type_node_ptr->fe_info->original != NULL)
type_node_ptr->fe_info->original->flags |= type_attr;
}
static void PROP_set_type_usage_attr
(
AST_type_n_t *type_node_ptr,
AST_flags_t type_attr
)
{
if ((type_node_ptr->kind == AST_pointer_k) &&
(type_node_ptr->type_structure.pointer->pointee_type->array_rep_type != NULL))
type_node_ptr->type_structure.pointer->pointee_type->array_rep_type->flags |= type_attr;
PROP_set_type_attr(type_node_ptr, type_attr);
}
static void PROP_process_pa_type
(
AST_type_n_t *type_node_ptr,
AST_type_p_n_t **pa_types,
prop_ctx_t *ctx
)
{
AST_type_p_n_t *tp_node;
if (ctx->typedef_dcl) return;
if (AST_SELF_POINTER_SET(type_node_ptr) &&
(type_node_ptr->name != NAMETABLE_NIL_ID))
return;
if (AST_CONTEXT_RD_SET(type_node_ptr))
return;
if (!ctx->in_aux ||
!ctx->under_ptr ||
(AST_SELF_POINTER_SET(type_node_ptr) &&
(type_node_ptr->name == NAMETABLE_NIL_ID)))
{
if (AST_IN_SET(ctx->param_p)) PROP_set_type_usage_attr(type_node_ptr,AST_IN_PA_STUB);
if (AST_OUT_SET(ctx->param_p)) PROP_set_type_usage_attr(type_node_ptr,AST_OUT_PA_STUB);
}
if (FE_TEST(type_node_ptr->fe_info->flags,FE_POINTED_AT)) return;
if (AST_DEF_AS_TAG_SET(type_node_ptr) && type_node_ptr->fe_info->original)
{
FE_SET(type_node_ptr->fe_info->flags,FE_POINTED_AT);
type_node_ptr = type_node_ptr->fe_info->original;
}
FE_SET(type_node_ptr->fe_info->flags,FE_POINTED_AT);
if (type_node_ptr->xmit_as_type == NULL
&& (type_is_scalar(type_node_ptr) || type_node_ptr == ASTP_void_ptr
|| type_node_ptr == ASTP_handle_ptr))
return;
tp_node = AST_type_ptr_node(null_parser_location);
tp_node->type = type_node_ptr;
*pa_types = (AST_type_p_n_t *)AST_concat_element(
(ASTP_node_t *)*pa_types,
(ASTP_node_t *)tp_node);
}
void PROP_process_up_type
(
AST_type_n_t *type_node_ptr
)
{
AST_type_p_n_t *tp_node;
tp_node = AST_type_ptr_node(null_parser_location);
tp_node->type = type_node_ptr;
PROP_up_types_list = (AST_type_p_n_t *)AST_concat_element(
(ASTP_node_t *)PROP_up_types_list,
(ASTP_node_t *)tp_node);
}
static boolean type_contains_context
(
AST_type_n_t *type_p
)
{
if (AST_CONTEXT_RD_SET(type_p))
{
return TRUE;
}
if (!type_can_contain_context(type_p))
{
return FALSE;
}
if (type_visited(type_p))
return FALSE;
else
type_visit(type_p);
switch (type_p->kind)
{
case AST_pointer_k:
if (type_contains_context(type_p->type_structure.pointer->pointee_type))
{
return TRUE;
}
break;
case AST_array_k:
if (AST_CONTEXT_RD_SET(type_p->type_structure.array->element_type)
|| type_contains_context(type_p->type_structure.array->element_type))
{
return TRUE;
}
break;
case AST_structure_k:
{
AST_field_n_t *field_p;
for (field_p = type_p->type_structure.structure->fields;
field_p != NULL;
field_p = field_p->next)
{
if (AST_CONTEXT_SET(field_p) ||
type_contains_context(field_p->type))
{
return TRUE;
}
}
break;
}
case AST_disc_union_k:
{
AST_arm_n_t *arm_p;
for (arm_p = type_p->type_structure.disc_union->arms;
arm_p != NULL;
arm_p = arm_p->next)
{
if (AST_CONTEXT_SET(arm_p)
|| (arm_p->type != NULL
&& type_contains_context(arm_p->type)))
{
return TRUE;
}
}
break;
}
default:
break;
}
return FALSE;
}
static boolean type_contains_ool
(
AST_type_n_t *type_p
)
{
if (AST_OUT_OF_LINE_SET(type_p))
{
return TRUE;
}
if (type_p->xmit_as_type != NULL)
return type_contains_ool(type_p->xmit_as_type);
if (type_visited(type_p))
return FALSE;
else
type_visit(type_p);
switch (type_p->kind)
{
case AST_pointer_k:
if (type_contains_ool(type_p->type_structure.pointer->pointee_type))
{
return TRUE;
}
break;
case AST_array_k:
if (AST_OUT_OF_LINE_SET(type_p->type_structure.array->element_type)
|| type_contains_ool(type_p->type_structure.array->element_type))
{
return TRUE;
}
break;
case AST_structure_k:
{
AST_field_n_t *field_p;
for (field_p = type_p->type_structure.structure->fields;
field_p != NULL;
field_p = field_p->next)
{
if (AST_OUT_OF_LINE_SET(field_p) ||
type_contains_ool(field_p->type))
{
return TRUE;
}
}
break;
}
case AST_disc_union_k:
{
AST_arm_n_t *arm_p;
for (arm_p = type_p->type_structure.disc_union->arms;
arm_p != NULL;
arm_p = arm_p->next)
{
if (AST_OUT_OF_LINE_SET(arm_p)
|| (arm_p->type != NULL
&& type_contains_ool(arm_p->type)))
{
return TRUE;
}
}
break;
}
case AST_pipe_k:
if (AST_OUT_OF_LINE_SET(type_p->type_structure.pipe->base_type)
|| type_contains_ool(type_p->type_structure.pipe->base_type))
return TRUE;
break;
default:
break;
}
return FALSE;
}
static boolean type_contains_conformant
(
AST_type_n_t *type_p
)
{
AST_field_n_t *field_p;
if (!(type_p->kind == AST_structure_k))
{
return FALSE;
}
if (type_visited(type_p))
return FALSE;
else
type_visit(type_p);
for (field_p = type_p->type_structure.structure->fields;
field_p != NULL;
field_p = field_p->next)
{
if ((AST_CONFORMANT_SET(field_p->type)
&& field_p->type->kind != AST_pointer_k)
||
type_contains_conformant(field_p->type))
{
PROP_set_type_attr(type_p,AST_CONFORMANT);
return TRUE;
}
}
return FALSE;
}
#define TYPE_PROP_PARAM_EXIT_TEST \
if (FE_TEST(param_p->fe_info->flags, FE_HAS_CFMT_ARR)) \
return
static void type_prop_param
(
AST_parameter_n_t *param_p,
AST_type_n_t *type_p,
AST_field_attr_n_t *fattr_p,
boolean string_set,
boolean non_ref
)
{
if (type_visited(type_p))
return;
else
type_visit(type_p);
switch (type_p->kind)
{
case AST_pointer_k:
if (type_p == param_p->type)
{
if (AST_PTR_SET(param_p)) return;
}
else
if (non_ref) return;
if (type_p != param_p->type
&& (string_set || AST_STRING_SET(type_p)))
FE_SET(param_p->fe_info->flags, FE_HAS_CFMT_ARR);
if (type_p != param_p->type
&& fattr_p != NULL
&& (fattr_p->min_is_vec != NULL
|| fattr_p->max_is_vec != NULL
|| fattr_p->size_is_vec != NULL))
FE_SET(param_p->fe_info->flags, FE_HAS_CFMT_ARR);
TYPE_PROP_PARAM_EXIT_TEST;
type_prop_param(param_p, type_p->type_structure.pointer->pointee_type,
(AST_field_attr_n_t *)NULL, FALSE,
!AST_REF_SET(type_p->type_structure.pointer->pointee_type));
break;
case AST_array_k:
if (type_p != param_p->type
&& AST_CONFORMANT_SET(type_p))
FE_SET(param_p->fe_info->flags, FE_HAS_CFMT_ARR);
TYPE_PROP_PARAM_EXIT_TEST;
type_prop_param(param_p, type_p->type_structure.array->element_type,
(AST_field_attr_n_t *)NULL, FALSE,
!AST_REF_SET(type_p->type_structure.array->element_type));
break;
case AST_structure_k:
{
AST_structure_n_t *struct_p;
AST_field_n_t *field_p;
struct_p = type_p->type_structure.structure;
for (field_p = struct_p->fields
; field_p != NULL
; field_p = field_p->next)
{
type_prop_param(param_p, field_p->type, field_p->field_attrs,
AST_STRING_SET(field_p)!=0, !AST_REF_SET(field_p));
TYPE_PROP_PARAM_EXIT_TEST;
}
break;
}
case AST_disc_union_k:
{
AST_disc_union_n_t *union_p;
AST_arm_n_t *arm_p;
union_p = type_p->type_structure.disc_union;
for (arm_p = union_p->arms
; arm_p != NULL
; arm_p = arm_p->next)
if (arm_p->type != NULL)
{
type_prop_param(param_p, arm_p->type,
(AST_field_attr_n_t *)NULL,
AST_STRING_SET(arm_p)!=0, !AST_REF_SET(arm_p));
TYPE_PROP_PARAM_EXIT_TEST;
}
break;
}
default:
break;
}
return;
}
#define C_PTR_TEST(c_type_p, early_exit) \
{ \
prop_pointer_types(c_type_p, &c_ptr, &c_ref, &c_unique, &c_full); \
if (c_ptr) \
{ \
FE_SET(type_p->fe_info->flags, FE_HAS_PTR); \
*ptr = TRUE; \
if (c_ref || FE_TEST(c_type_p->fe_info->flags, FE_HAS_REF_PTR)) \
{ \
FE_SET(type_p->fe_info->flags, FE_HAS_REF_PTR); \
*ref = TRUE; \
} \
if (c_unique || FE_TEST(c_type_p->fe_info->flags, FE_HAS_UNIQUE_PTR)) \
{ \
FE_SET(type_p->fe_info->flags, FE_HAS_UNIQUE_PTR); \
*unique = TRUE; \
} \
if (c_full || FE_TEST(c_type_p->fe_info->flags, FE_HAS_FULL_PTR)) \
{ \
FE_SET(type_p->fe_info->flags, FE_HAS_FULL_PTR); \
*full = TRUE; \
} \
if (early_exit && *ref && *unique && *full) \
return; \
} \
}
static void prop_pointer_types
(
AST_type_n_t *type_p,
boolean *ptr,
boolean *ref,
boolean *unique,
boolean *full
)
{
boolean c_ptr;
boolean c_ref;
boolean c_unique;
boolean c_full;
*ptr = FE_TEST(type_p->fe_info->flags, FE_HAS_PTR);
*ref = FE_TEST(type_p->fe_info->flags, FE_HAS_REF_PTR);
*unique = FE_TEST(type_p->fe_info->flags, FE_HAS_UNIQUE_PTR);
*full = FE_TEST(type_p->fe_info->flags, FE_HAS_FULL_PTR);
if (!type_can_contain_pointer(type_p) || type_visited(type_p) || *ptr)
return;
type_visit(type_p);
switch (type_p->kind)
{
case AST_pointer_k:
FE_SET(type_p->fe_info->flags, FE_HAS_PTR);
*ptr = TRUE;
if (AST_REF_SET(type_p)
|| FE_TEST(type_p->fe_info->flags, FE_HAS_REF_PTR))
{
FE_SET(type_p->fe_info->flags, FE_HAS_REF_PTR);
*ref = TRUE;
}
if (AST_UNIQUE_SET(type_p)
|| FE_TEST(type_p->fe_info->flags, FE_HAS_UNIQUE_PTR))
{
FE_SET(type_p->fe_info->flags, FE_HAS_UNIQUE_PTR);
*unique = TRUE;
}
if (AST_PTR_SET(type_p)
|| FE_TEST(type_p->fe_info->flags, FE_HAS_FULL_PTR))
{
FE_SET(type_p->fe_info->flags, FE_HAS_FULL_PTR);
*full = TRUE;
}
if (*ref && *unique && *full)
return;
C_PTR_TEST(type_p->type_structure.pointer->pointee_type, TRUE);
break;
case AST_structure_k:
{
AST_structure_n_t *struct_p;
AST_field_n_t *field_p;
struct_p = type_p->type_structure.structure;
for (field_p = struct_p->fields
; field_p != NULL
; field_p = field_p->next)
{
if (AST_REF_SET(field_p))
FE_SET(type_p->fe_info->flags, FE_HAS_REF_PTR);
if (AST_PTR_SET(field_p))
FE_SET(type_p->fe_info->flags, FE_HAS_PTR);
if (AST_UNIQUE_SET(field_p))
FE_SET(type_p->fe_info->flags, FE_HAS_UNIQUE_PTR);
if (AST_PTR_SET(field_p))
FE_SET(type_p->fe_info->flags, FE_HAS_FULL_PTR);
C_PTR_TEST(field_p->type, TRUE);
}
break;
}
case AST_array_k:
C_PTR_TEST(type_p->type_structure.array->element_type, TRUE);
break;
case AST_disc_union_k:
{
AST_disc_union_n_t *union_p;
AST_arm_n_t *arm_p;
union_p = type_p->type_structure.disc_union;
for (arm_p = union_p->arms
; arm_p != NULL
; arm_p = arm_p->next)
if (arm_p->type != NULL)
{
if (AST_REF_SET(arm_p))
FE_SET(type_p->fe_info->flags, FE_HAS_REF_PTR);
if (AST_PTR_SET(arm_p))
FE_SET(type_p->fe_info->flags, FE_HAS_PTR);
if (AST_UNIQUE_SET(arm_p))
FE_SET(type_p->fe_info->flags, FE_HAS_UNIQUE_PTR);
if (AST_PTR_SET(arm_p))
FE_SET(type_p->fe_info->flags, FE_HAS_FULL_PTR);
C_PTR_TEST(arm_p->type, FALSE);
}
if (FE_TEST(type_p->fe_info->flags,FE_HAS_PTR))
PROP_process_up_type(type_p);
break;
}
default:
break;
}
}
static void PROP_type_info_OR
(
prop_ctx_t *dst_ctx,
prop_ctx_t *src_ctx
)
{
dst_ctx->toplevel_ref_param |= src_ctx->toplevel_ref_param;
dst_ctx->toplevel_param |= src_ctx->toplevel_param;
dst_ctx->typedef_dcl |= src_ctx->typedef_dcl;
dst_ctx->has_rep_as |= src_ctx->has_rep_as;
dst_ctx->ct_cs_char |= src_ctx->ct_cs_char;
dst_ctx->has_xmit_as |= src_ctx->has_xmit_as;
dst_ctx->in_xmitted |= src_ctx->in_xmitted;
dst_ctx->has_v1_attr |= src_ctx->has_v1_attr;
dst_ctx->has_v2_attr |= src_ctx->has_v2_attr;
dst_ctx->in_aux |= src_ctx->in_aux;
dst_ctx->under_ptr |= src_ctx->under_ptr;
dst_ctx->has_enum |= src_ctx->has_enum;
dst_ctx->has_union |= src_ctx->has_union;
dst_ctx->has_vary_array |= src_ctx->has_vary_array;
dst_ctx->has_char |= src_ctx->has_char;
dst_ctx->has_float |= src_ctx->has_float;
dst_ctx->has_int |= src_ctx->has_int;
dst_ctx->has_error_status |= src_ctx->has_error_status;
dst_ctx->has_v1_struct |= src_ctx->has_v1_struct;
dst_ctx->has_interface |= src_ctx->has_interface;
}
static void PROP_type_union
(
AST_type_n_t *type_p,
prop_ctx_t *ctx
)
{
AST_disc_union_n_t *union_p;
AST_arm_n_t *arm_p;
prop_ctx_t saved_parent_ctx;
prop_ctx_t member_ctx;
union_p = type_p->type_structure.disc_union;
if (union_p->discrim_type != NULL) {
COPY_IF_LARGER(type_p->ndr_size,union_p->discrim_type->ndr_size);
COPY_IF_LARGER(type_p->alignment_size,union_p->discrim_type->alignment_size);
}
saved_parent_ctx = *ctx;
for (arm_p = union_p->arms
; arm_p != NULL
; arm_p = arm_p->next)
{
if (arm_p->type != NULL)
{
if (!ctx->under_ptr && (arm_p->type->kind == AST_pointer_k))
ctx->under_ptr = !AST_REF_SET(arm_p);
member_ctx = saved_parent_ctx;
member_ctx.instance_p = (ASTP_node_t *)arm_p;
member_ctx.parent_type_p = type_p;
PROP_type_info(arm_p->type, &member_ctx);
PROP_type_info_OR(ctx, &member_ctx);
COPY_IF_LARGER(type_p->alignment_size,arm_p->type->alignment_size);
}
}
}
static void PROP_type_struct
(
AST_type_n_t *type_p,
prop_ctx_t *ctx
)
{
AST_structure_n_t *struct_p;
AST_field_n_t *field_p;
prop_ctx_t saved_parent_ctx;
prop_ctx_t member_ctx;
struct_p = type_p->type_structure.structure;
type_p->ndr_size = 0;
saved_parent_ctx = *ctx;
for (field_p = struct_p->fields
; field_p != NULL
; field_p = field_p->next)
{
if (!ctx->under_ptr && (field_p->type->kind == AST_pointer_k))
ctx->under_ptr = !AST_REF_SET(field_p);
if (AST_VARYING_SET(field_p))
ctx->has_vary_array = TRUE;
member_ctx = saved_parent_ctx;
member_ctx.instance_p = (ASTP_node_t *)field_p;
member_ctx.parent_type_p = type_p;
PROP_type_info(field_p->type, &member_ctx);
if (AST_CONFORMANT_SET(field_p->type) || AST_VARYING_SET(field_p))
member_ctx.has_int = TRUE;
PROP_type_info_OR(ctx, &member_ctx);
type_p->ndr_size += field_p->type->ndr_size;
if (AST_UNALIGN_SET(type_p))
type_p->alignment_size = struct_p->fields->type->alignment_size;
else
COPY_IF_LARGER(type_p->alignment_size,field_p->type->alignment_size);
}
}
static void PROP_type_info
(
AST_type_n_t *type_p,
prop_ctx_t *ctx
)
{
boolean toplevel_ref_param;
boolean toplevel_param;
boolean in_aux;
boolean under_ptr;
ASTP_node_t *instance_p;
AST_type_n_t *parent_p;
if (type_visited(type_p))
return;
else
type_visit(type_p);
if (type_p->kind == AST_array_k
&& type_p->name != NAMETABLE_NIL_ID
&& !ctx->toplevel_param
&& !ctx->typedef_dcl
&& AST_PTR_SET(type_p))
FE_SET(type_p->fe_info->flags, FE_HAS_PTR_ARRAY);
if (ctx->in_xmitted)
FE_SET(type_p->fe_info->flags, FE_USED_IN_TRANSMITTED);
if (AST_STRING0_SET(type_p)
|| (AST_SMALL_SET(type_p) &&
(type_p->kind != AST_array_k || AST_CONFORMANT_SET(type_p)))
|| AST_V1_ENUM_SET(type_p)
|| AST_UNALIGN_SET(type_p))
FE_SET(type_p->fe_info->flags, FE_HAS_V1_ATTR);
if (AST_STRING_SET(type_p)
|| type_p->kind == AST_pipe_k
|| (type_p->kind == AST_pointer_k &&
!ctx->typedef_dcl && !ctx->toplevel_ref_param)
|| (type_p->kind == AST_enum_k && !AST_V1_ENUM_SET(type_p))
|| (type_p->kind == AST_structure_k && !AST_UNALIGN_SET(type_p))
|| (type_is_anonymous(type_p) && ctx->instance_p == NULL &&
type_p->kind == AST_array_k && AST_CONFORMANT_SET(type_p) &&
!AST_SMALL_SET(type_p))
|| type_p->cs_char_type != NULL)
FE_SET(type_p->fe_info->flags, FE_HAS_V2_ATTR);
instance_p = ctx->instance_p;
parent_p = ctx->parent_type_p;
ctx->instance_p = NULL;
ctx->parent_type_p = NULL;
if (instance_p != NULL)
{
AST_instance_n_t *inst_p = (AST_instance_n_t *)instance_p;
if (type_p->kind == AST_array_k
&& type_p->type_structure.array->element_type->cs_char_type != NULL
&& inst_p->field_attrs != NULL)
{
AST_field_attr_n_t *fattr_p = inst_p->field_attrs;
if (fattr_p->size_is_vec != NULL)
{
FE_SET(fattr_p->size_is_vec->ref.p_ref->fe_info->flags,
FE_USED_AS_CS_FLD_ATTR);
(fattr_p->size_is_vec->ref.p_ref->fe_info->ref_count)++;
}
if (fattr_p->length_is_vec != NULL)
{
FE_SET(fattr_p->length_is_vec->ref.p_ref->fe_info->flags,
FE_USED_AS_CS_FLD_ATTR);
(fattr_p->length_is_vec->ref.p_ref->fe_info->ref_count)++;
}
switch(inst_p->fe_info->node_kind)
{
case fe_parameter_n_k:
PROP_set_nf_cs_char_param((AST_parameter_n_t *)inst_p);
break;
case fe_field_n_k:
FE_SET(parent_p->fe_info->flags, FE_HAS_NF_CS_ARRAY);
break;
default:
break;
}
}
else if (inst_p->field_attrs != NULL)
{
PROP_set_used_as_reg_fld_attr(inst_p);
}
switch(instance_p->fe_info->node_kind)
{
case fe_parameter_n_k:
{
AST_parameter_n_t *param_p = (AST_parameter_n_t *)instance_p;
if (FE_TEST(type_p->fe_info->flags, FE_HAS_V1_ATTR)
|| AST_STRING0_SET(param_p)
|| (AST_SMALL_SET(param_p) &&
(type_p->kind != AST_array_k ||
AST_CONFORMANT_SET(type_p) || AST_VARYING_SET(param_p))))
FE_SET(param_p->fe_info->flags, FE_HAS_V1_ATTR);
if (FE_TEST(type_p->fe_info->flags, FE_HAS_V2_ATTR)
|| AST_STRING_SET(param_p)
|| AST_PTR_SET(param_p) || AST_UNIQUE_SET(param_p)
|| (type_p->kind == AST_array_k &&
(AST_CONFORMANT_SET(type_p) || AST_VARYING_SET(param_p))
&& !AST_SMALL_SET(type_p) && !AST_SMALL_SET(param_p)))
FE_SET(param_p->fe_info->flags, FE_HAS_V2_ATTR);
break;
}
case fe_field_n_k:
{
AST_field_n_t *field_p = (AST_field_n_t *)instance_p;
if (FE_TEST(type_p->fe_info->flags, FE_HAS_V1_ATTR)
|| AST_STRING0_SET(field_p)
|| (AST_SMALL_SET(field_p) &&
(type_p->kind != AST_array_k ||
AST_CONFORMANT_SET(type_p) || AST_VARYING_SET(field_p))))
{
FE_SET(field_p->fe_info->flags, FE_HAS_V1_ATTR);
FE_SET(parent_p->fe_info->flags, FE_HAS_V1_ATTR);
}
if (FE_TEST(type_p->fe_info->flags, FE_HAS_V2_ATTR)
|| AST_STRING_SET(field_p)
|| AST_PTR_SET(field_p) || AST_UNIQUE_SET(field_p)
|| (type_p->kind == AST_array_k &&
(AST_CONFORMANT_SET(type_p) || AST_VARYING_SET(field_p))
&& !AST_SMALL_SET(type_p) && !AST_SMALL_SET(field_p)))
{
FE_SET(field_p->fe_info->flags, FE_HAS_V2_ATTR);
FE_SET(parent_p->fe_info->flags, FE_HAS_V2_ATTR);
}
break;
}
case fe_arm_n_k:
{
AST_arm_n_t *arm_p = (AST_arm_n_t *)instance_p;
if (FE_TEST(type_p->fe_info->flags, FE_HAS_V1_ATTR)
|| AST_STRING0_SET(arm_p)
|| (AST_SMALL_SET(arm_p) &&
(type_p->kind != AST_array_k ||
AST_CONFORMANT_SET(type_p) || AST_VARYING_SET(arm_p))))
{
FE_SET(arm_p->fe_info->flags, FE_HAS_V1_ATTR);
FE_SET(parent_p->fe_info->flags, FE_HAS_V1_ATTR);
}
if (FE_TEST(type_p->fe_info->flags, FE_HAS_V2_ATTR)
|| AST_STRING_SET(arm_p)
|| AST_PTR_SET(arm_p) || AST_UNIQUE_SET(arm_p)
|| (type_p->kind == AST_array_k &&
(AST_CONFORMANT_SET(type_p) || AST_VARYING_SET(arm_p))
&& !AST_SMALL_SET(type_p) && !AST_SMALL_SET(arm_p)))
{
FE_SET(arm_p->fe_info->flags, FE_HAS_V2_ATTR);
FE_SET(parent_p->fe_info->flags, FE_HAS_V2_ATTR);
}
break;
}
default:
break;
}
}
toplevel_param = ctx->toplevel_param;
toplevel_ref_param = ctx->toplevel_ref_param;
under_ptr = ctx->under_ptr;
ctx->toplevel_ref_param = false;
ctx->toplevel_param = false;
if (ctx->typedef_dcl)
{
if (FE_TEST(type_p->fe_info->flags,FE_PROP_TYPE_DONE))
{
if (FE_TEST(type_p->fe_info->flags, FE_HAS_V1_ATTR))
ctx->has_v1_attr = true;
if (FE_TEST(type_p->fe_info->flags, FE_HAS_V2_ATTR))
ctx->has_v2_attr = true;
}
else FE_SET(type_p->fe_info->flags,FE_PROP_TYPE_DONE);
}
else
{
if (!toplevel_param && !( (AST_IN_SET(ctx->param_p) &&
!FE_TEST(type_p->fe_info->flags,FE_PROP_IN_PARAM_DONE)) ||
(AST_OUT_SET(ctx->param_p) &&
!FE_TEST(type_p->fe_info->flags,FE_PROP_OUT_PARAM_DONE))))
{
if (FE_TEST(type_p->fe_info->flags, FE_HAS_V1_ATTR))
ctx->has_v1_attr = true;
if (FE_TEST(type_p->fe_info->flags, FE_HAS_V2_ATTR))
ctx->has_v2_attr = true;
}
if (AST_IN_SET(ctx->param_p)) FE_SET(type_p->fe_info->flags,FE_PROP_IN_PARAM_DONE);
if (AST_OUT_SET(ctx->param_p)) FE_SET(type_p->fe_info->flags,FE_PROP_OUT_PARAM_DONE);
}
in_aux = ctx->in_aux;
if (((type_p->name != NAMETABLE_NIL_ID) &&
(((type_p->kind == AST_pointer_k) && AST_SELF_POINTER_SET(type_p)) ||
(AST_OUT_OF_LINE_SET(type_p)))))
ctx->in_aux = true;
if (type_p->xmit_as_type != NULL)
{
ctx->in_xmitted = TRUE;
PROP_type_info(type_p->xmit_as_type, ctx);
ctx->has_xmit_as = TRUE;
}
else
{
switch (type_p->kind)
{
case AST_structure_k:
PROP_type_struct(type_p, ctx);
if (AST_UNALIGN_SET(type_p))
ctx->has_v1_struct = TRUE;
break;
case AST_array_k:
PROP_type_info(type_p->type_structure.array->element_type, ctx);
COPY_IF_LARGER(type_p->alignment_size,type_p->type_structure.array->element_type->alignment_size);
type_p->ndr_size = type_p->type_structure.array->element_type->ndr_size;
if (!AST_CONFORMANT_SET(type_p))
{
int i;
for (i = type_p->type_structure.array->index_count - 1; i >= 0; i--)
{
AST_array_index_n_t *index_p;
index_p = &type_p->type_structure.array->index_vec[i];
type_p->ndr_size *= (
index_p->upper_bound->value.int_val - index_p->lower_bound->value.int_val);
}
}
if (toplevel_param && !toplevel_ref_param)
{
PROP_process_pa_type(type_p, &ctx->int_p->pa_types, ctx);
if (type_p->xmit_as_type != NULL)
PROP_process_pa_type(type_p->xmit_as_type, &ctx->int_p->pa_types, ctx);
}
break;
case AST_disc_union_k:
PROP_type_union(type_p, ctx);
ctx->has_union = TRUE;
break;
case AST_pointer_k:
{
AST_type_n_t *ptee_type_p;
ptee_type_p = type_p->type_structure.pointer->pointee_type;
if (ptee_type_p->kind == AST_interface_k)
ctx->has_interface = TRUE;
if (ptee_type_p->fe_info->fe_type_id != fe_ptr_info)
{
ptee_type_p->fe_info->fe_type_id = fe_ptr_info;
ptee_type_p->fe_info->type_specific.pointer_type = type_p;
}
if ((instance_p == NULL) && !ctx->under_ptr)
ctx->under_ptr = !AST_REF_SET(type_p);
PROP_type_info(ptee_type_p, ctx);
if (ptee_type_p->array_rep_type != NULL
&& ptee_type_p->cs_char_type == NULL)
{
if (!in_aux && ctx->in_aux)
{
ctx->in_aux = false;
PROP_type_info(ptee_type_p->array_rep_type,ctx);
ctx->in_aux = true;
}
else
PROP_type_info(ptee_type_p->array_rep_type,ctx);
}
if (!toplevel_ref_param)
{
ctx->parent_type_p = type_p;
PROP_process_pa_type(ptee_type_p, &ctx->int_p->pa_types, ctx);
if (ptee_type_p->xmit_as_type != NULL)
PROP_process_pa_type(ptee_type_p->xmit_as_type,
&ctx->int_p->pa_types, ctx);
if (ptee_type_p->array_rep_type != NULL
&& ptee_type_p->cs_char_type == NULL)
{
PROP_process_pa_type(
ptee_type_p->array_rep_type,
&ctx->int_p->pa_types,
ctx);
if (ptee_type_p->array_rep_type->xmit_as_type != NULL)
PROP_process_pa_type(
ptee_type_p->array_rep_type->xmit_as_type,
&ctx->int_p->pa_types,
ctx);
}
}
break;
}
case AST_pipe_k:
PROP_type_info(type_p->type_structure.pipe->base_type, ctx);
break;
default:
break;
}
}
if (type_p->rep_as_type != NULL)
ctx->has_rep_as = TRUE;
if (type_p->xmit_as_type == NULL)
{
char const *type_name;
AST_type_n_t *base_type_p = type_p;
while (base_type_p->defined_as != NULL)
base_type_p = base_type_p->defined_as;
NAMETABLE_id_to_string(base_type_p->name, &type_name);
if (strcmp(type_name, "error_status_t") == 0)
ctx->has_error_status = TRUE;
if (type_p->kind == AST_character_k)
ctx->has_char = TRUE;
else if (type_is_float(type_p))
ctx->has_float = TRUE;
else if (type_is_multibyte_integer(type_p))
ctx->has_int = TRUE;
else if (type_is_enum(type_p))
ctx->has_enum = TRUE;
else if (AST_PTR_SET(type_p))
{
ctx->has_int = TRUE;
}
}
ctx->in_aux = in_aux;
ctx->under_ptr = under_ptr;
type_unvisit(type_p);
if (ctx->ct_cs_char
|| (type_p->defined_as != NULL
&& type_p->defined_as->cs_char_type != NULL))
FE_SET(type_p->fe_info->flags, FE_CT_CS_CHAR);
if (type_p->cs_char_type != NULL)
ctx->ct_cs_char = TRUE;
if ((type_p->name == NAMETABLE_NIL_ID) &&
(type_contains_conformant(type_p)))
PROP_set_type_attr(type_p,AST_CONFORMANT);
if (ctx->has_rep_as)
FE_SET(type_p->fe_info->flags, FE_HAS_REP_AS);
if (ctx->has_xmit_as)
FE_SET(type_p->fe_info->flags, FE_HAS_XMIT_AS);
if (ctx->has_char)
FE_SET(type_p->fe_info->flags, FE_HAS_CHAR);
if (ctx->has_float)
FE_SET(type_p->fe_info->flags, FE_HAS_FLOAT);
if (ctx->has_int)
FE_SET(type_p->fe_info->flags, FE_HAS_INT);
if (type_p->kind == AST_structure_k
&& !ctx->has_enum
&& !ctx->has_union
&& !ctx->has_vary_array
&& !ctx->has_xmit_as
&& !ctx->has_rep_as
&& !FE_TEST(type_p->fe_info->flags, FE_HAS_PTR)
&& !ctx->has_error_status
&& !ctx->has_interface
&& !ctx->has_v1_struct)
FE_SET(type_p->fe_info->flags, FE_MAYBE_WIRE_ALIGNED);
if (FE_TEST(type_p->fe_info->flags, FE_HAS_V1_ATTR))
ctx->has_v1_attr = true;
if (FE_TEST(type_p->fe_info->flags, FE_HAS_V2_ATTR))
ctx->has_v2_attr = true;
if (type_p->kind == AST_pointer_k
|| type_p->kind == AST_structure_k
|| type_p->kind == AST_array_k
|| type_p->kind == AST_enum_k
|| type_p->kind == AST_pipe_k)
{
if (ctx->has_v1_attr)
FE_SET(type_p->fe_info->flags, FE_HAS_V1_ATTR);
if (ctx->has_v2_attr)
FE_SET(type_p->fe_info->flags, FE_HAS_V2_ATTR);
if (instance_p != NULL)
{
switch(instance_p->fe_info->node_kind)
{
case fe_parameter_n_k:
{
AST_parameter_n_t *param_p = (AST_parameter_n_t *)instance_p;
if (ctx->has_v1_attr)
FE_SET(param_p->fe_info->flags, FE_HAS_V1_ATTR);
if (ctx->has_v2_attr)
FE_SET(param_p->fe_info->flags, FE_HAS_V2_ATTR);
break;
}
case fe_field_n_k:
{
AST_field_n_t *field_p = (AST_field_n_t *)instance_p;
if (ctx->has_v1_attr)
FE_SET(field_p->fe_info->flags, FE_HAS_V1_ATTR);
if (ctx->has_v2_attr)
FE_SET(field_p->fe_info->flags, FE_HAS_V2_ATTR);
break;
}
case fe_arm_n_k:
{
AST_arm_n_t *arm_p = (AST_arm_n_t *)instance_p;
if (ctx->has_v1_attr)
FE_SET(arm_p->fe_info->flags, FE_HAS_V1_ATTR);
if (ctx->has_v2_attr)
FE_SET(arm_p->fe_info->flags, FE_HAS_V2_ATTR);
break;
}
default:
break;
}
}
}
}
static void type_process_in_out_attrs
(
AST_type_n_t *type_p,
boolean set_in,
boolean set_out,
boolean set_out_pa_ref,
boolean varying
)
{
if (type_visited(type_p))
return;
type_visit(type_p);
if (set_in)
{
PROP_set_type_usage_attr(type_p,AST_IN);
if (type_p->xmit_as_type != NULL)
PROP_set_type_usage_attr(type_p->xmit_as_type,AST_IN);
}
if (set_out)
{
PROP_set_type_usage_attr(type_p,AST_OUT);
if (type_p->xmit_as_type != NULL)
PROP_set_type_usage_attr(type_p->xmit_as_type,AST_OUT);
}
if (set_out_pa_ref)
{
PROP_set_type_usage_attr(type_p,AST_OUT_PA_REF);
if (type_p->xmit_as_type != NULL)
PROP_set_type_usage_attr(type_p->xmit_as_type,AST_OUT_PA_REF);
}
switch (type_p->kind)
{
case AST_pointer_k:
type_process_in_out_attrs(type_p->type_structure.pointer->pointee_type,
set_in, set_out, set_out_pa_ref,false);
if (type_p->type_structure.pointer->pointee_type->array_rep_type != NULL)
{
type_process_in_out_attrs(
type_p->type_structure.pointer->pointee_type->array_rep_type,
set_in, set_out, set_out_pa_ref,varying || AST_STRING_SET(type_p));
}
break;
case AST_structure_k:
{
AST_structure_n_t *struct_p;
AST_field_n_t *field_p;
struct_p = type_p->type_structure.structure;
for (field_p = struct_p->fields
; field_p != NULL
; field_p = field_p->next)
{
if (AST_VARYING_SET(field_p))
{
if (set_in) PROP_set_type_usage_attr(field_p->type,AST_IN_VARYING);
if (set_out) PROP_set_type_usage_attr(field_p->type,AST_OUT_VARYING);
} else if ((field_p->type->kind == AST_pointer_k) ||
(field_p->type->kind == AST_array_k))
{
if (set_in) PROP_set_type_usage_attr(field_p->type,AST_IN_FIXED);
if (set_out) PROP_set_type_usage_attr(field_p->type,AST_OUT_FIXED);
}
type_process_in_out_attrs(field_p->type,
set_in, set_out, set_out_pa_ref, AST_VARYING_SET(field_p)!=0);
}
break;
}
case AST_array_k:
if (varying)
{
if (set_in) PROP_set_type_usage_attr(type_p,AST_IN_VARYING);
if (set_out) PROP_set_type_usage_attr(type_p,AST_OUT_VARYING);
}
else {
if (set_in) PROP_set_type_usage_attr(type_p,AST_IN_FIXED);
if (set_out) PROP_set_type_usage_attr(type_p,AST_OUT_FIXED);
}
type_process_in_out_attrs(type_p->type_structure.array->element_type,
set_in, set_out, set_out_pa_ref, false);
break;
case AST_disc_union_k:
{
AST_disc_union_n_t *union_p;
AST_arm_n_t *arm_p;
union_p = type_p->type_structure.disc_union;
for (arm_p = union_p->arms
; arm_p != NULL
; arm_p = arm_p->next)
if (arm_p->type != NULL)
{
if (AST_VARYING_SET(arm_p))
{
if (set_in) PROP_set_type_usage_attr(arm_p->type,AST_IN_VARYING);
if (set_out) PROP_set_type_usage_attr(arm_p->type,AST_OUT_VARYING);
} else if ((arm_p->type->kind == AST_pointer_k) ||
(arm_p->type->kind == AST_array_k))
{
if (set_in) PROP_set_type_usage_attr(arm_p->type,AST_IN_FIXED);
if (set_out) PROP_set_type_usage_attr(arm_p->type,AST_OUT_FIXED);
}
type_process_in_out_attrs(arm_p->type,
set_in, set_out, set_out_pa_ref, AST_VARYING_SET(arm_p)!=0);
}
break;
}
case AST_pipe_k:
type_process_in_out_attrs(type_p->type_structure.pipe->base_type,
set_in, set_out, set_out_pa_ref, false);
break;
default:
break;
}
}
#if 0
static boolean type_contains_mutable
(
AST_type_n_t *type_p
)
{
if (!type_can_contain_pointer(type_p))
{
return FALSE;
}
if (type_visited(type_p))
return FALSE;
else
type_visit(type_p);
switch (type_p->kind)
{
case AST_pointer_k:
if AST_MUTABLE_SET(type_p)
{
return TRUE;
}
else
{
if (type_contains_mutable(
type_p->type_structure.pointer->pointee_type))
{
return TRUE;
}
}
break;
case AST_structure_k:
{
AST_field_n_t *field_p;
for (field_p = type_p->type_structure.structure->fields;
field_p != NULL;
field_p = field_p->next)
{
if (type_contains_mutable(field_p->type))
{
return TRUE;
}
}
break;
}
case AST_array_k:
if (type_contains_mutable(
type_p->type_structure.array->element_type))
{
return TRUE;
}
break;
case AST_disc_union_k:
{
AST_arm_n_t *arm_p;
for (arm_p = type_p->type_structure.disc_union->arms;
arm_p != NULL;
arm_p = arm_p->next)
{
if (arm_p->type != NULL && type_contains_mutable(arm_p->type))
{
return TRUE;
}
}
break;
}
default:
break;
}
return FALSE;
}
#endif
static boolean type_contains_pointer
(
AST_type_n_t *type_p
)
{
if (!type_can_contain_pointer(type_p))
{
return FALSE;
}
if (type_visited(type_p))
return FALSE;
else
type_visit(type_p);
if (type_p->xmit_as_type != NULL)
return type_contains_pointer(type_p->xmit_as_type);
switch (type_p->kind)
{
case AST_pointer_k:
return TRUE;
break;
case AST_structure_k:
{
AST_field_n_t *field_p;
for (field_p = type_p->type_structure.structure->fields;
field_p != NULL;
field_p = field_p->next)
{
if (type_contains_pointer(field_p->type))
{
return TRUE;
}
}
break;
}
case AST_array_k:
if (type_contains_pointer(
type_p->type_structure.array->element_type))
{
return TRUE;
}
break;
case AST_disc_union_k:
{
AST_arm_n_t *arm_p;
for (arm_p = type_p->type_structure.disc_union->arms;
arm_p != NULL;
arm_p = arm_p->next)
{
if (arm_p->type != NULL && type_contains_pointer(arm_p->type))
{
return TRUE;
}
}
break;
}
default:
break;
}
return FALSE;
}
static void type_prop_conformant
(
AST_type_n_t *type_p
)
{
visited_list = NULL;
type_contains_conformant(type_p);
type_visit_free();
}
static void type_prop_up_to_param
(
AST_parameter_n_t *param_p
)
{
AST_type_n_t *type_p;
boolean non_ref;
visited_list = NULL;
type_p = param_follow_ref_ptr(param_p, CHK_follow_ref_arr_siz);
if (param_p->type == type_p)
non_ref = !AST_REF_SET(param_p);
else
non_ref = !AST_REF_SET(type_p);
type_prop_param(param_p, type_p, param_p->field_attrs,
AST_STRING_SET(param_p)!=0, non_ref);
type_visit_free();
}
#if 0
static boolean type_has_mutable
(
AST_type_n_t *type_p
)
{
boolean has_mutable;
visited_list = NULL;
has_mutable = type_contains_mutable(type_p);
type_visit_free();
return has_mutable;
}
#endif
static boolean type_has_pointer
(
AST_type_n_t *type_p
)
{
boolean has_pointer;
visited_list = NULL;
has_pointer = type_contains_pointer(type_p);
type_visit_free();
return has_pointer;
}
static void type_prop_ptr_attrs
(
AST_type_n_t *type_p
)
{
boolean ptr;
boolean ref;
boolean unique;
boolean full;
visited_list = NULL;
prop_pointer_types(type_p, &ptr, &ref, &unique, &full);
type_visit_free();
}
static void type_prop_in_out_attrs
(
AST_type_n_t *type_p,
boolean in,
boolean out,
boolean varying
)
{
if (!in && !out && !AST_OUT_PA_REF_SET(type_p))
return;
visited_list = NULL;
type_process_in_out_attrs(type_p,
in,
out,
(AST_OUT_PA_REF_SET(type_p) != 0),
varying
);
type_visit_free();
}
static boolean type_has_context
(
AST_type_n_t *type_p
)
{
boolean has_context;
visited_list = NULL;
has_context = type_contains_context(type_p);
type_visit_free();
return has_context;
}
static boolean type_has_ool
(
AST_type_n_t *type_p
)
{
boolean has_ool;
visited_list = NULL;
has_ool = type_contains_ool(type_p);
type_visit_free();
return has_ool;
}
static NAMETABLE_id_t *type_get_tag_name_addr
(
AST_type_n_t *type_p
)
{
switch (type_p->kind)
{
case AST_structure_k:
return &(type_p->type_structure.structure->tag_name);
case AST_disc_union_k:
return &(type_p->type_structure.disc_union->tag_name);
case AST_array_k:
return type_get_tag_name_addr
(type_p->type_structure.array->element_type);
default:
return NULL;
}
}
static void type_prop_to_instance
(
AST_type_n_t *type_p
)
{
switch (type_p->kind)
{
case AST_structure_k:
{
AST_field_n_t *field_p;
for (field_p = type_p->type_structure.structure->fields
; field_p != NULL
; field_p = field_p->next)
{
if (AST_STRING_SET(field_p->type) || AST_STRING_SET(field_p))
{
AST_SET_STRING(field_p);
AST_SET_VARYING(field_p);
}
}
return;
}
case AST_disc_union_k:
{
AST_arm_n_t *arm_p;
for (arm_p = type_p->type_structure.disc_union->arms
; arm_p != NULL
; arm_p = arm_p->next)
if (arm_p->type != NULL
&& (AST_STRING_SET(arm_p) || AST_STRING_SET(arm_p->type)))
{
AST_SET_STRING(arm_p);
AST_SET_VARYING(arm_p);
}
return;
}
default:
break;
}
}
static void type_prop
(
AST_type_n_t *type_p,
AST_interface_n_t *int_p,
AST_interface_n_t *parent_int_p
)
{
prop_ctx_t ctx;
ctx.toplevel_ref_param = false;
ctx.toplevel_param = false;
ctx.int_p = int_p;
ctx.instance_p = NULL;
ctx.param_p = NULL;
ctx.parent_type_p = NULL;
ctx.typedef_dcl = true;
ctx.has_rep_as = false;
ctx.ct_cs_char = false;
ctx.has_xmit_as = false;
ctx.in_xmitted = false;
ctx.has_v1_attr = false;
ctx.has_v2_attr = false;
ctx.in_aux = false;
ctx.under_ptr = false;
ctx.has_enum = false;
ctx.has_union = false;
ctx.has_vary_array = false;
ctx.has_char = false;
ctx.has_float = false;
ctx.has_int = false;
ctx.has_error_status = false;
ctx.has_v1_struct = false;
if (AST_IN_LINE_SET(int_p)
&& !AST_OUT_OF_LINE_SET(type_p)
&& !type_is_scalar(type_p))
{
PROP_set_type_usage_attr(type_p,AST_IN_LINE);
}
if (AST_OUT_OF_LINE_SET(int_p)
&& !AST_IN_LINE_SET(type_p)
&& !type_is_scalar(type_p)
&& type_p->xmit_as_type == NULL
&& type_p->kind != AST_pointer_k)
{
PROP_set_type_usage_attr(type_p,AST_OUT_OF_LINE);
}
if (parent_int_p == NULL
&& AST_OUT_OF_LINE_SET(type_p)
&& !FE_TEST(type_p->fe_info->flags,FE_OOL))
{
AST_type_p_n_t *typep_p;
typep_p = AST_type_ptr_node(null_parser_location);
typep_p->type = type_p;
FE_SET(type_p->fe_info->flags,FE_OOL);
int_p->ool_types = (AST_type_p_n_t *)AST_concat_element(
(ASTP_node_t *)int_p->ool_types,
(ASTP_node_t *)typep_p);
if ((type_p->kind == AST_pointer_k) &&
(type_p->type_structure.pointer->pointee_type->array_rep_type != NULL) &&
!FE_TEST(type_p->type_structure.pointer->pointee_type->array_rep_type->fe_info->flags,FE_OOL))
{
typep_p = AST_type_ptr_node(null_parser_location);
typep_p->type = type_p;
FE_SET(type_p->type_structure.pointer->pointee_type->array_rep_type->fe_info->flags,FE_OOL);
int_p->ool_types = (AST_type_p_n_t *)AST_concat_element(
(ASTP_node_t *)int_p->ool_types,
(ASTP_node_t *)type_p->type_structure.pointer->pointee_type->array_rep_type);
}
}
type_prop_to_instance(type_p);
type_prop_conformant(type_p);
type_prop_ptr_attrs(type_p);
if (type_p->kind == AST_array_k
&& type_is_anonymous(type_p->type_structure.array->element_type))
{
NAMETABLE_id_t *tag_name_p;
tag_name_p = type_get_tag_name_addr
(type_p->type_structure.array->element_type);
if (tag_name_p != NULL && *tag_name_p == NAMETABLE_NIL_ID)
*tag_name_p = AST_generate_name(int_p,"_tag");
}
if (parent_int_p == NULL && !AST_LOCAL_SET(int_p))
{
visited_list = NULL;
PROP_type_info(type_p, &ctx);
type_visit_free();
}
}
static void param_prop
(
AST_parameter_n_t *param_p,
AST_operation_n_t *op_p,
AST_interface_n_t *int_p
)
{
AST_type_n_t *top_type_p;
AST_type_n_t *type_p;
prop_ctx_t ctx;
boolean has_in_ctx = false;
top_type_p = param_p->type;
type_p = param_follow_ref_ptr(param_p, CHK_follow_ref_arr_siz);
if (param_p->uplink->cs_tag_rtn_name != NAMETABLE_NIL_ID
&& (AST_CS_STAG_SET(param_p) || AST_CS_DRTAG_SET(param_p)
|| AST_CS_RTAG_SET(param_p)))
AST_SET_HIDDEN(param_p);
if ((top_type_p->kind == AST_pointer_k) &&
AST_REF_SET(param_p) &&
AST_OUT_SET(param_p) && !AST_IN_SET(param_p))
PROP_set_type_usage_attr(type_p,AST_OUT_PA_REF);
ctx.toplevel_param = true;
ctx.toplevel_ref_param = (AST_REF_SET(param_p) != 0);
ctx.int_p = int_p;
ctx.instance_p = (ASTP_node_t *)param_p;
ctx.param_p = param_p;
ctx.parent_type_p = NULL;
ctx.typedef_dcl = false;
ctx.has_rep_as = false;
ctx.ct_cs_char = false;
ctx.has_xmit_as = false;
ctx.in_xmitted = false;
ctx.has_v1_attr = false;
ctx.has_v2_attr = false;
ctx.in_aux = false;
ctx.under_ptr = false;
ctx.has_enum = false;
ctx.has_union = false;
ctx.has_vary_array = false;
ctx.has_char = false;
ctx.has_float = false;
ctx.has_int = false;
ctx.has_error_status = false;
ctx.has_v1_struct = false;
if (!AST_LOCAL_SET(int_p))
{
visited_list = NULL;
PROP_type_info(top_type_p, &ctx);
type_visit_free();
}
if (top_type_p->kind == AST_short_float_k
&& param_p != op_p->result)
FE_SET(op_p->fe_info->flags, FE_HAS_VAL_FLOAT);
if (AST_HEAP_SET(type_p))
AST_SET_HEAP(param_p);
if (AST_STRING_SET(top_type_p) || AST_STRING_SET(param_p))
{
AST_SET_STRING(param_p);
AST_SET_VARYING(param_p);
}
if (AST_CONTEXT_RD_SET(top_type_p)
|| AST_CONTEXT_RD_SET(type_p))
AST_SET_CONTEXT(param_p);
if (AST_IN_SET(param_p))
{
PROP_set_type_usage_attr(type_p,AST_IN);
if (type_p->xmit_as_type != NULL)
PROP_set_type_usage_attr(type_p->xmit_as_type,AST_IN);
if (AST_CONTEXT_SET(param_p) ||
type_has_context(top_type_p))
{
AST_SET_HAS_IN_CTX(op_p);
has_in_ctx = true;
}
if (type_has_ool(top_type_p))
{
AST_SET_HAS_IN_OOLS(op_p);
}
if (AST_PTR_SET(param_p)
|| AST_UNIQUE_SET(param_p)
|| (!AST_STRING_SET(param_p)
&& !AST_CONTEXT_RD_SET(type_p) && type_has_pointer(type_p)))
AST_SET_HAS_IN_PTRS(op_p);
if (AST_VARYING_SET(param_p))
PROP_set_type_usage_attr(type_p,AST_IN_VARYING);
else if ((type_p->kind == AST_pointer_k) ||
(type_p->kind == AST_array_k))
PROP_set_type_usage_attr(type_p,AST_IN_FIXED);
}
if (AST_OUT_SET(param_p))
{
PROP_set_type_usage_attr(type_p,AST_OUT);
if (type_p->xmit_as_type != NULL)
PROP_set_type_usage_attr(type_p->xmit_as_type,AST_OUT);
if (AST_CONTEXT_SET(param_p) ||
type_has_context(top_type_p))
{
AST_SET_HAS_OUT_CTX(op_p);
if (has_in_ctx) AST_SET_HAS_IN_OUT_CTX(op_p);
}
if (type_has_ool(top_type_p))
{
AST_SET_HAS_OUT_OOLS(op_p);
}
if (AST_PTR_SET(param_p)
|| AST_UNIQUE_SET(param_p)
|| (!AST_STRING_SET(param_p)
&& !AST_CONTEXT_RD_SET(type_p) && type_has_pointer(type_p)))
AST_SET_HAS_OUT_PTRS(op_p);
if (AST_VARYING_SET(param_p))
PROP_set_type_usage_attr(type_p,AST_OUT_VARYING);
else if ((type_p->kind == AST_pointer_k) ||
(type_p->kind == AST_array_k))
PROP_set_type_usage_attr(type_p,AST_OUT_FIXED);
}
type_prop_up_to_param(param_p);
type_prop_in_out_attrs(type_p,
AST_IN_SET(param_p)!=0,
AST_OUT_SET(param_p)!=0,
AST_VARYING_SET(param_p)!=0);
if (ctx.has_rep_as)
AST_SET_ENABLE_ALLOCATE(op_p);
if (ctx.has_xmit_as)
AST_SET_HAS_XMIT_AS(op_p);
if (type_is_anonymous(top_type_p))
{
type_prop_conformant(top_type_p);
type_prop_ptr_attrs(top_type_p);
}
if (AST_PTR_SET(param_p) || FE_TEST(param_p->type->fe_info->flags, FE_HAS_FULL_PTR))
{
AST_SET_HAS_FULL_PTRS(op_p);
if (AST_IN_SET(param_p))
FE_SET(op_p->fe_info->flags, FE_HAS_IN_FULL_PTR);
}
if (type_is_anonymous(top_type_p))
{
NAMETABLE_id_t *tag_name_p;
tag_name_p = type_get_tag_name_addr(top_type_p);
if (tag_name_p != NULL && *tag_name_p == NAMETABLE_NIL_ID)
*tag_name_p = AST_generate_name(int_p,"_tag");
}
}
static void op_add_binding_handle_param
(
AST_operation_n_t *op_p
)
{
NAMETABLE_id_t new_param_id;
AST_parameter_n_t *new_param_p;
new_param_id = NAMETABLE_add_id("IDL_handle");
new_param_p = AST_parameter_node(null_parser_location,
new_param_id);
new_param_p->type = ASTP_handle_ptr;
new_param_p->uplink = op_p;
AST_SET_IN(new_param_p);
new_param_p->next = op_p->parameters;
if (new_param_p->next != NULL)
{
new_param_p->last = new_param_p->next->last;
new_param_p->next->last = NULL;
}
op_p->parameters = new_param_p;
}
static void PROP_auto_heap
(
AST_operation_n_t *op_p
)
{
AST_parameter_n_t *param_p;
int stack_size;
int auto_heap_size;
auto_heap_size = AUTO_HEAP_STACK_THRESHOLD;
do {
stack_size = 0;
for (param_p = op_p->parameters ; param_p != NULL ; param_p = param_p->next)
{
AST_type_n_t *surrogate_type = param_p->type;
if (surrogate_type->kind == AST_pointer_k && !AST_PTR_SET(surrogate_type))
surrogate_type = surrogate_type->type_structure.pointer->pointee_type;
if (surrogate_type->ndr_size >= auto_heap_size)
AST_SET_HEAP(param_p);
if (!AST_HEAP_SET(param_p))
stack_size += surrogate_type->ndr_size;
}
if (op_p->result != NULL)
{
AST_type_n_t *surrogate_type = op_p->result->type;
if (surrogate_type->kind == AST_pointer_k && !AST_PTR_SET(surrogate_type))
surrogate_type = surrogate_type->type_structure.pointer->pointee_type;
if (surrogate_type->ndr_size >= auto_heap_size)
AST_SET_HEAP(op_p->result);
if (!AST_HEAP_SET(op_p->result))
stack_size += surrogate_type->ndr_size;
}
auto_heap_size = auto_heap_size >> 2;
} while ((stack_size > AUTO_HEAP_STACK_THRESHOLD) && (auto_heap_size > 4));
}
static void operation_prop
(
AST_operation_n_t *op_p,
AST_interface_n_t *int_p
)
{
AST_parameter_n_t *param_p;
if (AST_CODE_SET(int_p)
&& !AST_NO_CODE_SET(op_p))
AST_SET_CODE(op_p);
if (AST_NO_CODE_SET(int_p)
&& !AST_CODE_SET(op_p))
AST_SET_NO_CODE(op_p);
if (AST_ENCODE_SET(int_p))
AST_SET_ENCODE(op_p);
if (AST_DECODE_SET(int_p))
AST_SET_DECODE(op_p);
if ((AST_ENCODE_SET(op_p) || AST_DECODE_SET(op_p))
&& !AST_NO_CODE_SET(op_p))
AST_SET_HAS_ENCODE_OPS(int_p);
if (AST_EXPLICIT_HANDLE_SET(int_p)
&& (op_p->parameters == NULL
|| !type_is_handle(op_p->parameters->type)))
AST_SET_EXPLICIT_HANDLE(op_p);
if (AST_EXPLICIT_HANDLE_SET(op_p)
&& op_p->parameters != NULL
&& param_is_handle(op_p->parameters))
AST_CLR_EXPLICIT_HANDLE(op_p);
if (AST_EXPLICIT_HANDLE_SET(op_p))
op_add_binding_handle_param(op_p);
if (AST_NO_CANCEL_SET(int_p))
AST_SET_NO_CANCEL(op_p);
if (int_p->cs_tag_rtn_name != NAMETABLE_NIL_ID
&& op_p->cs_tag_rtn_name == NAMETABLE_NIL_ID)
{
for (param_p = op_p->parameters;
param_p != NULL ;
param_p = param_p->next)
{
if (AST_CS_STAG_SET(param_p) || AST_CS_DRTAG_SET(param_p)
|| AST_CS_RTAG_SET(param_p))
{
op_p->cs_tag_rtn_name = int_p->cs_tag_rtn_name;
break;
}
}
}
if (op_p->cs_tag_rtn_name != NAMETABLE_NIL_ID)
{
if (NAMETABLE_add_binding(op_p->cs_tag_rtn_name, (char *)int_p))
{
AST_name_n_t *name_p;
name_p = AST_name_node(op_p->cs_tag_rtn_name);
int_p->cs_tag_rtns = (AST_name_n_t *)AST_concat_element(
(ASTP_node_t *)int_p->cs_tag_rtns, (ASTP_node_t *)name_p);
}
}
for (param_p = op_p->parameters ; param_p != NULL ; param_p = param_p->next)
param_prop(param_p, op_p, int_p);
if (op_p->result != NULL)
param_prop(op_p->result, op_p, int_p);
PROP_auto_heap(op_p);
}
static void export_prop
(
AST_export_n_t *export_p,
AST_interface_n_t *int_p,
AST_interface_n_t *parent_int_p
)
{
switch (export_p->kind)
{
case AST_cpp_quote_k:
case AST_constant_k:
break;
case AST_operation_k:
if (parent_int_p == NULL)
operation_prop(export_p->thing_p.exported_operation, int_p);
break;
case AST_type_k:
type_prop(export_p->thing_p.exported_type, int_p, parent_int_p);
break;
default:
error(NIDL_INTERNAL_ERROR, __FILE__, __LINE__);
}
}
static void interface_prop
(
AST_interface_n_t *int_p,
AST_interface_n_t *parent_int_p
)
{
AST_export_n_t *export_p;
AST_import_n_t *import_p;
if (parent_int_p == NULL
&& !AST_CODE_SET(int_p)
&& !AST_NO_CODE_SET(int_p))
AST_SET_CODE(int_p);
if (!AST_IN_LINE_SET(int_p)
&& !AST_OUT_OF_LINE_SET(int_p))
{
#ifdef DUMPERS
if (cmd_opt[opt_ool])
AST_SET_OUT_OF_LINE(int_p);
else
#endif
AST_SET_IN_LINE(int_p);
}
import_p = int_p->imports;
while (import_p != NULL)
{
if (import_p->interface != NULL)
interface_prop(import_p->interface, int_p);
import_p = import_p->next;
}
if (int_p->prev)
{
interface_prop(int_p->prev, parent_int_p);
}
PROP_up_types_list = NULL;
for (export_p = int_p->exports
; export_p != NULL
; export_p = export_p->next)
export_prop(export_p, int_p, parent_int_p);
int_p->up_types = PROP_up_types_list;
}
static AST_type_p_n_t *PROP_remove_type_p(
AST_type_p_n_t **list_root, AST_type_p_n_t *type_p, AST_type_p_n_t *prev_type_p
);
static AST_type_p_n_t *PROP_remove_type_p
(AST_type_p_n_t **list_root, AST_type_p_n_t *type_p, AST_type_p_n_t *prev_type_p)
{
if (*list_root == type_p)
{
*list_root = (*list_root)->next;
FREE(type_p);
return *list_root;
}
else if (prev_type_p != NULL)
{
prev_type_p->next = type_p->next;
if ((*list_root)->last == type_p) (*list_root)->last = prev_type_p;
FREE(type_p)
return prev_type_p;
}
else
{
AST_type_p_n_t *cp,*pp;
pp = NULL;
for (cp = *list_root; ((cp != NULL) && (cp != type_p)); cp = cp->next) pp = cp;
if ((cp != type_p) || (pp == NULL)) error(NIDL_INTERNAL_ERROR, __FILE__, __LINE__);
return PROP_remove_type_p(list_root,type_p,pp);
}
}
static void PROP_post_filter_types_list
(AST_type_p_n_t **list_root, boolean filter_xmit_as ATTRIBUTE_UNUSED)
{
AST_type_p_n_t *cp;
AST_type_p_n_t *pcp;
AST_type_p_n_t *tp;
AST_type_p_n_t *ptp;
pcp = (AST_type_p_n_t *)NULL;
for (cp = *list_root; cp; cp = cp->next)
{
restart:
switch (cp->type->kind)
{
case AST_structure_k:
{
AST_structure_n_t *sp;
sp = cp->type->type_structure.structure;
ptp = cp;
for (tp = cp->next; tp; tp = tp->next)
{
boolean counterparts = false;
if (AST_DEF_AS_TAG_SET(tp->type) &&
(cp->type->fe_info->tag_ptr == tp->type)) counterparts = true;
if (AST_DEF_AS_TAG_SET(cp->type) &&
(tp->type->fe_info->tag_ptr == cp->type)) counterparts = true;
if ((tp->type->kind == AST_structure_k) &&
(tp->type->type_structure.structure == sp) &&
counterparts)
{
if (AST_DEF_AS_TAG_SET(tp->type))
tp = PROP_remove_type_p(list_root,tp,ptp);
else {
cp = PROP_remove_type_p(list_root,cp,pcp);
pcp = NULL;
goto restart;
}
}
ptp = tp;
}
break;
}
case AST_disc_union_k:
{
AST_disc_union_n_t *up;
up = cp->type->type_structure.disc_union;
ptp = cp;
for (tp = cp->next; tp; tp = tp->next)
{
boolean counterparts = false;
if (AST_DEF_AS_TAG_SET(tp->type) &&
(cp->type->fe_info->tag_ptr == tp->type)) counterparts = true;
if (AST_DEF_AS_TAG_SET(cp->type) &&
(tp->type->fe_info->tag_ptr == cp->type)) counterparts = true;
if ((tp->type->kind == AST_disc_union_k) &&
(tp->type->type_structure.disc_union == up) &&
counterparts)
{
if (AST_DEF_AS_TAG_SET(tp->type))
tp = PROP_remove_type_p(list_root,tp,ptp);
else {
cp = PROP_remove_type_p(list_root,cp,pcp);
pcp = NULL;
goto restart;
}
}
ptp = tp;
}
break;
}
default:
break;
}
pcp = cp;
}
}
static void type_add_type_to_sp_list
(
AST_type_n_t *type_node_ptr,
AST_type_p_n_t **types_list,
AST_type_n_t *parent_type_ptr ATTRIBUTE_UNUSED
)
{
AST_type_p_n_t *tp;
if (type_node_ptr->xmit_as_type != NULL)
type_node_ptr = type_node_ptr->xmit_as_type;
if (FE_TEST(type_node_ptr->fe_info->flags,FE_SELF_POINTING)) return;
if (AST_DEF_AS_TAG_SET(type_node_ptr) && type_node_ptr->fe_info->original)
{
FE_SET(type_node_ptr->fe_info->flags,FE_SELF_POINTING);
type_node_ptr = type_node_ptr->fe_info->original;
}
if (type_is_scalar(type_node_ptr) || type_node_ptr == ASTP_void_ptr
|| type_node_ptr == ASTP_handle_ptr)
return;
for (tp = *types_list; tp; tp = tp->next)
if (tp->type == type_node_ptr) return;
tp = AST_type_ptr_node(null_parser_location);
tp->type = type_node_ptr;
FE_SET(type_node_ptr->fe_info->flags,FE_SELF_POINTING);
*types_list = (AST_type_p_n_t *)AST_concat_element(
(ASTP_node_t *)*types_list,
(ASTP_node_t *)tp);
}
static void type_find_pa_types
(
AST_type_n_t *type_p,
AST_type_p_n_t **types_list
)
{
if (type_visited(type_p)) return;
type_visit(type_p);
switch (type_p->kind)
{
case AST_structure_k:
{
AST_structure_n_t *struct_p;
AST_field_n_t *field_p;
struct_p = type_p->type_structure.structure;
for (field_p = struct_p->fields
; field_p != NULL
; field_p = field_p->next)
{
type_find_pa_types(field_p->type, types_list);
}
break;
}
case AST_array_k:
type_find_pa_types(type_p->type_structure.array->element_type,
types_list);
break;
case AST_disc_union_k:
{
AST_disc_union_n_t *union_p;
AST_arm_n_t *arm_p;
union_p = type_p->type_structure.disc_union;
for (arm_p = union_p->arms
; arm_p != NULL
; arm_p = arm_p->next)
{
if (arm_p->type != NULL)
{
type_find_pa_types(arm_p->type,types_list);
}
}
break;
}
case AST_pointer_k:
if (!FE_TEST(type_p->fe_info->flags,FE_SELF_POINTING))
{
type_find_pa_types(type_p->type_structure.pointer->pointee_type,
types_list);
type_add_type_to_sp_list(type_p->type_structure.pointer->pointee_type,
types_list, type_p);
if (type_p->type_structure.pointer->pointee_type->array_rep_type != NULL)
{
type_add_type_to_sp_list(type_p->type_structure.pointer->
pointee_type->array_rep_type,
types_list, type_p);
if (AST_VARYING_SET(type_p->type_structure.pointer->pointee_type->array_rep_type))
{
AST_SET_IN_VARYING(type_p->type_structure.pointer->pointee_type->array_rep_type);
AST_SET_OUT_VARYING(type_p->type_structure.pointer->pointee_type->array_rep_type);
}
}
}
break;
default:
break;
}
}
static void PROP_contained_pa_to_sp_list
(AST_type_p_n_t **types_list,AST_type_p_n_t **dest_list)
{
AST_type_p_n_t *cp;
AST_type_p_n_t *contained_pa_types = NULL;
for (cp = *types_list; cp; cp = cp->next)
{
visited_list = NULL;
type_find_pa_types(cp->type,&contained_pa_types);
type_visit_free();
}
*dest_list = (AST_type_p_n_t *)AST_concat_element(
(ASTP_node_t *)*dest_list,
(ASTP_node_t *)contained_pa_types);
}
static void types_list_prop
(
AST_type_p_n_t *typep_p,
AST_interface_n_t *int_p
)
{
AST_type_n_t *type_p;
NAMETABLE_id_t *tag_name_p;
for ( ; typep_p != NULL ; typep_p = typep_p->next)
{
type_p = typep_p->type;
if (!type_is_anonymous(type_p))
continue;
tag_name_p = type_get_tag_name_addr(type_p);
if (tag_name_p == NULL || *tag_name_p != NAMETABLE_NIL_ID)
continue;
*tag_name_p = AST_generate_name(int_p,"_tag");
}
}
boolean PROP_main
(
boolean *cmd_opt_arr,
void **cmd_val_arr,
AST_interface_n_t *int_p
)
{
cmd_opt = cmd_opt_arr;
cmd_val = cmd_val_arr;
assert(int_p != NULL);
interface_prop(int_p, NULL);
PROP_contained_pa_to_sp_list(&int_p->sp_types,&int_p->sp_types);
PROP_contained_pa_to_sp_list(&int_p->ool_types,&int_p->sp_types);
PROP_post_filter_types_list(&int_p->ool_types, FALSE);
PROP_post_filter_types_list(&int_p->ra_types, FALSE);
PROP_post_filter_types_list(&int_p->sp_types, FALSE);
PROP_post_filter_types_list(&int_p->pa_types, FALSE);
PROP_post_filter_types_list(&int_p->up_types, FALSE);
types_list_prop(int_p->pa_types, int_p);
return TRUE;
}