Lines Matching refs:size
91 if ((sizeof (itm_place_t)) < itm_hdr->interpreter.size) {
94 itm_hdr->interpreter.size,
100 if ((sizeof (itm_place_t)) < itm_hdr->type_id.size) {
103 itm_hdr->type_id.size,
150 act->tbl_hdr, act->tbl_hdr->size,
187 tbl->size = (sizeof (itm_tbl_hdr_t)) + (obj_array.num *obj_size);
201 itm_size_t size)
212 obj_array.obj = malloc_vital(hdr_size + (size * obj_array.num));
218 ol; offset += size, ol = ol->next) {
219 (void) memcpy((char *)(obj_array.obj) + offset, ol->obj, size);
303 void *obj, size_t size, itm_place_t *ref,
309 type, name, obj, size, ref, reg_place));
318 refp->size = size;
336 } else if ((NULL != name) && (0 < name->size)) {
385 if (rp->data0.size == 0) {
390 length = rp->data0.size;
392 if ((rp->data0.size != length) ||
393 (rp->data1.size != length)) {
413 table->size = table_size;
448 len_min = ((itm_data_t *)(ol->obj))->size;
451 if (ep->size < len_min) len_min = ep->size;
452 if (ep->size > len_max) len_max = ep->size;
473 table->size = table_size;
484 if ((sizeof (itm_place_t)) < ep->size) {
486 (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) {
671 if (0 == ml->data_pair.data0.size) {
683 if (0 == ml->data_pair.data0.size) {
687 if (ml->data_pair.range.size > 0) {
730 if (0 < ml->data_pair.data0.size) {
735 if (ml->data_pair.range.size > 0) {
740 if (0 == ml->data_pair.data1.size) {
751 if (((*(dp1+0))->range.size != 0) &&
779 "specified, but size does not match\n"));
791 if (0 < (*(tpp + num - 1))->range.size) {
933 map_type_name[i].name, attr->type->size)) {
966 assert((sizeof (itm_place_t)) >= source->size);
968 if ((1 == source->size) &&
975 if (0 < (*(tpp + num - 1))->range.size)
1001 if ((1 == (*tpp)->data0.size) &&
1002 (1 == (*tpp)->data1.size)) {
1008 header->size = table_size;
1011 sub_hdr->source_len = (*tpp)->data0.size;
1036 if (source->size != resultlen) {
1039 "specified, but size does not match\n"));
1055 if (default_data->size <= (sizeof (itm_place_t))) {
1060 (resultlen - default_data->size),
1062 default_data->size);
1069 (resultlen - default_data->size),
1071 default_data->size);
1078 if (0 == (*(tpp + i))->data1.size) {
1083 k = ((*(tpp + i))->range.size) == 0 ? j :
1093 if (0 == (*(tpp + i))->data1.size) {
1097 k = ((*(tpp + i))->range.size) == 0 ? j :
1110 if (0 != (*(tpp + i))->range.size)
1116 (void) memcpy(p + (resultlen - (*(tpp + i))->data1.size),
1118 (*(tpp + i))->data1.size);
1156 ((source->size + 1 + resultlen) * num2));
1159 table_size += (source->size + 1 + resultlen);
1168 header->size = table_size;
1183 sub_hdr->source_len = source->size;
1187 source_data = malloc_vital(source->size);
1191 NSPTR(&((*(tpp + i))->data0)), source->size);
1192 j += source->size;
1193 if (0 == (*(tpp + i))->data1.size) {
1200 (resultlen - (*(tpp + i))->data1.size),
1202 (*(tpp + i))->data1.size);
1206 if ((*(tpp + i))->range.size != 0) {
1209 source->size);
1212 (resultlen - (*(tpp + i))->data1.size),
1214 (*(tpp + i))->data1.size);
1222 (source_data + source->size - 1);
1223 m < source->size;
1234 source_data, source->size);
1235 j += source->size;
1237 if (0 == (*(tpp + i))->data1.size) {
1270 (void) memset(table + j, 0, source->size + 1 + resultlen);
1271 (void) memcpy(table + j + source->size + 1 +
1272 (resultlen - default_data->size),
1273 NSPTR(default_data), default_data->size);
1321 pair_size = (source->size + 1 + resultlen);
1331 source_data = malloc_vital(source->size);
1338 (*(tpp + i))->data0.size,
1347 if ((*(tpp + i))->range.size != 0) {
1350 source->size);
1355 (source_data + source->size - 1);
1356 m < source->size;
1367 hash((char *)source_data, source->size,
1431 header->size = table_size;
1446 sub_hdr->source_len = source->size;
1459 (*(tpp + i))->data0.size,
1473 (void) memcpy(p, NSPTR(&((*(tpp + i))->data0)), source->size);
1474 p += source->size;
1475 if (0 == (*(tpp + i))->data1.size) {
1482 (resultlen - (*(tpp + i))->data1.size));
1484 (resultlen - (*(tpp + i))->data1.size),
1486 (*(tpp + i))->data1.size);
1489 if ((*(tpp + i))->range.size != 0) {
1492 source->size);
1494 (resultlen - (*(tpp + i))->data1.size));
1496 (resultlen - (*(tpp + i))->data1.size),
1498 (*(tpp + i))->data1.size);
1503 (source_data + source->size - 1);
1504 m < source->size;
1516 source->size,
1530 (void) memcpy(p, source_data, source->size);
1531 p += source->size;
1533 if (0 == (*(tpp + i))->data1.size) {
1566 (void) memcpy(hash_table + j + (resultlen - default_data->size),
1567 NSPTR(default_data), default_data->size);
1616 (source->size + source->size) +
1633 table = (char *)(sub_hdr + 1) + source->size + source->size;
1637 header->size = table_size;
1640 sub_hdr->source_len = (*tpp)->data0.size;
1662 (void) memcpy((char *)(sub_hdr + 1), byte_seq_min, source->size);
1663 (void) memcpy((char *)(sub_hdr + 1) + source->size,
1664 byte_seq_max, source->size);
1669 if (source->size != resultlen) {
1672 "specified, but size does not match\n"));
1680 if (default_data->size <= (sizeof (itm_place_t))) {
1685 (resultlen - default_data->size),
1687 default_data->size);
1694 (resultlen - default_data->size),
1696 default_data->size);
1704 if (0 == (*(tpp + i))->data1.size) {
1708 (*(tpp + i))->data0.size,
1710 k = ((*(tpp + i))->range.size) == 0 ? j :
1712 (*(tpp + i))->data0.size,
1725 if (0 == (*(tpp + i))->data1.size) {
1728 (*(tpp + i))->data0.size,
1730 k = ((*(tpp + i))->range.size) == 0 ? j :
1733 (*(tpp + i))->data0.size,
1746 (*(tpp + i))->data0.size,
1749 if (0 != (*(tpp + i))->range.size)
1752 (*(tpp + i))->range.size,
1756 (void) memset(p, 0, (resultlen - (*(tpp + i))->data1.size));
1757 (void) memcpy(p + (resultlen - (*(tpp + i))->data1.size),
1759 (*(tpp + i))->data1.size);
1912 j = ml->data_pair.data0.size;
1913 if (j < ml->data_pair.data1.size) j = ml->data_pair.data1.size;
1914 if (j < ml->data_pair.range.size) j = ml->data_pair.range.size;
1916 ml->data_pair.data0.size - 1;
1918 ml->data_pair.data1.size - 1;
1920 ml->data_pair.range.size - 1;
1923 if (len < ml->data_pair.data0.size) m -= *c1;
1924 if (len < ml->data_pair.data1.size) m += *c2;
1925 if (len < ml->data_pair.range.size) m += *c3;
1985 assert(0 < pair->range.size);
1986 j = pair->data0.size;
1987 if (j < pair->range.size)
1988 j = pair->range.size;
1989 c1 = ((uchar_t *)(NSPTR(&(pair->data0)))) + pair->data0.size - 1;
1990 c2 = ((uchar_t *)(NSPTR(&(pair->range)))) + pair->range.size - 1;
1993 if (i < pair->range.size) num2 = *c2;
1994 if (i < pair->data0.size) num2 -= *c1;
2136 expr->data.value.size = 0;
2165 if ((sizeof (itm_place_t)) < data->size) {
2167 (void *)(data->place.itm_ptr), data->size,
2206 for (i = 0, num = 0; i < data0->data.value.size; i++, p++) {
2213 for (i = 0, num = 0; i < data1->data.value.size; i++, p++) {
2251 for (i = 0, num = 0; i < data0->data.value.size; i++, p++) {
2276 for (i = 0, num = 0; i < data1->data.value.size; i++, p++) {
2337 if ((sizeof (itm_place_t)) < expr->data.value.size) {
2343 i < expr->data.value.size;
2360 name_to_str(name), name->size, type, name_id));
2362 if (0 == name->size)
2365 if ((name->size != p->name.size) ||
2366 (memcmp(NSPTR(name), NSPTR(&(p->name)), name->size))) {
2405 name_to_str(name), name->size, type, refp, name_id, p));
2454 name_to_str(name), name->size, type, refp, name_id));
2500 if (d0->size < d1->size) {
2501 if (memcmp(NSPTR(d0), NSPTR(d1), d0->size) < 0) {
2506 } else if (d0->size == d1->size) {
2507 return (memcmp(NSPTR(d0), NSPTR(d1), d0->size));
2508 } else /* (d0->size > d1->size) */ {
2509 if (memcmp(NSPTR(d0), NSPTR(d1), d1->size) <= 0) {
2532 if (d0->size == d1->size) {
2533 s = d0->size;
2534 } else if (d0->size < d1->size) {
2535 s = d1->size - d0->size;
2541 s = d0->size;
2543 assert(d0->size > d1->size);
2544 s = d0->size - d1->size;
2550 s = d1->size;
2577 if ((sizeof (itm_place_t)) < data->size) {
2581 i < data->size;