int
lite_PD_cast (PDBfile *file, char *type, char *memb, char *contr) {
HASHTAB *tab;
hashel *hp;
defstr *dp;
memdes *desc, *lst;
/*
* Add the cast to the file->chart.
*/
tab = file->chart;
for (hp = *(tab->table); hp != NULL; hp = hp->next) {
dp = (defstr *) hp->def;
if (strcmp(type, dp->type) != 0) continue;
/*
* Check that the contr is right.
*/
for (desc = dp->members; desc != NULL; desc = desc->next) {
if (strcmp(contr, desc->name) != 0) continue;
/*
* Do this once, don't repeat in other chart.
*/
if ((strcmp(desc->base_type, "char") != 0) ||
!_lite_PD_indirection(desc->type)) {
sprintf(lite_PD_err, "BAD CAST CONTROLLER - PD_CAST");
return(FALSE);
}
break;
}
}
/*
* Add the cast to the file->host_chart.
*/
tab = file->host_chart;
for (hp = *(tab->table); hp != NULL; hp = hp->next) {
dp = (defstr *) hp->def;
if (strcmp(type, dp->type) != 0) continue;
for (desc = dp->members; desc != NULL; desc = desc->next) {
if (strcmp(memb, desc->name) != 0) continue;
/*
* Make an independent copy in case the one in the file
* chart is released.
*/
desc->cast_memb = lite_SC_strsavef(contr, "char*:PD_CAST:membh");
desc->cast_offs = _lite_PD_member_location(contr, tab, dp, &lst);
}
}
return(TRUE);
}
defstr *
lite_PD_defstr (PDBfile *file, char *name, ...) {
char *nxt, *ptype;
int doffs;
HASHTAB *fchrt;
memdes *desc, *lst, *prev;
defstr *dp;
va_list ap ;
va_start (ap, name);
prev = NULL;
lst = NULL;
fchrt = file->chart;
doffs = file->default_offset;
for (nxt = va_arg(ap, char*); (int) *nxt != 0; nxt = va_arg(ap, char*)) {
desc = _lite_PD_mk_descriptor(nxt, doffs);
ptype = desc->base_type;
if (lite_SC_lookup(ptype, fchrt) == NULL) {
if ((strcmp(ptype, name) != 0) || !_lite_PD_indirection(nxt)) {
sprintf(lite_PD_err, "ERROR: %s BAD MEMBER TYPE - PD_DEFSTR\n",
nxt);
return(NULL);
}
}
if (lst == NULL) lst = desc;
else prev->next = desc;
prev = desc;
}
va_end (ap) ;
/*
* Install the type in both charts.
*/
dp = _lite_PD_defstr_inst(name, lst, -1, NULL, NULL, fchrt,
file->host_chart, file->align, file->host_align,
FALSE);
if (dp == NULL) {
sprintf(lite_PD_err, "ERROR: CAN'T HANDLE PRIMITIVE TYPE - PD_DEFSTR\n");
}
return(dp);
}
/*-------------------------------------------------------------------------
* Function: _lite_PD_mk_defstr
*
* Purpose: Make a defstr entry for the structure chart.
*
* Return: Success:
*
* Failure:
*
* Programmer: Adapted from PACT PDB
* Mar 5, 1996 4:45 PM EST
*
* Modifications:
* Eric Brugger, Tue Dec 8 15:16:07 PST 1998
* Remove unnecessary calls to lite_SC_mark, since reference count now
* set when allocated.
*
*-------------------------------------------------------------------------
*/
defstr *
_lite_PD_mk_defstr (char *type, memdes *lst, long sz, int align, int flg,
int conv, int *ordr, long *formt) {
defstr *dp;
memdes *desc;
int n;
dp = FMAKE(defstr, "_PD_MK_DEFSTR:dp");
dp->type = lite_SC_strsavef(type, "char*:_PD_MK_DEFSTR:type");
dp->alignment = align;
dp->convert = conv;
dp->onescmp = 0;
dp->unsgned = 0;
dp->order_flag = flg;
dp->order = ordr;
dp->format = formt;
dp->members = lst;
if (sz >= 0) {
dp->size_bits = 0L;
dp->size = sz;
} else {
dp->size_bits = -sz;
dp->size = (-sz + 7) >> 3L;
dp->unsgned = TRUE;
}
/*
* Find the number of indirects.
*/
for (n = 0, desc = lst; desc != NULL; desc = desc->next) {
if (_lite_PD_indirection(desc->type)) n++;
}
dp->n_indirects = n;
return(dp);
}
/*-------------------------------------------------------------------------
* Function: lite_PD_convert
*
* Purpose: Convert from one machine format to another NITEMS of type
* TYPE from IN and put them in OUT. ISTD and OSTD are the
* data format standards of IN and OUT respectively.
*
* Return: Success:
*
* Failure:
*
* Programmer: Adapted from PACT PDB
* Mar 6, 1996 11:34 AM EST
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
lite_PD_convert (char **out, char **in, char *intype, char *outtype,
long nitems, data_standard *istd, data_standard *ostd,
data_standard *hstd, long *pin_offs, long *pout_offs,
HASHTAB *in_chart, HASHTAB *out_chart, int boffs, int error) {
int ret = FALSE, tmp;
long i, mitems, in_incr, out_incr;
char *mtype;
defstr *idp, *odp, *midp, *modp;
memdes *desc;
if (_lite_PD_indirection(outtype)) {
in_incr = _lite_PD_align(*pin_offs, intype, in_chart, &tmp);
out_incr = _lite_PD_align(*pout_offs, outtype, out_chart, &tmp);
*pin_offs += in_incr;
*pout_offs += out_incr;
*in += istd->ptr_bytes + in_incr;
*out += ostd->ptr_bytes + out_incr;
return(TRUE);
}
idp = PD_inquire_table_type(in_chart, intype);
if (idp == NULL)
lite_PD_error("BAD TYPE IN_CHART - PD_CONVERT", error);
odp = PD_inquire_table_type(out_chart, outtype);
if (odp == NULL)
lite_PD_error("BAD TYPE OUT_CHART - PD_CONVERT", error);
/*
* If members is non-NULL then it is a derived type.
*/
if (odp->members != NULL) {
for (i = 0L; i < nitems; i++) {
in_incr = _lite_PD_align(*pin_offs, intype, in_chart, &tmp);
out_incr = _lite_PD_align(*pout_offs, outtype, out_chart, &tmp);
*pin_offs += in_incr;
*pout_offs += out_incr;
*in += in_incr;
*out += out_incr;
for (desc = odp->members; desc != NULL; desc = desc->next) {
mitems = desc->number;
mtype = desc->type;
in_incr = _lite_PD_align(*pin_offs, mtype, in_chart, &tmp);
out_incr = _lite_PD_align(*pout_offs, mtype, out_chart, &tmp);
/*
* Increment the offsets to the alignments.
*/
*pin_offs += in_incr;
*pout_offs += out_incr;
*in += in_incr;
*out += out_incr;
if (_lite_PD_indirection(mtype)) {
/*
* Don't even think about converting pointers - they will be
* recomputed. However, don't throw away information about
* whether or not pointer is null.
*/
if (!_lite_PD_null_pointer(*in, istd->ptr_bytes)) **out = 1;
*in += istd->ptr_bytes;
*out += ostd->ptr_bytes;
*pin_offs += istd->ptr_bytes;
*pout_offs += ostd->ptr_bytes;
ret = TRUE;
} else if (_lite_PD_prim_typep(desc->base_type, in_chart, error)) {
/*
* Check for direct primitives.
*/
modp = PD_inquire_table_type(out_chart, mtype);
if (modp == NULL)
lite_PD_error("BAD OUT TYPE IN STRUCT - PD_CONVERT", error);
midp = PD_inquire_table_type(in_chart, mtype);
if (midp == NULL)
lite_PD_error("BAD IN TYPE IN STRUCT - PD_CONVERT", error);
ret = _lite_PD_convert((char **) out, in, mitems, boffs,
midp, modp, hstd, pin_offs, pout_offs);
} else {
/*
* Recurse for direct derived types.
*/
ret = lite_PD_convert(out, in, mtype, mtype, mitems,
istd, ostd, hstd, pin_offs, pout_offs,
in_chart, out_chart, boffs, error);
}
if (!ret)
lite_PD_error("STRUCT CONVERSION FAILED - PD_CONVERT",
error);
}
}
} else {
/*
* if members is NULL then it is a primitive type.
*/
ret = _lite_PD_convert((char **) out, in, nitems, boffs, idp, odp,
hstd, pin_offs, pout_offs);
if (!ret)
lite_PD_error("PRIMITIVE CONVERSION FAILED - PD_CONVERT", error);
}
return(ret);
}
