?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed.git] / usr / src / cmd / geniconvtbl / itm_util.c
blob0dc9fa48613fed6181604e545e8cc3303331e95d
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright (c) 1999 by Sun Microsystems, Inc.
24 * All rights reserved.
25 * Copyright 2015 PALO, Richard.
26 */
27 #include <assert.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <ctype.h>
31 #include <libintl.h>
32 #include <strings.h>
33 #include "iconv_tm.h"
34 #include "itmcomp.h"
35 #include "itm_util.h"
36 #include "hash.h"
37 #include "maptype.h"
38
39
40 static size_t map_table_resultlen(itmc_map_t *);
41 static int data_pair_compare(itmc_data_pair_t **, itmc_data_pair_t **);
42 static long data_to_long(itm_data_t *);
43
44 static itm_tbl_hdr_t *map_table_indexed_fixed(itmc_data_pair_t **,
45 itm_size_t, itm_data_t *, long, itm_num_t);
46 static itm_tbl_hdr_t *map_table_dense_encoding(itmc_data_pair_t **,
47 itm_size_t, itm_data_t *, unsigned long,
48 unsigned char *, unsigned char *, long,
49 itm_num_t);
50 static itm_tbl_hdr_t *map_table_lookup_fixed(itmc_data_pair_t **,
51 itm_size_t, itm_data_t *, long, itm_size_t);
52 static itm_tbl_hdr_t *map_table_hash(itmc_data_pair_t **, itm_size_t,
53 itm_data_t *, long, long, itm_size_t,
54 itm_num_t);
55 static itm_tbl_hdr_t *map_table_lookup_var();
56 static void put_dense_encoding_default(char *, unsigned char *,
57 unsigned char *, unsigned char *, long, long, long);
58 static size_t map_table_resultlen(itmc_map_t *);
59 static void map_range_adjust_byte_seq(unsigned char *,
60 unsigned char *, long, itmc_data_pair_t *);
61 static void map_range_make_result(char *, itm_size_t, itm_size_t,
62 char *, itm_size_t);
63 static size_t map_table_num_range(itmc_data_pair_t *);
64 static itmc_map_type_t check_map_type(itmc_map_attr_t *);
65
66
67 static itmc_name_t *name_lookup(itm_data_t *, itm_type_t);
68 static itmc_name_t *name_refer(itm_data_t *, itm_type_t, itmc_ref_t *);
69 static itmc_name_t *name_register(itm_data_t *, itm_type_t, itmc_ref_t *);
70 static void op_hirarchy(itm_tbl_hdr_t *, itmc_obj_t *);
71 static obj_array_t obj_list_to_array(itm_size_t, itmc_obj_t *, itm_size_t);
72
73
74 void
75 itm_def_process(itm_data_t *itm_name)
76 {
77 itm_hdr_t *itm_hdr;
78 long len;
79
80 TRACE_MESSAGE('y', ("itm_def_process\n"));
81
82
83 itm_hdr = malloc_vital(sizeof (itm_hdr_t));
84 (void) memset(itm_hdr, 0, sizeof (itm_hdr_t));
85
86 if ((NULL != cmd_opt.interpreter) &&
87 (0 < (len = strlen(cmd_opt.interpreter)))) {
88 itm_hdr->interpreter = *(str_to_data(len, cmd_opt.interpreter));
89 }
90 if ((sizeof (itm_place_t)) < itm_hdr->interpreter.size) {
91 (void) obj_register(ITMC_OBJ_STRING, NULL,
92 (void *)itm_hdr->interpreter.place.itm_ptr,
93 itm_hdr->interpreter.size,
94 &(itm_hdr->interpreter.place),
95 OBJ_REG_HEAD);
96 }
97
98 itm_hdr->type_id = *itm_name;
99 if ((sizeof (itm_place_t)) < itm_hdr->type_id.size) {
100 (void) obj_register(ITMC_OBJ_STRING, NULL,
101 (void *)itm_hdr->type_id.place.itm_ptr,
102 itm_hdr->type_id.size,
103 &(itm_hdr->type_id.place),
104 OBJ_REG_HEAD);
105 }
106
107 (void) assemble(itm_hdr);
108 }
109
110
111
112 itmc_obj_t *
113 direction_unit(
114 itmc_ref_t *cond,
115 itm_data_t *cond_name,
116 itmc_action_t *act,
117 itm_data_t *act_name)
118 {
119 itmc_obj_t *du;
120 itm_direc_t *direc;
121
122 du = malloc_vital(sizeof (itmc_obj_t));
123 du->type = ITMC_OBJ_DIREC;
124 du->name = NULL;
125 du->obj = direc = malloc_vital(sizeof (itm_direc_t));
126
127 if (NULL != cond) {
128 direc->condition.itm_ptr = (uintptr_t)NULL;
129 cond->referencer = &(direc->condition);
130 du->ref[0] = cond;
131 } else if (NULL != cond_name) {
132 direc->condition.itm_ptr = (itm_place2_t)(cond_name);
133 du->ref[0] = obj_register(ITMC_OBJ_COND, cond_name, NULL, 0,
134 &(direc->condition), OBJ_REG_TAIL);
135 } else {
136 direc->condition.itm_ptr = 0;
137 du->ref[0] = NULL;
138 }
139
140
141 if (NULL != act_name) {
142 direc->action.itm_ptr = (itm_place2_t)(act_name);
143 du->ref[1] = obj_register(ITMC_OBJ_ACTION, act_name, NULL, 0,
144 &(direc->action), OBJ_REG_TAIL);
145 } else if (NULL != act && act->tbl_hdr != NULL) {
146 direc->action.itm_ptr = (itm_place2_t)(act->tbl_hdr);
147 du->ref[1] = obj_register(act->type,
148 (itm_data_t *)(act->tbl_hdr->name.itm_ptr),
149 act->tbl_hdr, act->tbl_hdr->size,
150 &(direc->action), OBJ_REG_TAIL);
151 } else {
152 return (NULL);
153 }
154
155 du->ref[2] = NULL;
156 return (du);
157 }
158
159
160
161 itm_tbl_hdr_t *
162 obj_table(itm_type_t tbl_type,
163 itm_data_t *name,
164 itmc_obj_t *obj_list,
165 itm_size_t obj_size)
166 {
167 itm_tbl_hdr_t *tbl;
168 obj_array_t obj_array;
169
170 obj_array = obj_list_to_array(sizeof (itm_tbl_hdr_t),
171 obj_list, obj_size);
172 tbl = obj_array.obj;
173
174 tbl->type = tbl_type;
175 if (name) {
176 #if !defined(_LP64)
177 tbl->name.itm_pad = 0;
178 #endif
179 tbl->name.itm_ptr = (itm_place2_t)name;
180 } else {
181 #if !defined(_LP64)
182 tbl->name.itm_pad = 0;
183 #endif
184 tbl->name.itm_ptr = (uintptr_t)NULL;
185 }
186 tbl->size = (sizeof (itm_tbl_hdr_t)) + (obj_array.num *obj_size);
187 tbl->number = obj_array.num;
188
189 if ((ITM_TBL_MASK&tbl->type) == ITM_TBL_OP) {
190 op_hirarchy(tbl, obj_list);
191 }
192 return (tbl);
193 }
194
195 /*
196 *
197 */
198 static obj_array_t
199 obj_list_to_array(itm_size_t hdr_size, itmc_obj_t *obj_list,
200 itm_size_t size)
201 {
202 obj_array_t obj_array;
203 itm_size_t offset;
204 itmc_obj_t *ol;
205
206 for (obj_array.num = 0, ol = obj_list;
207 ol; obj_array.num += 1, ol = ol->next) {
208 /* NOP */;
209 }
210
211 obj_array.obj = malloc_vital(hdr_size + (size * obj_array.num));
212
213 if (obj_array.num == 0)
214 return (obj_array);
215
216 for (offset = hdr_size, ol = obj_list;
217 ol; offset += size, ol = ol->next) {
218 (void) memcpy((char *)(obj_array.obj) + offset, ol->obj, size);
219 if (ol->ref[0]) {
220 ol->ref[0]->referencer =
221 (void *)((char *)(ol->ref[0]->referencer) +
222 ((char *)(obj_array.obj) -
223 (char *)(ol->obj) + offset));
224 }
225 if (ol->ref[1]) {
226 ol->ref[1]->referencer =
227 (void *)((char *)(ol->ref[1]->referencer) +
228 ((char *)(obj_array.obj) -
229 (char *)(ol->obj) + offset));
230 }
231 if (ol->ref[2]) {
232 ol->ref[2]->referencer =
233 (void *)((char *)(ol->ref[2]->referencer) +
234 ((char *)(obj_array.obj) -
235 (char *)(ol->obj) + offset));
236 }
237 }
238
239 return (obj_array);
240 }
241
242 static void
243 op_hirarchy(itm_tbl_hdr_t *optbl,
244 itmc_obj_t *obj_list)
245 {
246 itm_op_outer_t *o;
247 itm_op_inner_t *in;
248 itmc_obj_t *ol;
249
250 TRACE_MESSAGE('l', ("op_hirarchy (optbl=%x)\n", optbl));
251 o = malloc_vital(sizeof (itm_op_outer_t));
252 o->link = itm_op_outer;
253 itm_op_outer = o;
254 o->in = NULL;
255 o->optbl = optbl;
256
257 for (ol = obj_list; ol != NULL; ol = ol->next) {
258 if ((ol->type == ITMC_OBJ_OP) &&
259 (((itm_op_t *)ol->obj)->type == ITM_OP_OPERATION)) {
260 in = malloc_vital(sizeof (itm_op_inner_t));
261 in->in = o->in;
262 o->in = in;
263 TRACE_MESSAGE('L', ("o->in(%x) in->in(%x)\n",
264 o->in, in->in));
265 in->ref = ol->ref[0];
266 }
267 }
268
269 #ifdef ENABLE_TRACE
270 for (in = o->in; in != NULL; in = in->in) {
271 TRACE_MESSAGE('L', ("o=%x in=%x in->in=%x\n",
272 o, in, in->in));
273 TRACE_MESSAGE('L', ("o(table)%x->in(ref)=%x\n",
274 o->optbl, in->ref));
275 }
276 #endif
277
278 }
279
280 itmc_obj_t *
281 obj_list_append(itmc_obj_t *obj_list, itmc_obj_t *obj)
282 {
283 if (0 == obj) {
284 return (obj_list);
285 }
286
287 obj->next = NULL;
288 obj->last = obj;
289
290 if (obj_list) {
291 obj_list->last->next = obj;
292 obj_list->last = obj;
293 return (obj_list);
294 } else {
295 return (obj);
296 }
297 }
298
299
300 itmc_ref_t *
301 obj_register(itm_type_t type, itm_data_t *name,
302 void *obj, size_t size, itm_place_t *ref,
303 itm_type_t reg_place)
304 {
305 itmc_ref_t *refp;
306
307 TRACE_MESSAGE('O', ("obj_register: %6ld %08p %08p %08ld %08p %ld\n",
308 type, name, obj, size, ref, reg_place));
309
310 refp = malloc_vital(sizeof (itmc_ref_t));
311 refp->name = NULL;
312 refp->referencee = obj;
313 #if !defined(_LP64)
314 refp->reloc.itm_pad = 0;
315 #endif
316 refp->reloc.itm_ptr = 0;
317 refp->size = size;
318 refp->referencer = ref;
319 refp->next = NULL;
320
321 if (NULL == obj) { /* reference to named object */
322 if (NULL == name) {
323 if (0 == error_deferred) {
324 /* should never happen */
325 itm_error(
326 gettext("internal error: "
327 "obj_register: (NULL == obj) "
328 "&& (NULL == name)\n"));
329 exit(ITMC_STATUS_SYS2);
330 }
331 return (NULL);
332 }
333 refp->name = name_refer(name, type, refp);
334 return (refp);
335 } else if ((NULL != name) && (0 < name->size)) {
336 /* definition of named object */
337 refp->name = name_register(name, type, refp);
338 }
339
340 if ((ITMC_OBJ_FIRST <= type) && (type <= ITMC_OBJ_LAST)) {
341 switch (reg_place) {
342 case OBJ_REG_HEAD:
343 refp->next = ref_first[type];
344 ref_first[type] = refp;
345 if (NULL == ref_last[type]) {
346 ref_last[type] = refp;
347 }
348 break;
349 case OBJ_REG_TAIL:
350 if (ref_first[type]) {
351 ref_last[type]->next = refp;
352 } else {
353 ref_first[type] = refp;
354 }
355 ref_last[type] = refp;
356 break;
357 }
358 } else {
359 itm_error(gettext("obj_register: illegal object type\n"));
360 exit(ITMC_STATUS_SYS2);
361 }
362
363 return (refp);
364 }
365
366
367 itm_tbl_hdr_t *
368 range_table(itm_data_t *name, itmc_obj_t *obj_list)
369 {
370 itm_num_t num;
371 itmc_obj_t *ol;
372 itmc_data_pair_t *rp;
373 itm_range_hdr_t *rh;
374 itm_tbl_hdr_t *table;
375 itm_size_t length = 0;
376 itm_num_t i;
377 char *p;
378 itm_size_t table_size;
379
380 /* count range, determine length */
381 for (num = 0, ol = obj_list; ol; ol = ol->next, num++) {
382 rp = (itmc_data_pair_t *)(ol->obj);
383 if (length == 0) {
384 if (rp->data0.size == 0) {
385 itm_error(gettext("between has null range\n"));
386 error_deferred += 1;
387 return (NULL);
388 }
389 length = rp->data0.size;
390 }
391 if ((rp->data0.size != length) ||
392 (rp->data1.size != length)) {
393 itm_error(gettext(
394 "length of source sequences must be the same\n"));
395 error_deferred += 1;
396 return (NULL);
397 }
398 }
399 if (num == 0) {
400 itm_error(gettext("between has no ranges\n"));
401 error_deferred += 1;
402 return (NULL);
403 }
404 table_size = ((sizeof (itm_tbl_hdr_t)) +
405 (sizeof (itm_range_hdr_t)) + (length * num) * 2);
406 table_size = ITMROUNDUP(table_size);
407
408 table = malloc_vital(table_size);
409 table->type = ITM_TBL_RANGE;
410 if (NULL != name)
411 table->name.itm_ptr = (itm_place2_t)name;
412 table->size = table_size;
413 table->number = num;
414
415 rh = (itm_range_hdr_t *)(table + 1);
416 rh->len = length;
417
418 p = (char *)(rh + 1);
419 for (ol = obj_list, i = 0; ol; ol = ol->next, i++) {
420 rp = (itmc_data_pair_t *)(ol->obj);
421 (void) memcpy(p, (NSPTR(&(rp->data0))), length);
422 p += length;
423 (void) memcpy(p, (NSPTR(&(rp->data1))), length);
424 p += length;
425 }
426
427 return (table);
428 }
429
430 /*
431 * escape sequence table for stateful code set sequence
432 */
433 itm_tbl_hdr_t *
434 escseq_table(itm_data_t *name, itmc_obj_t *obj_list)
435 {
436 itm_num_t num;
437 itmc_obj_t *ol;
438 itm_data_t *ep;
439 itm_escapeseq_hdr_t *eh;
440 itm_tbl_hdr_t *table;
441 itm_size_t len_max = 0;
442 itm_size_t len_min;
443 itm_num_t i;
444 itm_size_t table_size;
445
446 ol = obj_list;
447 len_min = ((itm_data_t *)(ol->obj))->size;
448 for (num = 0; NULL != ol; ol = ol->next, num++) {
449 ep = (itm_data_t *)(ol->obj);
450 if (ep->size < len_min) len_min = ep->size;
451 if (ep->size > len_max) len_max = ep->size;
452 }
453 if (num == 0) {
454 itm_error(gettext
455 ("escape sequence is defined without sequence\n"));
456 error_deferred += 1;
457 return (NULL);
458 } else if (0 == len_min) {
459 itm_error(gettext("null sequence\n"));
460 error_deferred += 1;
461 return (NULL);
462 }
463
464 table_size = ((sizeof (itm_tbl_hdr_t)) +
465 (sizeof (itm_escapeseq_hdr_t)) +
466 (sizeof (itm_data_t) * num));
467 table_size = ITMROUNDUP(table_size);
468 table = malloc_vital(table_size);
469 table->type = ITM_TBL_ESCAPESEQ;
470 if (NULL != name)
471 table->name.itm_ptr = (itm_place2_t)name;
472 table->size = table_size;
473 table->number = num;
474
475 eh = (itm_escapeseq_hdr_t *)(table + 1);
476 eh->len_max = len_max;
477 eh->len_min = len_min;
478
479 for (ol = obj_list, ep = (itm_data_t *)(eh + 1);
480 ol != NULL;
481 ol = ol->next, ep++) {
482 *ep = *((itm_data_t *)(ol->obj));
483 if ((sizeof (itm_place_t)) < ep->size) {
484 (void) obj_register(ITMC_OBJ_DATA, NULL,
485 (void *)(ep->place.itm_ptr), ep->size,
486 &(ep->place), OBJ_REG_TAIL);
487 }
488 }
489 (void) qsort((itm_data_t *)(eh + 1), num, sizeof (itm_data_t),
490 (int (*)(const void *, const void *))data_compare);
491
492 for (i = 0, ep = (itm_data_t *)(eh + 1);
493 i < num - 1;
494 i++, ep++) {
495 if (0 <= data_compare(ep, (ep + 1))) {
496 itm_error(
497 gettext(
498 "same escape sequences are defined: "
499 "0x%1$s 0x%2$s\n"),
500 data_to_hexadecimal(ep),
501 data_to_hexadecimal(ep + 1));
502 error_deferred += 1;
503 return (NULL);
504 }
505 }
506 return (table);
507 }
508
509
510
511
512 itm_tbl_hdr_t *
513 map_table(itm_data_t *name, itmc_map_t *map_list,
514 itmc_map_attr_t *attr)
515 {
516 itm_size_t num;
517 itm_size_t num2;
518 itmc_map_t *ml;
519 itmc_data_pair_t **tpp;
520 itm_tbl_hdr_t *table;
521 long source_len = 0;
522 long result_len = 0;
523 long source_fixed_len = 1;
524 long pass_through = 0;
525 long default_count = 0;
526 itm_data_t *default_data = NULL;
527 long error_deferred_local = 0;
528 unsigned long dense_encoded_map_ent;
529 unsigned long simple_indexed_map_ent;
530 itm_size_t source_start;
531 itm_size_t source_end;
532 unsigned long u;
533 unsigned char *byte_seq_min;
534 unsigned char *byte_seq_max;
535 unsigned char *p;
536 long i;
537 itmc_map_type_t map_type = ITMC_MAP_UNKNOWN;
538 itmc_map_name_type_t *map_name_type;
539 long hash_factor;
540 long result_len_specfied = 0;
541 size_t j;
542 long n;
543 itmc_data_pair_t **dp1;
544 itm_num_t error_count = 0;
545
546 if (attr != NULL) {
547 map_type = check_map_type(attr);
548 }
549 if (ITMC_MAP_UNKNOWN == map_type) {
550 map_type = ITMC_MAP_AUTOMATIC;
551 }
552 hash_factor = ((NULL != attr) && (attr->hash_factor != 0)) ?
553 attr->hash_factor :
554 200;
555
556 map_name_type = cmd_opt.map_name_type;
557 for (; map_name_type; map_name_type = map_name_type->next) {
558 if ('\0' == *(map_name_type->name)) {
559 map_type = map_name_type->type;
560 hash_factor = map_name_type->hash_factor;
561 break;
562 }
563 }
564 map_name_type = cmd_opt.map_name_type;
565 if ((NULL != name) && (NULL != cmd_opt.map_name_type)) {
566 p = NSPTR(name);
567 for (; map_name_type; map_name_type = map_name_type->next) {
568 if (0 == strcmp(map_name_type->name, (char *)p)) {
569 map_type = map_name_type->type;
570 hash_factor = map_name_type->hash_factor;
571 break;
572 }
573 }
574 }
575
576 if (NULL != attr) {
577 if (MAXSEQUENCE < attr->resultlen) {
578 itm_error(
579 gettext("output_byte_length must be less than %1$d\n"),
580 MAXSEQUENCE);
581 error_deferred += 1;
582 return (NULL);
583 }
584 result_len_specfied = attr->resultlen;
585 } else {
586 result_len_specfied = 0;
587 }
588
589 for (num = 0, ml = map_list; ml; ml = ml->next, num++) {
590
591 /* default */
592 if (0 == ml->data_pair.data0.size) {
593 if (0 == ml->data_pair.data1.size) {
594 pass_through += 1;
595 default_data = (itm_data_t *)(-1);
596 } else {
597 default_count += 1;
598 default_data = &(ml->data_pair.data1);
599 }
600 --num;
601
602
603 } else if (0 == ml->data_pair.data1.size) {
604 /* error source sequence */
605 continue;
606 }
607
608 /* fixed length */
609 if ((0 < source_len) &&
610 (0 < ml->data_pair.data0.size) &&
611 (source_len != ml->data_pair.data0.size)) {
612 source_fixed_len = 0;
613 }
614
615 /* maximum length */
616 if (source_len < ml->data_pair.data0.size) {
617 source_len = ml->data_pair.data0.size;
618 }
619 if (result_len < ml->data_pair.data1.size) {
620 result_len = ml->data_pair.data1.size;
621 }
622
623 /* map source has range */
624 if (0 < ml->data_pair.range.size) {
625 if (ml->data_pair.range.size !=
626 ml->data_pair.data0.size) {
627 itm_error(
628 gettext("length of source range must be "
629 "the same: 0x%1$s 0x%2$s\n"),
630 data_to_hexadecimal(&(ml->data_pair.data0)),
631 data_to_hexadecimal(
632 &(ml->data_pair.range)));
633 error_deferred += 1;
634 return (NULL);
635 }
636 if (0 <= data_compare(&(ml->data_pair.data0),
637 &((ml->data_pair.range)))) {
638 itm_error(
639 gettext("source range error: 0x%1$s 0x%2$s\n"),
640 data_to_hexadecimal(
641 &(ml->data_pair.data0)),
642 data_to_hexadecimal(
643 &(ml->data_pair.range)));
644 error_deferred += 1;
645 return (NULL);
646 }
647 j = map_table_resultlen(ml);
648 if (result_len < j) {
649 result_len = j;
650 }
651 }
652 }
653 if (num == 0) {
654 itm_error(
655 gettext("no mapping pair\n"));
656 error_deferred += 1;
657 return (NULL);
658 }
659
660 if (0 != result_len_specfied) {
661 if (result_len > result_len_specfied) {
662 itm_error(
663 gettext("result value length is "
664 "over specifed output_byte_length(%1$ld)\n"),
665 result_len_specfied);
666 error_deferred += 1;
667 return (NULL);
668 }
669 result_len = result_len_specfied;
670 }
671 byte_seq_min = malloc_vital((sizeof (unsigned char)) * source_len);
672 byte_seq_max = malloc_vital((sizeof (unsigned char)) * source_len);
673 for (num = 0, ml = map_list; ml; ml = ml->next, num++) {
674 if (0 == ml->data_pair.data0.size) {
675 continue;
676 }
677
678 p = (unsigned char *)(NSPTR(&((ml->data_pair).data0)));
679 for (i = 0; i < source_len; i++) {
680 *(byte_seq_min + i) = *(p + i);
681 *(byte_seq_max + i) = *(p + i);
682 }
683 break;
684 }
685 for (num = 0, ml = map_list; ml; ml = ml->next, num++) {
686 if (0 == ml->data_pair.data0.size) {
687 num--;
688 continue;
689 }
690 if (ml->data_pair.range.size > 0) {
691 map_range_adjust_byte_seq(byte_seq_min, byte_seq_max,
692 source_len, &(ml->data_pair));
693 } else {
694 p = (unsigned char *)(NSPTR(&((ml->data_pair).data0)));
695 for (i = 0; i < source_len; i++) {
696 if (*(p + i) < *(byte_seq_min + i)) {
697 *(byte_seq_min + i) = *(p + i);
698 }
699 if (*(byte_seq_max + i) < *(p + i)) {
700 *(byte_seq_max + i) = *(p + i);
701 }
702 }
703 }
704 }
705 for (dense_encoded_map_ent = 1, i = 0; i < source_len; i++) {
706 u = dense_encoded_map_ent;
707 dense_encoded_map_ent *=
708 (*(byte_seq_max + i) - *(byte_seq_min + i) + 1);
709 if (dense_encoded_map_ent < u) {
710 dense_encoded_map_ent = (ulong_t)(~0);
711 break;
712 }
713 }
714 #if defined(DEBUG)
715 if (TRACE('m')) {
716 int i;
717 TRACE_MESSAGE('m', ("map_table: ent=%lu num=%lu ",
718 dense_encoded_map_ent, num));
719 TRACE_MESSAGE('m', ("byte_seq_min=0x"));
720 for (i = 0; i < source_len; i++) {
721 TRACE_MESSAGE('m', ("%02x", *(byte_seq_min + i)));
722 }
723 TRACE_MESSAGE('m', (" byte_seq_max=0x"));
724 for (i = 0; i < source_len; i++) {
725 TRACE_MESSAGE('m', ("%02x", *(byte_seq_max + i)));
726 }
727 TRACE_MESSAGE('m', ("\n"));
728 }
729 #endif /* DEBUG */
730
731 tpp = malloc_vital((sizeof (itmc_data_pair_t *)) * num);
732 for (num = 0, num2 = 0, ml = map_list; ml; ml = ml->next) {
733 if (0 < ml->data_pair.data0.size) {
734 itm_num_t range_num;
735 *(tpp + num) = &(ml->data_pair);
736 num++;
737 range_num = 1;
738 if (ml->data_pair.range.size > 0) {
739 range_num +=
740 map_table_num_range(&(ml->data_pair));
741 }
742 num2 += range_num;
743 if (0 == ml->data_pair.data1.size) {
744 /* specified error sequence */
745 error_count += range_num;
746 }
747 }
748 }
749 (void) qsort(tpp, num, sizeof (itmc_data_pair_t *),
750 (int (*)(const void *, const void *))data_pair_compare);
751
752 /* check if map_pair range and next map_pair are overrapped */
753 for (n = 0, dp1 = tpp; n < (num-1); n++, dp1++) {
754 if (((*(dp1+0))->range.size != 0) &&
755 (0 <= data_compare(&((*(dp1+0))->range),
756 &((*(dp1+1))->data0)))) {
757 itm_error(
758 gettext("ranges of source sequences "
759 "overrapped: %1$s %2$s\n"),
760 data_to_hexadecimal(&((*(dp1+0))->range)),
761 data_to_hexadecimal(&((*(dp1+1))->data0)));
762 error_deferred += 1;
763 return (NULL);
764 }
765 }
766
767 if (1 < default_count) {
768 itm_error(
769 gettext("default is specified %1$d times in a map\n"),
770 default_count);
771 error_deferred_local += 1;
772 }
773 if ((1 == default_count) && (!source_fixed_len)) {
774 itm_error(
775 gettext("default is specified,"
776 " but length of source data is not fixed\n"));
777 error_deferred_local += 1;
778 }
779 if ((1 <= pass_through) && (source_len != result_len)) {
780 itm_error(
781 gettext("\"default no_change_copy\" is "
782 "specified, but size does not match\n"));
783 error_deferred_local += 1;
784 }
785
786 if (error_deferred_local) {
787 error_deferred += error_deferred_local;
788 return (NULL);
789 }
790
791 if (source_fixed_len) {
792 source_start = data_to_long(&((*(tpp + 0))->data0));
793 source_end = data_to_long(&((*(tpp + num - 1))->data0));
794 if (0 < (*(tpp + num - 1))->range.size) {
795 source_end = data_to_long(&((*(tpp + num - 1))->range));
796 }
797
798 simple_indexed_map_ent = source_end - source_start + 1;
799
800 TRACE_MESSAGE('m', ("map_table: simple_indexed_map_ent=%lu\n",
801 simple_indexed_map_ent));
802
803 switch (map_type) {
804 case ITMC_MAP_AUTOMATIC:
805 if ((source_len <= 2) &&
806 (((ulong_t)(~0) == dense_encoded_map_ent) ||
807 (simple_indexed_map_ent <
808 (dense_encoded_map_ent * 2)))) {
809 /*
810 * for small source sequence,
811 * if dense table is not so large
812 * compared with simple table,
813 * use simple.
814 */
815 map_type = ITMC_MAP_SIMPLE_INDEX;
816 } else if (cmd_opt.large_table) {
817 if ((sizeof (long)) < source_len) {
818 itm_error(
819 gettext("length of source is too long "
820 "for large table: %ld\n"),
821 source_len);
822 error_deferred += 1;
823 return (NULL);
824 }
825 map_type = ITMC_MAP_SIMPLE_INDEX;
826 } else if (((ulong_t)(~0) == dense_encoded_map_ent) ||
827 ((0xffff < dense_encoded_map_ent) &&
828 ((num2 * 8) < dense_encoded_map_ent))) {
829 /*
830 * if dense can be used and not too large
831 * ( less than (hash table entry * 8),
832 * use dense.
833 */
834 map_type = ITMC_MAP_SIMPLE_HASH;
835 } else {
836 map_type = ITMC_MAP_DENSE_ENCODING;
837 }
838 break;
839 case ITMC_MAP_SIMPLE_INDEX:
840 if ((sizeof (long)) < source_len) {
841 itm_error(
842 gettext("length of source is too long "
843 "for index lookup: %ld\n"),
844 source_len);
845 error_deferred += 1;
846 return (NULL);
847 }
848 break;
849 case ITMC_MAP_SIMPLE_HASH:
850 for (i = 2, u = 256; i < (sizeof (long)); i++) {
851 u *= 256;
852 }
853 if (u < num2) {
854 itm_error(
855 gettext("map is too large for hashing: %lu\n"),
856 num2);
857 error_deferred += 1;
858 return (NULL);
859 }
860 break;
861 case ITMC_MAP_DENSE_ENCODING:
862 for (i = 2, u = 256; i < (sizeof (long)); i++) {
863 u *= 256;
864 }
865 if (u < dense_encoded_map_ent) {
866 itm_error(
867 gettext(
868 "map is too large for dense encoding: "
869 "%lu\n"),
870 dense_encoded_map_ent);
871 error_deferred += 1;
872 return (NULL);
873 }
874 break;
875 case ITMC_MAP_BINARY_SEARCH:
876 for (i = 2, u = 256; i < (sizeof (long)); i++) {
877 u *= 256;
878 }
879 if (u < num2) {
880 itm_error(
881 gettext("length of source is too long for "
882 "binary search: %ld\n"),
883 source_len);
884 error_deferred += 1;
885 return (NULL);
886 }
887 break;
888 default:
889 break;
890 }
891 switch (map_type) {
892 case ITMC_MAP_SIMPLE_INDEX:
893 table = map_table_indexed_fixed(
894 tpp, num, default_data,
895 result_len, error_count);
896 break;
897 case ITMC_MAP_SIMPLE_HASH:
898 table = map_table_hash(tpp, num, default_data,
899 hash_factor, result_len, num2,
900 error_count);
901 break;
902 case ITMC_MAP_DENSE_ENCODING:
903 table = map_table_dense_encoding(tpp, num,
904 default_data,
905 dense_encoded_map_ent,
906 byte_seq_min, byte_seq_max,
907 result_len, error_count);
908 break;
909 case ITMC_MAP_BINARY_SEARCH:
910 table = map_table_lookup_fixed(tpp, num,
911 default_data,
912 result_len, num2);
913 break;
914 }
915 } else {
916 table = map_table_lookup_var();
917 }
918
919 if ((NULL != name) && (NULL != table)) {
920 table->name.itm_ptr = (itm_place2_t)name;
921 }
922
923 return (table);
924 }
925
926
927 static itmc_map_type_t
928 check_map_type(itmc_map_attr_t *attr)
929 {
930 int i;
931
932 if (NULL == attr->type) {
933 return (0);
934 }
935 for (i = 0; NULL != map_type_name[i].name; i++) {
936 if (0 == strncmp(((char *)&(attr->type->place)),
937 map_type_name[i].name, attr->type->size)) {
938 return (map_type_name[i].type);
939 }
940 }
941 return (0);
942 }
943
944
945 static itm_tbl_hdr_t *
946 map_table_indexed_fixed(
947 itmc_data_pair_t **tpp,
948 itm_size_t num,
949 itm_data_t *default_data,
950 long resultlen,
951 itm_num_t error_count)
952 {
953 itm_tbl_hdr_t *header;
954 itm_map_idx_fix_hdr_t *sub_hdr;
955 char *table;
956 char *error_table;
957 itm_size_t source_start;
958 itm_size_t source_end;
959 itm_size_t entry_num;
960 itm_size_t table_size;
961 itm_size_t j;
962 itm_size_t i;
963 itm_size_t k;
964 char *p;
965 itm_data_t *source;
966
967 TRACE_MESSAGE('m', ("map_table_range : %ld\n", num));
968
969 source = &((*(tpp + 0))->data0);
970 assert((sizeof (itm_place_t)) >= source->size);
971
972 if ((1 == source->size) &&
973 (1 == resultlen)) {
974 source_start = 0;
975 source_end = 255;
976 } else {
977 source_start = data_to_long(&((*(tpp + 0))->data0));
978 source_end = data_to_long(&((*(tpp + num - 1))->data0));
979 if (0 < (*(tpp + num - 1))->range.size)
980 source_end = data_to_long(&((*(tpp + num - 1))->range));
981 }
982
983 entry_num = source_end - source_start + 1;
984
985 table_size = ((sizeof (itm_tbl_hdr_t)) +
986 (sizeof (itm_map_idx_fix_hdr_t)) +
987 (resultlen * entry_num));
988 if (0 < error_count) {
989 table_size += entry_num;
990 }
991 if (NULL == default_data) {
992 if ((num < entry_num) ||
993 (error_count <= 0)) {
994 table_size += entry_num;
995 }
996 } else if ((itm_data_t *)(-1) != default_data) {
997 table_size += resultlen;
998 }
999
1000 table_size = ITMROUNDUP(table_size);
1001 header = malloc_vital(table_size);
1002 sub_hdr = (itm_map_idx_fix_hdr_t *)(header + 1);
1003 table = (char *)(sub_hdr + 1);
1004
1005 if ((1 == (*tpp)->data0.size) &&
1006 (1 == (*tpp)->data1.size)) {
1007 header->type = ITM_TBL_MAP_INDEX_FIXED_1_1;
1008 } else {
1009 header->type = ITM_TBL_MAP_INDEX_FIXED;
1010 }
1011 header->name.itm_ptr = 0;
1012 header->size = table_size;
1013 header->number = entry_num;
1014
1015 sub_hdr->source_len = (*tpp)->data0.size;
1016 sub_hdr->result_len = resultlen;
1017 sub_hdr->start.itm_ptr = source_start;
1018 sub_hdr->end.itm_ptr = source_end;
1019 sub_hdr->error_num = error_count; /* > 0; so pad4 = 0 */
1020
1021 if (NULL != default_data) {
1022 if ((itm_data_t *)(-1) == default_data) {
1023 sub_hdr->default_error = -1;
1024 #if !defined(_LP64)
1025 sub_hdr->pad3_num = (pad_t)(~0);
1026 #endif
1027 } else {
1028 sub_hdr->default_error = 0;
1029 }
1030 } else {
1031 if (num < entry_num) {
1032 sub_hdr->default_error = 1;
1033 } else {
1034 sub_hdr->default_error = 2;
1035 }
1036 }
1037
1038 error_table = (table + (resultlen * entry_num));
1039 if (-1 == sub_hdr->default_error) {
1040 if (source->size != resultlen) {
1041 itm_error(
1042 gettext("\"default no_change_copy\" is "
1043 "specified, but size does not match\n"));
1044 exit(ITMC_STATUS_BT);
1045 }
1046
1047 for (i = 0, j = 0;
1048 i < (entry_num);
1049 i++, j += resultlen) {
1050 for (k = 0; k < resultlen; k++) {
1051 *(table + j + k) =
1052 (((source_start + i) >>
1053 ((resultlen - k - 1) * 8)) &
1054 0x00ff);
1055 }
1056 }
1057 } else if (0 == sub_hdr->default_error) {
1058 error_table += resultlen;
1059 if (default_data->size <= (sizeof (itm_place_t))) {
1060 for (i = 0, j = 0;
1061 i < (entry_num + 1); /* last one is for default */
1062 i++, j += resultlen) {
1063 (void) memcpy(table + j +
1064 (resultlen - default_data->size),
1065 (void *)(&(default_data->place.itm_64d)),
1066 default_data->size);
1067 }
1068 } else {
1069 for (i = 0, j = 0;
1070 i < (entry_num + 1); /* last one is for default */
1071 i++, j += resultlen) {
1072 (void) memcpy(table + j +
1073 (resultlen - default_data->size),
1074 (void *)(default_data->place.itm_ptr),
1075 default_data->size);
1076 }
1077 }
1078 }
1079 if (1 == sub_hdr->default_error) {
1080 (void) memset(error_table, 1, entry_num);
1081 for (i = 0; i < num; i++) {
1082 if (0 == (*(tpp + i))->data1.size) {
1083 continue; /* error sequence */
1084 }
1085 j = data_to_long(&((*(tpp + i))->data0)) -
1086 source_start;
1087 k = ((*(tpp + i))->range.size) == 0 ? j :
1088 data_to_long(&((*(tpp + i))->range)) -
1089 source_start;
1090 for (; j <= k; j++) {
1091 *(error_table + j) = 0;
1092 }
1093 }
1094 } else if (0 < error_count) {
1095 (void) memset(error_table, 0, entry_num);
1096 for (i = 0; i < num; i++) {
1097 if (0 == (*(tpp + i))->data1.size) {
1098 /* error sequence */
1099 j = data_to_long(&((*(tpp + i))->data0)) -
1100 source_start;
1101 k = ((*(tpp + i))->range.size) == 0 ? j :
1102 data_to_long(&((*(tpp + i))->range)) -
1103 source_start;
1104 for (; j <= k; j++) {
1105 *(error_table + j) = 1;
1106 }
1107 }
1108 }
1109 }
1110
1111 p = malloc_vital(sizeof (uchar_t *) * resultlen);
1112 for (i = 0; i < num; i++) {
1113 j = data_to_long(&((*(tpp + i))->data0)) - source_start;
1114 if (0 != (*(tpp + i))->range.size)
1115 k = data_to_long(&((*(tpp + i))->range)) -
1116 source_start;
1117 else
1118 k = j;
1119 (void) memset(p, 0, sizeof (uchar_t *) * resultlen);
1120 (void) memcpy(p + (resultlen - (*(tpp + i))->data1.size),
1121 ((caddr_t)NSPTR(&((*(tpp + i))->data1))),
1122 (*(tpp + i))->data1.size);
1123 map_range_make_result(table, j, k, p, resultlen);
1124 }
1125 free(p);
1126
1127 return (header);
1128 }
1129
1130
1131
1132
1133 static itm_tbl_hdr_t *
1134 map_table_lookup_fixed(
1135 itmc_data_pair_t **tpp,
1136 itm_size_t num,
1137 itm_data_t *default_data,
1138 long resultlen,
1139 itm_size_t num2)
1140 {
1141 itm_tbl_hdr_t *header;
1142 itm_map_lookup_hdr_t *sub_hdr;
1143 char *table;
1144 itm_size_t table_size;
1145 itm_size_t j;
1146 itm_size_t i;
1147 itm_size_t k;
1148 itm_size_t h;
1149 itm_data_t *source;
1150 uchar_t *source_data;
1151 uchar_t *result_data;
1152
1153 TRACE_MESSAGE('m', ("map_table_lookup_fixed : %ld(%ld) 0x%lx\n",
1154 num, num2, default_data));
1155
1156 source = &((*(tpp + 0))->data0);
1157
1158 table_size = ((sizeof (itm_tbl_hdr_t)) +
1159 (sizeof (itm_map_idx_fix_hdr_t)) +
1160 ((source->size + 1 + resultlen) * num2));
1161 if ((NULL != default_data) &&
1162 (((itm_data_t *)(-1)) != default_data)) {
1163 table_size += (source->size + 1 + resultlen);
1164 }
1165 table_size = ITMROUNDUP(table_size);
1166 header = malloc_vital(table_size);
1167 sub_hdr = (itm_map_lookup_hdr_t *)(header + 1);
1168 table = (char *)(sub_hdr + 1);
1169
1170 header->type = ITM_TBL_MAP_LOOKUP;
1171 header->name.itm_ptr = 0;
1172 header->size = table_size;
1173 header->number = num2;
1174 if (NULL != default_data) {
1175 if ((itm_data_t *)(-1) == default_data) {
1176 #if !defined(_LP64)
1177 sub_hdr->pad3_num = (pad_t)(~0);
1178 #endif
1179 sub_hdr->default_error = -1;
1180 } else {
1181 sub_hdr->default_error = 0;
1182 }
1183 } else {
1184 sub_hdr->default_error = 2;
1185 }
1186
1187 sub_hdr->source_len = source->size;
1188 sub_hdr->result_len = resultlen;
1189
1190 /* specified map */
1191 source_data = malloc_vital(source->size);
1192 result_data = malloc_vital(resultlen);
1193 for (i = 0, j = 0; i < num; i++) {
1194 (void) memcpy(table + j,
1195 NSPTR(&((*(tpp + i))->data0)), source->size);
1196 j += source->size;
1197 if (0 == (*(tpp + i))->data1.size) {
1198 *(table + j) = 1; /* specified error */
1199 j += 1;
1200 } else {
1201 /* *(table + j) = 0; ** valid */
1202 j += 1;
1203 (void) memcpy(table + j +
1204 (resultlen - (*(tpp + i))->data1.size),
1205 NSPTR(&((*(tpp + i))->data1)),
1206 (*(tpp + i))->data1.size);
1207 }
1208 j += resultlen;
1209
1210 if ((*(tpp + i))->range.size != 0) {
1211 (void) memcpy(source_data,
1212 NSPTR(&((*(tpp + i))->data0)),
1213 source->size);
1214 (void) memset(result_data, 0, resultlen);
1215 (void) memcpy(result_data +
1216 (resultlen - (*(tpp + i))->data1.size),
1217 NSPTR(&((*(tpp + i))->data1)),
1218 (*(tpp + i))->data1.size);
1219 h = map_table_num_range((*(tpp + i)));
1220 for (k = 0; k < h; k++) {
1221 uchar_t *dp;
1222 itm_size_t m;
1223
1224 for (m = 0,
1225 dp = (uchar_t *)
1226 (source_data + source->size - 1);
1227 m < source->size;
1228 m++, dp--) {
1229 if (0xff != *dp) {
1230 (*dp) += (char)1;
1231 for (++dp; m > 0; m--, dp++) {
1232 (*dp) = 0x00;
1233 }
1234 break;
1235 }
1236 }
1237 (void) memcpy(table + j,
1238 source_data, source->size);
1239 j += source->size;
1240
1241 if (0 == (*(tpp + i))->data1.size) {
1242 *(table + j) = 1; /* specified error */
1243 j += 1;
1244 } else {
1245 /* *(table + j) = 0; ** valid */
1246 j += 1;
1247 for (m = 0, dp = (uchar_t *)
1248 (result_data + resultlen - 1);
1249 m < resultlen;
1250 m++, dp--) {
1251 if (0xff != *dp) {
1252 (*dp) += 1;
1253 for (++dp;
1254 m > 0;
1255 m--, dp++) {
1256 (*dp) = 0x00;
1257 }
1258 break;
1259 }
1260 }
1261 (void) memcpy(table + j, result_data,
1262 resultlen);
1263 }
1264 j += resultlen;
1265 }
1266 }
1267 }
1268 free(source_data);
1269 free(result_data);
1270
1271 /* default */
1272 if ((NULL != default_data) &&
1273 (((itm_data_t *)(-1)) != default_data)) {
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);
1278 }
1279 return (header);
1280 }
1281
1282
1283
1284
1285 static itm_tbl_hdr_t *
1286 map_table_hash(
1287 itmc_data_pair_t **tpp,
1288 itm_size_t num,
1289 itm_data_t *default_data,
1290 long hash_factor,
1291 long resultlen,
1292 itm_size_t num2,
1293 itm_num_t error_count)
1294 {
1295 itm_tbl_hdr_t *header;
1296 itm_map_hash_hdr_t *sub_hdr;
1297 itm_size_t table_size;
1298 char *error_table;
1299 char *hash_table;
1300 itm_size_t hash_table_num;
1301 char *of_table;
1302 itm_size_t of_table_num;
1303 itm_size_t pair_size;
1304 itm_size_t i;
1305 itm_size_t j;
1306 itm_size_t k;
1307 char *p;
1308 itm_data_t *source;
1309 long hash_value;
1310 #if defined(DEBUG)
1311 long hash_none;
1312 long hash_one;
1313 long hash_conflict;
1314 #endif /* DEBUG */
1315 uchar_t *source_data;
1316 uchar_t *result_data;
1317 uchar_t *dp;
1318 itm_size_t m;
1319 itm_size_t n;
1320 itm_size_t h;
1321
1322 TRACE_MESSAGE('m', ("map_table_hash : %ld(%ld) 0x%lx\n",
1323 num, num2, default_data));
1324 source = &((*(tpp + 0))->data0);
1325 pair_size = (source->size + 1 + resultlen);
1326
1327 if (100 <= hash_factor) {
1328 hash_table_num = (num2 * (hash_factor / 100.0));
1329 } else {
1330 hash_table_num = (num2 * 2);
1331 }
1332 if (hash_table_num < 256) {
1333 hash_table_num = 256;
1334 }
1335 source_data = malloc_vital(source->size);
1336 result_data = malloc_vital(resultlen);
1337
1338 hash_table = malloc_vital(hash_table_num);
1339 for (i = 0, of_table_num = 0; i < num; i++) {
1340 hash_value = hash(NSPTR(&((*(tpp + i))->data0)),
1341 (*(tpp + i))->data0.size,
1342 hash_table_num);
1343 if (0 == *(hash_table + hash_value)) {
1344 *(hash_table + hash_value) = 1;
1345 } else {
1346 *(hash_table + hash_value) = 2;
1347 of_table_num += 1;
1348 }
1349
1350 if ((*(tpp + i))->range.size != 0) {
1351 (void) memcpy(source_data,
1352 NSPTR(&((*(tpp + i))->data0)),
1353 source->size);
1354 h = map_table_num_range((*(tpp + i)));
1355 for (n = 0; n < h; n++) {
1356 for (m = 0,
1357 dp = (uchar_t *)
1358 (source_data + source->size - 1);
1359 m < source->size;
1360 m++, dp--) {
1361 if (0xff != *dp) {
1362 (*dp) += 1;
1363 for (++dp; m > 0; m--, dp++) {
1364 (*dp) = 0x00;
1365 }
1366 break;
1367 }
1368 }
1369 hash_value = hash((char *)source_data,
1370 source->size,
1371 hash_table_num);
1372
1373 if (0 == *(hash_table + hash_value)) {
1374 *(hash_table + hash_value) = 1;
1375 } else {
1376 *(hash_table + hash_value) = 2;
1377 of_table_num += 1;
1378 }
1379 }
1380 }
1381 }
1382
1383 #if defined(DEBUG)
1384 if (TRACE('s')) {
1385 hash_none = 0;
1386 hash_one = 0;
1387 hash_conflict = 0;
1388 j = 0;
1389 for (i = 0; i < hash_table_num; i++) {
1390 if (2 == *(hash_table + i)) {
1391 (void) putchar('2');
1392 hash_conflict += 1;
1393 } else if (1 == *(hash_table + i)) {
1394 (void) putchar('1');
1395 hash_one += 1;
1396 } else if (0 == *(hash_table + i)) {
1397 (void) putchar('-');
1398 hash_none += 1;
1399 } else {
1400 (void) putchar('*');
1401 }
1402 if (63 <= j) {
1403 j = 0;
1404 (void) putchar('\n');
1405 } else {
1406 j += 1;
1407 }
1408 }
1409 (void) putchar('\n');
1410 (void) printf("null=%ld one=%ld conflict=%ld\n",
1411 hash_none, hash_one, hash_conflict);
1412 }
1413 #endif /* DEBUG */
1414
1415 free(hash_table);
1416 table_size = ((sizeof (itm_tbl_hdr_t)) +
1417 (sizeof (itm_map_hash_hdr_t)) +
1418 (hash_table_num) +
1419 (pair_size * hash_table_num) +
1420 (pair_size * of_table_num));
1421 if ((NULL != default_data) &&
1422 (((itm_data_t *)(-1)) != default_data)) {
1423 table_size += pair_size;
1424 }
1425 table_size = ITMROUNDUP(table_size);
1426 header = malloc_vital(table_size);
1427 sub_hdr = (itm_map_hash_hdr_t *)(header + 1);
1428 error_table = (char *)(sub_hdr + 1);
1429 hash_table = error_table + hash_table_num;
1430 of_table = hash_table + (pair_size * hash_table_num);
1431
1432 header->type = ITM_TBL_MAP_HASH;
1433 header->name.itm_ptr = 0;
1434 header->size = table_size;
1435 header->number = num2;
1436 if (NULL != default_data) {
1437 if ((itm_data_t *)(-1) == default_data) {
1438 sub_hdr->default_error = -1;
1439 #if !defined(_LP64)
1440 sub_hdr->pad7_num = (pad_t)(~0);
1441 #endif
1442 } else {
1443 sub_hdr->default_error = 0;
1444 }
1445 } else {
1446 sub_hdr->default_error = 2;
1447 }
1448
1449 sub_hdr->source_len = source->size;
1450 sub_hdr->result_len = resultlen;
1451 sub_hdr->hash_tbl_size = (pair_size * hash_table_num);
1452 sub_hdr->hash_tbl_num = hash_table_num;
1453 sub_hdr->hash_of_size =
1454 (pair_size * of_table_num);
1455 sub_hdr->hash_of_num = of_table_num;
1456 sub_hdr->error_num = error_count; /* > 0; so pad4 = 0 */
1457
1458 /* specified map */
1459 for (i = 0, j = 0, k = 0; i < num; i++) {
1460 hash_value = hash(NSPTR(&((*(tpp + i))->data0)),
1461 (*(tpp + i))->data0.size,
1462 hash_table_num);
1463 p = error_table + hash_value;
1464 if (*p) { /* conflict */
1465 if (*p < 63) {
1466 *p += 1;
1467 }
1468 p = of_table + k;
1469 k += pair_size;
1470 } else {
1471 *p = 1;
1472 p = hash_table + (pair_size * hash_value);
1473 }
1474
1475 (void) memcpy(p, NSPTR(&((*(tpp + i))->data0)), source->size);
1476 p += source->size;
1477 if (0 == (*(tpp + i))->data1.size) {
1478 (*p) = 1; /* specified error */
1479 p++;
1480 } else {
1481 /* (*p) = 0; ** valid */
1482 p++;
1483 (void) memset(p, 0,
1484 (resultlen - (*(tpp + i))->data1.size));
1485 (void) memcpy(p +
1486 (resultlen - (*(tpp + i))->data1.size),
1487 NSPTR(&((*(tpp + i))->data1)),
1488 (*(tpp + i))->data1.size);
1489 }
1490
1491 if ((*(tpp + i))->range.size != 0) {
1492 (void) memcpy(source_data,
1493 NSPTR(&((*(tpp + i))->data0)),
1494 source->size);
1495 (void) memset(result_data, 0,
1496 (resultlen - (*(tpp + i))->data1.size));
1497 (void) memcpy(result_data +
1498 (resultlen - (*(tpp + i))->data1.size),
1499 NSPTR(&((*(tpp + i))->data1)),
1500 (*(tpp + i))->data1.size);
1501 h = map_table_num_range((*(tpp + i)));
1502 for (n = 0; n < h; n++) {
1503 for (m = 0,
1504 dp = (uchar_t *)
1505 (source_data + source->size - 1);
1506 m < source->size;
1507 m++, dp--) {
1508 if (0xff != *dp) {
1509 (*dp) += 1;
1510 for (++dp; m > 0; m--, dp++) {
1511 (*dp) = 0x00;
1512 }
1513 break;
1514 }
1515 }
1516
1517 hash_value = hash((char *)source_data,
1518 source->size,
1519 hash_table_num);
1520 p = error_table + hash_value;
1521 if (*p) { /* conflict */
1522 if (*p < 63) {
1523 *p += 1;
1524 }
1525 p = of_table + k;
1526 k += pair_size;
1527 } else {
1528 *p = 1;
1529 p = hash_table +
1530 (pair_size * hash_value);
1531 }
1532 (void) memcpy(p, source_data, source->size);
1533 p += source->size;
1534
1535 if (0 == (*(tpp + i))->data1.size) {
1536 (*p) = 1; /* specified error */
1537 p += 1;
1538 } else {
1539 /* (*p) = 0; ** valid */
1540 p += 1;
1541 for (m = 0, dp = (uchar_t *)
1542 (result_data + resultlen - 1);
1543 m < resultlen;
1544 m++, dp--) {
1545 if (0xff != *dp) {
1546 (*dp) += 1;
1547 for (++dp; m > 0;
1548 m--, dp++) {
1549 (*dp) = 0x00;
1550 }
1551 break;
1552 }
1553 }
1554 (void) memcpy(p,
1555 result_data, resultlen);
1556 }
1557 }
1558 }
1559 }
1560 free(source_data);
1561 free(result_data);
1562
1563 /* default */
1564 if ((NULL != default_data) &&
1565 (((itm_data_t *)(-1)) != default_data)) {
1566 j = ((pair_size * hash_table_num) +
1567 (pair_size * of_table_num));
1568 (void) memcpy(hash_table + j + (resultlen - default_data->size),
1569 NSPTR(default_data), default_data->size);
1570 }
1571 #if defined(ENABLE_TRACE)
1572 for (i = 0, p = of_table; i < of_table_num; i++, p += 5) {
1573 (void) printf("0x%02x%02x%02x%02x 0x%02x\n",
1574 ((unsigned char)(*(p + 0))),
1575 ((unsigned char)(*(p + 1))),
1576 ((unsigned char)(*(p + 2))),
1577 ((unsigned char)(*(p + 3))),
1578 ((unsigned char)(*(p + 4))));
1579 }
1580 #endif
1581 return (header);
1582 }
1583
1584
1585
1586
1587 static itm_tbl_hdr_t *
1588 map_table_dense_encoding(
1589 itmc_data_pair_t **tpp,
1590 itm_size_t num,
1591 itm_data_t *default_data,
1592 unsigned long entry_num,
1593 unsigned char *byte_seq_min,
1594 unsigned char *byte_seq_max,
1595 long resultlen,
1596 itm_num_t error_count)
1597 {
1598
1599 itm_tbl_hdr_t *header;
1600 itm_map_dense_enc_hdr_t *sub_hdr;
1601 char *table;
1602 char *error_table;
1603 itm_size_t table_size;
1604 itm_size_t j;
1605 itm_size_t i;
1606 itm_size_t k;
1607 char *p;
1608 itm_data_t *source;
1609 unsigned char *byte_seq_def;
1610
1611 TRACE_MESSAGE('m', ("map_table_dense_encoding : %ld\n", num));
1612
1613 source = &((*(tpp + 0))->data0);
1614
1615
1616 table_size = ((sizeof (itm_tbl_hdr_t)) +
1617 (sizeof (itm_map_dense_enc_hdr_t)) +
1618 (source->size + source->size) +
1619 (resultlen * entry_num));
1620 if (0 < error_count) {
1621 table_size += entry_num;
1622 }
1623 if (NULL == default_data) {
1624 if ((num < entry_num) ||
1625 (error_count <= 0)) {
1626 table_size += entry_num;
1627 }
1628 } else if ((itm_data_t *)(-1) != default_data) {
1629 table_size += resultlen;
1630 }
1631
1632 table_size = ITMROUNDUP(table_size);
1633 header = malloc_vital(table_size);
1634 sub_hdr = (itm_map_dense_enc_hdr_t *)(header + 1);
1635 table = (char *)(sub_hdr + 1) + source->size + source->size;
1636
1637 header->type = ITM_TBL_MAP_DENSE_ENC;
1638 header->name.itm_ptr = 0;
1639 header->size = table_size;
1640 header->number = entry_num;
1641
1642 sub_hdr->source_len = (*tpp)->data0.size;
1643 sub_hdr->result_len = resultlen;
1644 sub_hdr->error_num = error_count; /* > 0; so pad4 = 0 */
1645
1646 if (NULL != default_data) {
1647 if ((itm_data_t *)(-1) == default_data) {
1648 sub_hdr->default_error = -1;
1649 #if !defined(_LP64)
1650 sub_hdr->pad3_num = (pad_t)(~0);
1651 #endif
1652
1653 } else {
1654 sub_hdr->default_error = 0;
1655 }
1656 } else {
1657 if (num < entry_num) {
1658 sub_hdr->default_error = 1;
1659 } else {
1660 sub_hdr->default_error = 2;
1661 }
1662 }
1663
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);
1667
1668 if (-1 == sub_hdr->default_error) {
1669 byte_seq_def = malloc_vital((sizeof (unsigned char *)) *
1670 resultlen);
1671 if (source->size != resultlen) {
1672 itm_error(
1673 gettext("\"default no_change_copy\" is "
1674 "specified, but size does not match\n"));
1675 exit(ITMC_STATUS_BT);
1676 }
1677 put_dense_encoding_default(
1678 table, byte_seq_min, byte_seq_max, byte_seq_def,
1679 resultlen - 1, 0, 0);
1680 free(byte_seq_def);
1681 } else if (0 == sub_hdr->default_error) {
1682 if (default_data->size <= (sizeof (itm_place_t))) {
1683 for (i = 0, j = 0;
1684 i < (entry_num + 1); /* 1:default data */
1685 i++, j += resultlen) {
1686 (void) memcpy(table + j +
1687 (resultlen - default_data->size),
1688 (void *)(&(default_data->place.itm_64d)),
1689 default_data->size);
1690 }
1691 } else {
1692 for (i = 0, j = 0;
1693 i < (entry_num + 1); /* 1:default data */
1694 i++, j += resultlen) {
1695 (void) memcpy(table + j +
1696 (resultlen - default_data->size),
1697 (void *)(default_data->place.itm_ptr),
1698 default_data->size);
1699 }
1700 }
1701 }
1702 if (1 == sub_hdr->default_error) {
1703 (void) memset(table + (resultlen * entry_num), 1, entry_num);
1704 error_table = (table + (resultlen * entry_num));
1705 for (i = 0; i < num; i++) {
1706 if (0 == (*(tpp + i))->data1.size) {
1707 continue; /* error sequence */
1708 }
1709 j = hash_dense_encoding(NSPTR(&((*(tpp + i))->data0)),
1710 (*(tpp + i))->data0.size,
1711 byte_seq_min, byte_seq_max);
1712 k = ((*(tpp + i))->range.size) == 0 ? j :
1713 hash_dense_encoding(NSPTR(&((*(tpp + i))->range)),
1714 (*(tpp + i))->data0.size,
1715 byte_seq_min, byte_seq_max);
1716 for (; j <= k; j++) {
1717 *(error_table + j) = 0;
1718 }
1719 }
1720 } else if (0 < error_count) {
1721 error_table = (table + (resultlen * entry_num));
1722 if (0 == sub_hdr->default_error) {
1723 error_table += resultlen;
1724 }
1725 (void) memset(error_table, 0, entry_num);
1726 for (i = 0; i < num; i++) {
1727 if (0 == (*(tpp + i))->data1.size) {
1728 j = hash_dense_encoding(
1729 NSPTR(&((*(tpp + i))->data0)),
1730 (*(tpp + i))->data0.size,
1731 byte_seq_min, byte_seq_max);
1732 k = ((*(tpp + i))->range.size) == 0 ? j :
1733 hash_dense_encoding(
1734 NSPTR(&((*(tpp + i))->range)),
1735 (*(tpp + i))->data0.size,
1736 byte_seq_min, byte_seq_max);
1737 for (; j <= k; j++) {
1738 *(error_table + j) = 1; /* specified */
1739 }
1740 }
1741 }
1742 }
1743
1744
1745 p = malloc_vital(resultlen);
1746 for (i = 0; i < num; i++) {
1747 j = hash_dense_encoding(NSPTR(&((*(tpp + i))->data0)),
1748 (*(tpp + i))->data0.size,
1749 byte_seq_min, byte_seq_max);
1750
1751 if (0 != (*(tpp + i))->range.size)
1752 k = hash_dense_encoding(
1753 NSPTR(&((*(tpp + i))->range)),
1754 (*(tpp + i))->range.size,
1755 byte_seq_min, byte_seq_max);
1756 else
1757 k = j;
1758 (void) memset(p, 0, (resultlen - (*(tpp + i))->data1.size));
1759 (void) memcpy(p + (resultlen - (*(tpp + i))->data1.size),
1760 ((caddr_t)NSPTR(&((*(tpp + i))->data1))),
1761 (*(tpp + i))->data1.size);
1762 map_range_make_result(table, j, k, p, resultlen);
1763 }
1764 free(p);
1765
1766 return (header);
1767 }
1768
1769
1770 static void
1771 put_dense_encoding_default(
1772 char *table,
1773 unsigned char *byte_seq_min,
1774 unsigned char *byte_seq_max,
1775 unsigned char *byte_seq_def,
1776 long pos_max,
1777 long position,
1778 long dense_encoded_value)
1779 {
1780 uchar_t i;
1781
1782 if (position < pos_max) {
1783 for (i = *(byte_seq_min + position);
1784 i <= *(byte_seq_max + position); i++) {
1785 *(byte_seq_def + position) = i;
1786 put_dense_encoding_default(
1787 table,
1788 byte_seq_min, byte_seq_max,
1789 byte_seq_def,
1790 pos_max, position + 1,
1791 ((dense_encoded_value + i) *
1792 (*(byte_seq_max + position) -
1793 *(byte_seq_min + position) + 1)));
1794 }
1795 return;
1796 }
1797
1798 for (i = *(byte_seq_min + position);
1799 i <= *(byte_seq_max + position); i++) {
1800 *(byte_seq_def + position) = i;
1801 (void) memcpy(table +
1802 ((pos_max + 1) * (dense_encoded_value + i - 1)),
1803 byte_seq_def, pos_max + 1);
1804 }
1805 }
1806
1807
1808 char *
1809 dense_enc_index_to_byte_seq(
1810 long value,
1811 long length,
1812 unsigned char *byte_seq_min,
1813 unsigned char *byte_seq_max)
1814 {
1815 static char *buf;
1816 static long buf_len;
1817 char *p;
1818 int i;
1819 int l;
1820 int residue;
1821
1822 if (buf_len < (2 + (length * 2) + 1)) {
1823 free(buf);
1824 buf_len = (2 + (length * 2) + 1) + 16;
1825 buf = malloc_vital(buf_len);
1826 }
1827
1828 *(buf + (length * 2)) = '\0';
1829 *(buf + 0) = '0';
1830 *(buf + 1) = 'x';
1831 p = buf + 2;
1832 for (i = length - 1; 0 <= i; --i) {
1833 residue = value % (*(byte_seq_max + i) -
1834 *(byte_seq_min + i) + 1);
1835 value /= (*(byte_seq_max + i) -
1836 *(byte_seq_min + i) + 1);
1837
1838 residue += *(byte_seq_min + i);
1839 l = ((0xf0 & residue) >> 4);
1840 if (l < 10) {
1841 *(p + (i * 2)) = ('0' + l);
1842 } else {
1843 *(p + (i * 2)) = ('a' + l - 10);
1844 }
1845 l = (0x0f & residue);
1846 if (l < 10) {
1847 *(p + (i * 2) + 1) = ('0' + l);
1848 } else {
1849 *(p + (i * 2) + 1) = ('a' + l - 10);
1850 }
1851 }
1852 return (buf);
1853 }
1854
1855
1856 itm_tbl_hdr_t *
1857 map_table_lookup_var()
1858 {
1859 itm_error(gettext(
1860 "length of all source sequences must be the same\n"));
1861 error_deferred += 1;
1862 return (NULL);
1863 }
1864
1865
1866
1867 static void
1868 map_range_adjust_byte_seq(
1869 unsigned char *byte_seq_min,
1870 unsigned char *byte_seq_max,
1871 long source_len,
1872 itmc_data_pair_t *pair)
1873 {
1874 unsigned char *p, *p2;
1875 int i;
1876 int flag;
1877
1878 p = (unsigned char *)(NSPTR(&((pair)->data0)));
1879 p2 = (unsigned char *)(NSPTR(&((pair)->range)));
1880 flag = 0;
1881 for (i = 0; i < source_len; i++) {
1882 if (flag != 0) {
1883 break;
1884 }
1885 if (*(p + i) != *(p2 + i))
1886 flag = 1;
1887 if (*(p + i) < *(byte_seq_min + i)) {
1888 *(byte_seq_min + i) = *(p + i);
1889 }
1890 if (*(byte_seq_max + i) < *(p2 + i)) {
1891 *(byte_seq_max + i) = *(p2 + i);
1892 }
1893 }
1894 for (; i < source_len; i++) {
1895 *(byte_seq_min + i) = 0x00;
1896 *(byte_seq_max + i) = 0xff;
1897 }
1898 }
1899
1900 /*
1901 * result value + (source range value - source base value)
1902 * and just caluculate its length
1903 */
1904 static size_t
1905 map_table_resultlen(itmc_map_t *ml)
1906 {
1907 size_t j;
1908 size_t len;
1909 int m;
1910 uchar_t *c1;
1911 uchar_t *c2;
1912 uchar_t *c3;
1913
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;
1917 c1 = (uchar_t *)(NSPTR(&((ml->data_pair).data0))) +
1918 ml->data_pair.data0.size - 1;
1919 c2 = (uchar_t *)(NSPTR(&((ml->data_pair).data1))) +
1920 ml->data_pair.data1.size - 1;
1921 c3 = (uchar_t *)(NSPTR(&((ml->data_pair.range)))) +
1922 ml->data_pair.range.size - 1;
1923 m = 0;
1924 for (len = 0; len < j; len++, c1--, c2--, c3--) {
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;
1928 m >>= 8;
1929 }
1930 if (m > 0) {
1931 len += 1;
1932 }
1933 TRACE_MESSAGE('g', ("map_table_resutlen: source(0x%s..0x%s), "
1934 "result(0x%s.... len= %ld)\n",
1935 data_to_hexadecimal(&(ml->data_pair.data0)),
1936 data_to_hexadecimal(&(ml->data_pair.range)),
1937 data_to_hexadecimal(&(ml->data_pair.data1)),
1938 len));
1939 return (len);
1940 }
1941
1942 /*
1943 *
1944 */
1945 static void
1946 map_range_make_result(
1947 char *table,
1948 itm_size_t range_start,
1949 itm_size_t range_end,
1950 char *result_data,
1951 itm_size_t result_size)
1952 {
1953 itm_size_t i;
1954 itm_size_t j;
1955 itm_size_t p;
1956 uchar_t *dp; /* unsigned for ++ operation */
1957
1958 for (i = range_start, p = i * result_size;
1959 i <= range_end; i++, p += result_size) {
1960 (void) memcpy(table + p, result_data, result_size);
1961 for (j = 0, dp = (uchar_t *)(result_data + result_size - 1);
1962 j < result_size;
1963 j++, dp--) {
1964 if (0xff != *dp) {
1965 (*dp) += 1;
1966 for (++dp; j > 0; j--, dp++) {
1967 (*dp) = 0x00;
1968 }
1969 break;
1970 }
1971 }
1972 }
1973 }
1974
1975 /*
1976 *
1977 */
1978 static size_t
1979 map_table_num_range(itmc_data_pair_t *pair)
1980 {
1981 size_t i, j;
1982 itm_num_t num;
1983 itm_num_t num2;
1984 uchar_t *c1;
1985 uchar_t *c2;
1986
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;
1993 num = 0;
1994 for (i = 0; i < j; i++, c1--, c2--) {
1995 if (i < pair->range.size) num2 = *c2;
1996 if (i < pair->data0.size) num2 -= *c1;
1997 TRACE_MESSAGE('G', (" num += %d(=%d-%d)\n ",
1998 *c2 - *c1, *c2, *c1));
1999 num2 <<= (i*8);
2000 num += num2;
2001 }
2002 TRACE_MESSAGE('g', ("map_table_num_range: source(0x%s..0x%s), "
2003 "num= %ld\n",
2004 data_to_hexadecimal(&(pair->data0)),
2005 data_to_hexadecimal(&(pair->range)),
2006 num));
2007 return (num);
2008 }
2009
2010 /*
2011 *
2012 */
2013 itmc_map_t *
2014 map_list_append(itmc_map_t *map_list, itmc_map_t *map_pair)
2015 {
2016 if (0 == map_pair) {
2017 return (map_list);
2018 }
2019
2020 map_pair->next = NULL;
2021 map_pair->last = map_pair;
2022
2023 if (map_list) {
2024 map_list->last->next = map_pair;
2025 map_list->last = map_pair;
2026 return (map_list);
2027 } else {
2028 return (map_pair);
2029 }
2030 }
2031
2032
2033
2034 itmc_obj_t *
2035 op_self(itm_op_type_t type)
2036 {
2037 return (op_unit(type, NULL, 0, NULL, 0, NULL, 0));
2038 }
2039
2040
2041 itmc_obj_t *
2042 op_unary(itm_op_type_t type, void *data, size_t data_size)
2043 {
2044 return (op_unit(type, data, data_size, NULL, 0, NULL, 0));
2045 }
2046
2047 itmc_obj_t *
2048 op_unit(itm_op_type_t type,
2049 void *data0, size_t data0_size,
2050 void *data1, size_t data1_size,
2051 void *data2, size_t data2_size)
2052 {
2053 itm_op_t *op;
2054 itmc_obj_t *obj;
2055
2056 op = malloc_vital(sizeof (itm_op_t));
2057 op->type = type;
2058 op->data.operand[0].itm_ptr = (itm_place2_t)(data0);
2059 op->data.operand[1].itm_ptr = (itm_place2_t)(data1);
2060 op->data.operand[2].itm_ptr = (itm_place2_t)(data2);
2061
2062 obj = malloc_vital(sizeof (itmc_obj_t));
2063 obj->type = ITMC_OBJ_OP;
2064 obj->name = NULL;
2065 obj->obj = op;
2066 obj->ref[0] = obj->ref[1] = obj->ref[2] = NULL;
2067 if (NULL != data0) {
2068 obj->ref[0] = obj_register(ITMC_OBJ_EXPR, NULL,
2069 data0, data0_size,
2070 &(op->data.operand[0]),
2071 OBJ_REG_TAIL);
2072 }
2073 if (NULL != data1) {
2074 obj->ref[1] = obj_register(ITMC_OBJ_EXPR, NULL,
2075 data1, data1_size,
2076 &(op->data.operand[1]),
2077 OBJ_REG_TAIL);
2078 }
2079 if (NULL != data2) {
2080 obj->ref[2] = obj_register(ITMC_OBJ_EXPR, NULL,
2081 data2, data2_size,
2082 &(op->data.operand[2]),
2083 OBJ_REG_TAIL);
2084 }
2085 obj->next = NULL;
2086 obj->last = NULL;
2087
2088 return (obj);
2089 }
2090
2091
2092 itmc_obj_t *
2093 op_self_num(itm_op_type_t type, itm_num_t data)
2094 {
2095 itm_op_t *op;
2096 itmc_obj_t *obj;
2097
2098 op = malloc_vital(sizeof (itm_op_t));
2099 op->type = type;
2100 op->data.itm_opnum = data;
2101 #if !defined(_LP64)
2102 op->data.itm_oppad = (data < 0) ? (pad_t)(~0) : 0;
2103 #endif
2104 obj = malloc_vital(sizeof (itmc_obj_t));
2105 obj->type = ITMC_OBJ_OP;
2106 obj->name = NULL;
2107 obj->obj = op;
2108 obj->ref[0] = obj->ref[1] = obj->ref[2] = NULL;
2109
2110 return (obj);
2111 }
2112
2113
2114 itm_expr_t *
2115 expr_self_num(itm_expr_type_t type, itm_num_t data)
2116 {
2117 itm_expr_t *expr;
2118
2119 expr = malloc_vital(sizeof (itm_expr_t));
2120 expr->type = type;
2121 expr->data.itm_exnum = data;
2122 #if !defined(_LP64)
2123 expr->data.itm_expad = (data < 0) ? (pad_t)(~0) : 0;
2124 #endif
2125 return (expr);
2126 }
2127
2128
2129 itm_expr_t *
2130 expr_self(itm_expr_type_t type, itm_data_t *data)
2131 {
2132 itm_expr_t *expr;
2133 itmc_name_t *name;
2134
2135 expr = malloc_vital(sizeof (itm_expr_t));
2136 expr->type = type;
2137 if (NULL == data) {
2138 expr->data.value.size = 0;
2139 expr->data.value.place.itm_ptr = 0;
2140 } else {
2141 expr->data.value = *(data);
2142 }
2143
2144 switch (type) {
2145 case ITM_EXPR_NAME: /* register */
2146 name = name_lookup(data, ITMC_OBJ_REGISTER);
2147 if (&name_lookup_error == name) {
2148 return (NULL);
2149 } else if (NULL == name) {
2150 if (reg_id >= MAXREGID) {
2151 itm_error(
2152 gettext(
2153 "more than %d variables are used\n"),
2154 MAXREGID);
2155 exit(ITMC_STATUS_BT2);
2156 }
2157 name = name_register(data, ITMC_OBJ_REGISTER, NULL);
2158 name->reg_id = (reg_id++);
2159 }
2160 expr->type = ITM_EXPR_REG;
2161 expr->data.itm_exnum = name->reg_id;
2162 #if !defined(_LP64)
2163 expr->data.itm_expad =
2164 (expr->data.itm_exnum < 0) ? (pad_t)(~0) : 0;
2165 #endif
2166 break;
2167 case ITM_EXPR_SEQ:
2168 if ((sizeof (itm_place_t)) < data->size) {
2169 (void) obj_register(ITMC_OBJ_DATA, NULL,
2170 (void *)(data->place.itm_ptr), data->size,
2171 &(expr->data.value.place), OBJ_REG_TAIL);
2172 }
2173 break;
2174 }
2175 return (expr);
2176 }
2177
2178
2179 itm_expr_t *
2180 expr_unary(itm_expr_type_t type, itm_expr_t *data0)
2181 {
2182 itm_expr_t *expr;
2183
2184 expr = malloc_vital(sizeof (itm_expr_t));
2185 expr->type = type;
2186 expr->data.operand[0].itm_ptr = (itm_place2_t)(data0);
2187 (void) obj_register(ITMC_OBJ_EXPR, NULL,
2188 data0, sizeof (itm_expr_t),
2189 &(expr->data.operand[0]), OBJ_REG_TAIL);
2190
2191 return (expr);
2192 }
2193
2194
2195 itm_expr_t *
2196 expr_binary(itm_expr_type_t type,
2197 itm_expr_t *data0, itm_expr_t *data1)
2198 {
2199 itm_expr_t *expr;
2200 itm_num_t num;
2201 unsigned char *p;
2202 int i;
2203
2204 expr = malloc_vital(sizeof (itm_expr_t));
2205 expr->type = type;
2206
2207 if (ITM_EXPR_SEQ == data0->type) {
2208 p = (unsigned char *)NSPTR(&(data0->data.value));
2209 for (i = 0, num = 0; i < data0->data.value.size; i++, p++) {
2210 num = ((num << 8) | *p);
2211 }
2212 data0 = expr_self_num(ITM_EXPR_INT, num);
2213 }
2214 if (ITM_EXPR_SEQ == data1->type) {
2215 p = (unsigned char *)NSPTR(&(data1->data.value));
2216 for (i = 0, num = 0; i < data1->data.value.size; i++, p++) {
2217 num = ((num << 8) | *p);
2218 }
2219 data1 = expr_self_num(ITM_EXPR_INT, num);
2220 }
2221
2222 expr->data.operand[0].itm_ptr = (itm_place2_t)(data0);
2223 expr->data.operand[1].itm_ptr = (itm_place2_t)(data1);
2224
2225 (void) obj_register(ITMC_OBJ_EXPR, NULL,
2226 data0, sizeof (itm_expr_t),
2227 &(expr->data.operand[0]), OBJ_REG_TAIL);
2228 (void) obj_register(ITMC_OBJ_EXPR, NULL,
2229 data1, sizeof (itm_expr_t),
2230 &(expr->data.operand[1]), OBJ_REG_TAIL);
2231
2232 return (expr);
2233 }
2234
2235
2236 itm_expr_t *
2237 expr_binary2(itm_expr_type_t type,
2238 itm_expr_t *data0, itm_expr_t *data1)
2239 {
2240 itm_expr_t *expr;
2241 itm_num_t num;
2242 unsigned char *p;
2243 int i;
2244
2245 if ((NULL == data0) || (NULL == data1)) {
2246 return (NULL);
2247 }
2248 expr = malloc_vital(sizeof (itm_expr_t));
2249 expr->type = type;
2250
2251 switch (data0->type) {
2252 case ITM_EXPR_SEQ:
2253 p = (unsigned char *)NSPTR(&(data0->data.value));
2254 for (i = 0, num = 0; i < data0->data.value.size; i++, p++) {
2255 num = ((num << 8) | *p);
2256 }
2257 data0 = expr_self_num(ITM_EXPR_INT, num);
2258 expr->data.operand[0].itm_ptr = (itm_place2_t)(data0);
2259 (void) obj_register(ITMC_OBJ_EXPR, NULL,
2260 data0, sizeof (itm_expr_t),
2261 &(expr->data.operand[0]), OBJ_REG_TAIL);
2262 break;
2263 case ITM_EXPR_INT:
2264 case ITM_EXPR_REG:
2265 case ITM_EXPR_IN_VECTOR_D:
2266 expr->data.operand[0] = data0->data.operand[0];
2267 break;
2268 default:
2269 expr->data.operand[0].itm_ptr = (itm_place2_t)(data0);
2270 (void) obj_register(ITMC_OBJ_EXPR, NULL,
2271 data0, sizeof (itm_expr_t),
2272 &(expr->data.operand[0]), OBJ_REG_TAIL);
2273 break;
2274 }
2275
2276 switch (data1->type) {
2277 case ITM_EXPR_SEQ:
2278 p = (unsigned char *)NSPTR(&(data1->data.value));
2279 for (i = 0, num = 0; i < data1->data.value.size; i++, p++) {
2280 num = ((num << 8) | *p);
2281 }
2282 data1 = expr_self_num(ITM_EXPR_INT, num);
2283 expr->data.operand[1].itm_ptr = (itm_place2_t)(data1);
2284 (void) obj_register(ITMC_OBJ_EXPR, NULL,
2285 data1, sizeof (itm_expr_t),
2286 &(expr->data.operand[1]), OBJ_REG_TAIL);
2287 break;
2288 case ITM_EXPR_INT:
2289 case ITM_EXPR_REG:
2290 case ITM_EXPR_IN_VECTOR_D:
2291 expr->data.operand[1] = data1->data.operand[0];
2292 break;
2293 default:
2294 expr->data.operand[1].itm_ptr = (itm_place2_t)(data1);
2295 (void) obj_register(ITMC_OBJ_EXPR, NULL,
2296 data1, sizeof (itm_expr_t),
2297 &(expr->data.operand[1]), OBJ_REG_TAIL);
2298 break;
2299 }
2300 return (expr);
2301 }
2302
2303
2304 itm_expr_t *
2305 expr_assign(itm_expr_type_t type,
2306 itm_data_t *data0, itm_expr_t *data1)
2307 {
2308 itm_expr_t *expr;
2309 itmc_name_t *name;
2310
2311 expr = malloc_vital(sizeof (itm_expr_t));
2312 expr->type = type;
2313 expr->data.operand[1].itm_ptr = (itm_place2_t)(data1);
2314
2315 name = name_lookup(data0, ITMC_OBJ_REGISTER);
2316 if (&name_lookup_error == name) {
2317 free(expr);
2318 exit(ITMC_STATUS_BT);
2319 } else if (NULL == name) {
2320 name = name_register(data0, ITMC_OBJ_REGISTER, NULL);
2321 name->reg_id = (reg_id++);
2322 }
2323 expr->data.operand[0].itm_ptr = name->reg_id;
2324
2325 (void) obj_register(ITMC_OBJ_EXPR, NULL,
2326 data1, sizeof (itm_expr_t),
2327 &(expr->data.operand[1]), OBJ_REG_TAIL);
2328 return (expr);
2329 }
2330
2331
2332 itm_expr_t *
2333 expr_seq_to_int(itm_expr_t *expr)
2334 {
2335 itm_num_t num;
2336 unsigned char *p;
2337 int i;
2338
2339 if (ITM_EXPR_SEQ == expr->type) {
2340 if ((sizeof (itm_place_t)) < expr->data.value.size) {
2341 p = (unsigned char *)(expr->data.value.place.itm_ptr);
2342 } else {
2343 p = (unsigned char *)&(expr->data.value.place.itm_64d);
2344 }
2345 for (i = 0, num = 0;
2346 i < expr->data.value.size;
2347 i++, p++) {
2348 num = ((num << 8) | *p);
2349 }
2350 free(expr);
2351 expr = expr_self_num(ITM_EXPR_INT, num);
2352 }
2353 return (expr);
2354 }
2355
2356
2357 itmc_name_t *
2358 name_lookup(itm_data_t *name, itm_type_t type)
2359 {
2360 itmc_name_t *p;
2361
2362 TRACE_MESSAGE('N', ("name_lookup\t: \"%-16s\" %2ld %2ld %2ld\n",
2363 name_to_str(name), name->size, type, name_id));
2364
2365 if (0 == name->size)
2366 return (NULL);
2367 for (p = name_first; p; p = p->next) {
2368 if ((name->size != p->name.size) ||
2369 (memcmp(NSPTR(name), NSPTR(&(p->name)), name->size))) {
2370 continue;
2371 }
2372 if ((type != p->type) &&
2373 (((ITMC_OBJ_ACTION != type) &&
2374 (ITMC_OBJ_ACTION != p->type)) ||
2375 ((ITMC_OBJ_ACTION == type) &&
2376 (ITMC_OBJ_DIREC != p->type) &&
2377 (ITMC_OBJ_OP != p->type) &&
2378 (ITMC_OBJ_MAP != p->type)) ||
2379 ((ITMC_OBJ_ACTION == p->type) &&
2380 (ITMC_OBJ_DIREC != type) &&
2381 (ITMC_OBJ_OP != type) &&
2382 (ITMC_OBJ_MAP != type)))) {
2383 itm_error(
2384 gettext("name type conflict: \"%1$s\" "
2385 "%2$s %3$s\n"),
2386 name_to_str(name),
2387 itm_name_type_name[type],
2388 itm_name_type_name[p->type]);
2389 error_deferred += 1;
2390 return (&name_lookup_error);
2391 } else {
2392 return (p);
2393 }
2394 }
2395 return (NULL);
2396 }
2397
2398
2399 itmc_name_t *
2400 name_refer(itm_data_t *name, itm_type_t type, itmc_ref_t *refp)
2401 {
2402 itmc_name_t *p;
2403 itmc_ref_link_t *rl;
2404
2405 p = name_lookup(name, type);
2406
2407 TRACE_MESSAGE('N', ("name_refer\t: \"%-16s\" %2ld %2ld %08p %2d %08p\n",
2408 name_to_str(name), name->size, type, refp, name_id, p));
2409
2410 if (&name_lookup_error == p) {
2411 return (NULL);
2412 }
2413
2414 rl = malloc_vital(sizeof (itmc_ref_link_t));
2415
2416 rl->ref = refp;
2417 rl->next = NULL;
2418
2419 if (NULL != p) {
2420 if (p->ref_last) {
2421 p->ref_last->next = rl;
2422 } else {
2423 p->ref_first = rl;
2424 }
2425 p->ref_last = rl;
2426 } else {
2427 p = malloc_vital(sizeof (itmc_name_t));
2428 p->id = (name_id++);
2429 p->reg_id = 0;
2430 p->name = *name;
2431 p->type = type;
2432 #if !defined(_LP64)
2433 p->reloc.itm_pad = 0;
2434 #endif
2435 p->reloc.itm_ptr = 0;
2436 p->ref_first = rl;
2437 p->ref_last = rl;
2438 p->next = NULL;
2439
2440 if (name_last) {
2441 name_last->next = p;
2442 } else {
2443 name_first = p;
2444 }
2445 name_last = p;
2446 }
2447 return (p);
2448 }
2449
2450
2451 itmc_name_t *
2452 name_register(itm_data_t *name, itm_type_t type, itmc_ref_t *refp)
2453 {
2454 itmc_name_t *p;
2455
2456 TRACE_MESSAGE('N', ("name_register\t: \"%-16s\" %2ld %2ld %08p %2ld\n",
2457 name_to_str(name), name->size, type, refp, name_id));
2458
2459
2460 p = name_lookup(name, type);
2461 if (&name_lookup_error == p) {
2462 return (NULL);
2463 }
2464 if (NULL != p) {
2465 if (NULL != p->object) {
2466 itm_error(gettext(
2467 "same names are specified: %1$s\n"),
2468 name_to_str(name));
2469 error_deferred += 1;
2470 return (NULL);
2471 }
2472 p->object = refp;
2473 } else {
2474 p = malloc_vital(sizeof (itmc_name_t));
2475 p->id = (name_id++);
2476 p->reg_id = 0;
2477 p->name = *name;
2478 p->type = type;
2479 p->object = refp;
2480 p->reloc.itm_ptr = 0;
2481 #if !defined(_LP64)
2482 p->reloc.itm_pad = 0;
2483 #endif
2484 p->ref_first = NULL;
2485 p->ref_last = NULL;
2486 p->next = NULL;
2487
2488 if (name_last) {
2489 name_last->next = p;
2490 } else {
2491 name_first = p;
2492 }
2493 name_last = p;
2494 }
2495
2496 return (p);
2497 }
2498
2499
2500 int
2501 data_compare(const itm_data_t *d0, const itm_data_t *d1)
2502 {
2503 if (d0->size < d1->size) {
2504 if (memcmp(NSPTR(d0), NSPTR(d1), d0->size) < 0) {
2505 return (-1);
2506 } else {
2507 return (1);
2508 }
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) {
2513 return (-1);
2514 } else {
2515 return (1);
2516 }
2517 }
2518 }
2519
2520 int
2521 data_pair_compare(itmc_data_pair_t **p0, itmc_data_pair_t **p1)
2522 {
2523 int r;
2524 itm_data_t *d0;
2525 itm_data_t *d1;
2526 uchar_t *c0;
2527 uchar_t *c1;
2528 size_t s;
2529 int i;
2530
2531 d0 = &((*p0)->data0);
2532 d1 = &((*p1)->data0);
2533 c0 = NSPTR(d0);
2534 c1 = NSPTR(d1);
2535 if (d0->size == d1->size) {
2536 s = d0->size;
2537 } else if (d0->size < d1->size) {
2538 s = d1->size - d0->size;
2539 for (i = 0; i < s; i++, c1++) {
2540 if (0x00 != *c1) {
2541 return (-1);
2542 }
2543 }
2544 s = d0->size;
2545 } else {
2546 assert(d0->size > d1->size);
2547 s = d0->size - d1->size;
2548 for (i = 0; i < s; i++, c0++) {
2549 if (0x00 != *c0) {
2550 return (1);
2551 }
2552 }
2553 s = d1->size;
2554 }
2555 r = memcmp(c0, c1, s);
2556 if (0 == r) {
2557 itm_data_t *d;
2558 if (c0 == NSPTR(d0)) {
2559 d = d0;
2560 } else {
2561 assert(c1 == NSPTR(d0));
2562 d = d1;
2563 }
2564 itm_error(gettext(
2565 "distinct source values are specified: 0x%1$s\n"),
2566 data_to_hexadecimal(d));
2567 error_deferred += 1;
2568 }
2569 return (r);
2570 }
2571
2572
2573 static long
2574 data_to_long(itm_data_t *data)
2575 {
2576 long l;
2577 int i;
2578 unsigned char *p;
2579
2580 if ((sizeof (itm_place_t)) < data->size) {
2581 return (0);
2582 }
2583 for (l = 0, i = 0, p = (unsigned char *)&(data->place);
2584 i < data->size;
2585 i++, p++) {
2586 l <<= 8;
2587 l |= *p;
2588 }
2589 return (l);
2590 }
Unleashed OS