Lines Matching refs:size
90 if ((sizeof (itm_place_t)) < itm_hdr->interpreter.size) {
93 itm_hdr->interpreter.size,
99 if ((sizeof (itm_place_t)) < itm_hdr->type_id.size) {
102 itm_hdr->type_id.size,
149 act->tbl_hdr, act->tbl_hdr->size,
186 tbl->size = (sizeof (itm_tbl_hdr_t)) + (obj_array.num *obj_size);
200 itm_size_t size)
211 obj_array.obj = malloc_vital(hdr_size + (size * obj_array.num));
217 ol; offset += size, ol = ol->next) {
218 (void) memcpy((char *)(obj_array.obj) + offset, ol->obj, size);
302 void *obj, size_t size, itm_place_t *ref,
308 type, name, obj, size, ref, reg_place));
317 refp->size = size;
335 } else if ((NULL != name) && (0 < name->size)) {
384 if (rp->data0.size == 0) {
389 length = rp->data0.size;
391 if ((rp->data0.size != length) ||
392 (rp->data1.size != length)) {
412 table->size = table_size;
447 len_min = ((itm_data_t *)(ol->obj))->size;
450 if (ep->size < len_min) len_min = ep->size;
451 if (ep->size > len_max) len_max = ep->size;
472 table->size = table_size;
483 if ((sizeof (itm_place_t)) < ep->size) {
485 (void *)(ep->place.itm_ptr), ep->size,
592 if (0 == ml->data_pair.data0.size) {
593 if (0 == ml->data_pair.data1.size) {
603 } else if (0 == ml->data_pair.data1.size) {
610 (0 < ml->data_pair.data0.size) &&
611 (source_len != ml->data_pair.data0.size)) {
616 if (source_len < ml->data_pair.data0.size) {
617 source_len = ml->data_pair.data0.size;
619 if (result_len < ml->data_pair.data1.size) {
620 result_len = ml->data_pair.data1.size;
624 if (0 < ml->data_pair.range.size) {
625 if (ml->data_pair.range.size !=
626 ml->data_pair.data0.size) {
674 if (0 == ml->data_pair.data0.size) {
686 if (0 == ml->data_pair.data0.size) {
690 if (ml->data_pair.range.size > 0) {
733 if (0 < ml->data_pair.data0.size) {
738 if (ml->data_pair.range.size > 0) {
743 if (0 == ml->data_pair.data1.size) {
754 if (((*(dp1+0))->range.size != 0) &&
782 "specified, but size does not match\n"));
794 if (0 < (*(tpp + num - 1))->range.size) {
937 map_type_name[i].name, attr->type->size)) {
970 assert((sizeof (itm_place_t)) >= source->size);
972 if ((1 == source->size) &&
979 if (0 < (*(tpp + num - 1))->range.size)
1005 if ((1 == (*tpp)->data0.size) &&
1006 (1 == (*tpp)->data1.size)) {
1012 header->size = table_size;
1015 sub_hdr->source_len = (*tpp)->data0.size;
1040 if (source->size != resultlen) {
1043 "specified, but size does not match\n"));
1059 if (default_data->size <= (sizeof (itm_place_t))) {
1064 (resultlen - default_data->size),
1066 default_data->size);
1073 (resultlen - default_data->size),
1075 default_data->size);
1082 if (0 == (*(tpp + i))->data1.size) {
1087 k = ((*(tpp + i))->range.size) == 0 ? j :
1097 if (0 == (*(tpp + i))->data1.size) {
1101 k = ((*(tpp + i))->range.size) == 0 ? j :
1114 if (0 != (*(tpp + i))->range.size)
1120 (void) memcpy(p + (resultlen - (*(tpp + i))->data1.size),
1122 (*(tpp + i))->data1.size);
1160 ((source->size + 1 + resultlen) * num2));
1163 table_size += (source->size + 1 + resultlen);
1172 header->size = table_size;
1187 sub_hdr->source_len = source->size;
1191 source_data = malloc_vital(source->size);
1195 NSPTR(&((*(tpp + i))->data0)), source->size);
1196 j += source->size;
1197 if (0 == (*(tpp + i))->data1.size) {
1204 (resultlen - (*(tpp + i))->data1.size),
1206 (*(tpp + i))->data1.size);
1210 if ((*(tpp + i))->range.size != 0) {
1213 source->size);
1216 (resultlen - (*(tpp + i))->data1.size),
1218 (*(tpp + i))->data1.size);
1226 (source_data + source->size - 1);
1227 m < source->size;
1238 source_data, source->size);
1239 j += source->size;
1241 if (0 == (*(tpp + i))->data1.size) {
1274 (void) memset(table + j, 0, source->size + 1 + resultlen);
1275 (void) memcpy(table + j + source->size + 1 +
1276 (resultlen - default_data->size),
1277 NSPTR(default_data), default_data->size);
1325 pair_size = (source->size + 1 + resultlen);
1335 source_data = malloc_vital(source->size);
1341 (*(tpp + i))->data0.size,
1350 if ((*(tpp + i))->range.size != 0) {
1353 source->size);
1358 (source_data + source->size - 1);
1359 m < source->size;
1370 source->size,
1434 header->size = table_size;
1449 sub_hdr->source_len = source->size;
1461 (*(tpp + i))->data0.size,
1475 (void) memcpy(p, NSPTR(&((*(tpp + i))->data0)), source->size);
1476 p += source->size;
1477 if (0 == (*(tpp + i))->data1.size) {
1484 (resultlen - (*(tpp + i))->data1.size));
1486 (resultlen - (*(tpp + i))->data1.size),
1488 (*(tpp + i))->data1.size);
1491 if ((*(tpp + i))->range.size != 0) {
1494 source->size);
1496 (resultlen - (*(tpp + i))->data1.size));
1498 (resultlen - (*(tpp + i))->data1.size),
1500 (*(tpp + i))->data1.size);
1505 (source_data + source->size - 1);
1506 m < source->size;
1518 source->size,
1532 (void) memcpy(p, source_data, source->size);
1533 p += source->size;
1535 if (0 == (*(tpp + i))->data1.size) {
1568 (void) memcpy(hash_table + j + (resultlen - default_data->size),
1569 NSPTR(default_data), default_data->size);
1618 (source->size + source->size) +
1635 table = (char *)(sub_hdr + 1) + source->size + source->size;
1639 header->size = table_size;
1642 sub_hdr->source_len = (*tpp)->data0.size;
1664 (void) memcpy((char *)(sub_hdr + 1), byte_seq_min, source->size);
1665 (void) memcpy((char *)(sub_hdr + 1) + source->size,
1666 byte_seq_max, source->size);
1671 if (source->size != resultlen) {
1674 "specified, but size does not match\n"));
1682 if (default_data->size <= (sizeof (itm_place_t))) {
1687 (resultlen - default_data->size),
1689 default_data->size);
1696 (resultlen - default_data->size),
1698 default_data->size);
1706 if (0 == (*(tpp + i))->data1.size) {
1710 (*(tpp + i))->data0.size,
1712 k = ((*(tpp + i))->range.size) == 0 ? j :
1714 (*(tpp + i))->data0.size,
1727 if (0 == (*(tpp + i))->data1.size) {
1730 (*(tpp + i))->data0.size,
1732 k = ((*(tpp + i))->range.size) == 0 ? j :
1735 (*(tpp + i))->data0.size,
1748 (*(tpp + i))->data0.size,
1751 if (0 != (*(tpp + i))->range.size)
1754 (*(tpp + i))->range.size,
1758 (void) memset(p, 0, (resultlen - (*(tpp + i))->data1.size));
1759 (void) memcpy(p + (resultlen - (*(tpp + i))->data1.size),
1761 (*(tpp + i))->data1.size);
1914 j = ml->data_pair.data0.size;
1915 if (j < ml->data_pair.data1.size) j = ml->data_pair.data1.size;
1916 if (j < ml->data_pair.range.size) j = ml->data_pair.range.size;
1918 ml->data_pair.data0.size - 1;
1920 ml->data_pair.data1.size - 1;
1922 ml->data_pair.range.size - 1;
1925 if (len < ml->data_pair.data0.size) m -= *c1;
1926 if (len < ml->data_pair.data1.size) m += *c2;
1927 if (len < ml->data_pair.range.size) m += *c3;
1987 assert(0 < pair->range.size);
1988 j = pair->data0.size;
1989 if (j < pair->range.size)
1990 j = pair->range.size;
1991 c1 = ((uchar_t *)(NSPTR(&(pair->data0)))) + pair->data0.size - 1;
1992 c2 = ((uchar_t *)(NSPTR(&(pair->range)))) + pair->range.size - 1;
1995 if (i < pair->range.size) num2 = *c2;
1996 if (i < pair->data0.size) num2 -= *c1;
2138 expr->data.value.size = 0;
2168 if ((sizeof (itm_place_t)) < data->size) {
2170 (void *)(data->place.itm_ptr), data->size,
2209 for (i = 0, num = 0; i < data0->data.value.size; i++, p++) {
2216 for (i = 0, num = 0; i < data1->data.value.size; i++, p++) {
2254 for (i = 0, num = 0; i < data0->data.value.size; i++, p++) {
2279 for (i = 0, num = 0; i < data1->data.value.size; i++, p++) {
2340 if ((sizeof (itm_place_t)) < expr->data.value.size) {
2346 i < expr->data.value.size;
2363 name_to_str(name), name->size, type, name_id));
2365 if (0 == name->size)
2368 if ((name->size != p->name.size) ||
2369 (memcmp(NSPTR(name), NSPTR(&(p->name)), name->size))) {
2408 name_to_str(name), name->size, type, refp, name_id, p));
2457 name_to_str(name), name->size, type, refp, name_id));
2503 if (d0->size < d1->size) {
2504 if (memcmp(NSPTR(d0), NSPTR(d1), d0->size) < 0) {
2509 } else if (d0->size == d1->size) {
2510 return (memcmp(NSPTR(d0), NSPTR(d1), d0->size));
2511 } else /* (d0->size > d1->size) */ {
2512 if (memcmp(NSPTR(d0), NSPTR(d1), d1->size) <= 0) {
2535 if (d0->size == d1->size) {
2536 s = d0->size;
2537 } else if (d0->size < d1->size) {
2538 s = d1->size - d0->size;
2544 s = d0->size;
2546 assert(d0->size > d1->size);
2547 s = d0->size - d1->size;
2553 s = d1->size;
2580 if ((sizeof (itm_place_t)) < data->size) {
2584 i < data->size;