1/* $OpenBSD: eval.c,v 1.69 2011/03/24 11:23:08 espie Exp $ */
2/* $NetBSD: eval.c,v 1.7 1996/11/10 21:21:29 pk Exp $ */
3
4/*
5 * Copyright (c) 1989, 1993
6 * The Regents of the University of California. All rights reserved.
7 *
8 * This code is derived from software contributed to Berkeley by
9 * Ozan Yigit at York University.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the University nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36#include <sys/cdefs.h>
37__FBSDID("$FreeBSD: head/usr.bin/m4/eval.c 228697 2011-12-18 22:04:55Z bapt $");
38
39
40/*
41 * eval.c
42 * Facility: m4 macro processor
43 * by: oz
44 */
45
46#include <sys/types.h>
47#include <err.h>
48#include <errno.h>
49#include <limits.h>
50#include <unistd.h>
51#include <stdint.h>
52#include <stdio.h>
53#include <stdlib.h>
54#include <stddef.h>
55#include <string.h>
56#include <fcntl.h>
57#include "mdef.h"
58#include "stdd.h"
59#include "extern.h"
60#include "pathnames.h"
61
62static void dodefn(const char *);
63static void dopushdef(const char *, const char *);
64static void dodump(const char *[], int);
65static void dotrace(const char *[], int, int);
66static void doifelse(const char *[], int);
67static int doincl(const char *);
68static int dopaste(const char *);
69static void dochq(const char *[], int);
70static void dochc(const char *[], int);
71static void dom4wrap(const char *);
72static void dodiv(int);
73static void doundiv(const char *[], int);
74static void dosub(const char *[], int);
75static void map(char *, const char *, const char *, const char *);
76static const char *handledash(char *, char *, const char *);
77static void expand_builtin(const char *[], int, int);
78static void expand_macro(const char *[], int);
79static void dump_one_def(const char *, struct macro_definition *);
80
81unsigned long expansion_id;
82
83/*
84 * eval - eval all macros and builtins calls
85 * argc - number of elements in argv.
86 * argv - element vector :
87 * argv[0] = definition of a user
88 * macro or NULL if built-in.
89 * argv[1] = name of the macro or
90 * built-in.
91 * argv[2] = parameters to user-defined
92 * . macro or built-in.
93 * .
94 *
95 * A call in the form of macro-or-builtin() will result in:
96 * argv[0] = nullstr
97 * argv[1] = macro-or-builtin
98 * argv[2] = nullstr
99 *
100 * argc is 3 for macro-or-builtin() and 2 for macro-or-builtin
101 */
102void
103eval(const char *argv[], int argc, int td, int is_traced)
104{
105 size_t mark = SIZE_MAX;
106
107 expansion_id++;
108 if (td & RECDEF)
109 m4errx(1, "expanding recursive definition for %s.", argv[1]);
110 if (is_traced)
111 mark = trace(argv, argc, infile+ilevel);
112 if (td == MACRTYPE)
113 expand_macro(argv, argc);
114 else
115 expand_builtin(argv, argc, td);
116 if (mark != SIZE_MAX)
117 finish_trace(mark);
118}
119
120/*
121 * expand_builtin - evaluate built-in macros.
122 */
123void
124expand_builtin(const char *argv[], int argc, int td)
125{
126 int c, n;
127 int ac;
128 static int sysval = 0;
129
130#ifdef DEBUG
131 printf("argc = %d\n", argc);
132 for (n = 0; n < argc; n++)
133 printf("argv[%d] = %s\n", n, argv[n]);
134 fflush(stdout);
135#endif
136
137 /*
138 * if argc == 3 and argv[2] is null, then we
139 * have macro-or-builtin() type call. We adjust
140 * argc to avoid further checking..
141 */
142 /* we keep the initial value for those built-ins that differentiate
143 * between builtin() and builtin.
144 */
145 ac = argc;
146
147 if (argc == 3 && !*(argv[2]) && !mimic_gnu)
148 argc--;
149
150 switch (td & TYPEMASK) {
151
152 case DEFITYPE:
153 if (argc > 2)
154 dodefine(argv[2], (argc > 3) ? argv[3] : null);
155 break;
156
157 case PUSDTYPE:
158 if (argc > 2)
159 dopushdef(argv[2], (argc > 3) ? argv[3] : null);
160 break;
161
162 case DUMPTYPE:
163 dodump(argv, argc);
164 break;
165
166 case TRACEONTYPE:
167 dotrace(argv, argc, 1);
168 break;
169
170 case TRACEOFFTYPE:
171 dotrace(argv, argc, 0);
172 break;
173
174 case EXPRTYPE:
175 /*
176 * doexpr - evaluate arithmetic
177 * expression
178 */
179 {
180 int base = 10;
181 int maxdigits = 0;
182 const char *errstr;
183
184 if (argc > 3) {
185 base = strtonum(argv[3], 2, 36, &errstr);
186 if (errstr) {
187 m4errx(1, "expr: base %s invalid.", argv[3]);
188 }
189 }
190 if (argc > 4) {
191 maxdigits = strtonum(argv[4], 0, INT_MAX, &errstr);
192 if (errstr) {
193 m4errx(1, "expr: maxdigits %s invalid.", argv[4]);
194 }
195 }
196 if (argc > 2)
197 pbnumbase(expr(argv[2]), base, maxdigits);
198 break;
199 }
200
201 case IFELTYPE:
202 if (argc > 4)
203 doifelse(argv, argc);
204 break;
205
206 case IFDFTYPE:
207 /*
208 * doifdef - select one of two
209 * alternatives based on the existence of
210 * another definition
211 */
212 if (argc > 3) {
213 if (lookup_macro_definition(argv[2]) != NULL)
214 pbstr(argv[3]);
215 else if (argc > 4)
216 pbstr(argv[4]);
217 }
218 break;
219
220 case LENGTYPE:
221 /*
222 * dolen - find the length of the
223 * argument
224 */
225 pbnum((argc > 2) ? strlen(argv[2]) : 0);
226 break;
227
228 case INCRTYPE:
229 /*
230 * doincr - increment the value of the
231 * argument
232 */
233 if (argc > 2)
234 pbnum(atoi(argv[2]) + 1);
235 break;
236
237 case DECRTYPE:
238 /*
239 * dodecr - decrement the value of the
240 * argument
241 */
242 if (argc > 2)
243 pbnum(atoi(argv[2]) - 1);
244 break;
245
246 case SYSCTYPE:
247 /*
248 * dosys - execute system command
249 */
250 if (argc > 2) {
251 fflush(stdout);
252 sysval = system(argv[2]);
253 }
254 break;
255
256 case SYSVTYPE:
257 /*
258 * dosysval - return value of the last
259 * system call.
260 *
261 */
262 pbnum(sysval);
263 break;
264
265 case ESYSCMDTYPE:
266 if (argc > 2)
267 doesyscmd(argv[2]);
268 break;
269 case INCLTYPE:
270 if (argc > 2)
271 if (!doincl(argv[2]))
272 if (mimic_gnu)
273 warn("%s at line %lu: include(%s)",
274 CURRENT_NAME, CURRENT_LINE, argv[2]);
275 else
276 err(1, "%s at line %lu: include(%s)",
277 CURRENT_NAME, CURRENT_LINE, argv[2]);
278 break;
279
280 case SINCTYPE:
281 if (argc > 2)
282 (void) doincl(argv[2]);
283 break;
284#ifdef EXTENDED
285 case PASTTYPE:
286 if (argc > 2)
287 if (!dopaste(argv[2]))
288 err(1, "%s at line %lu: paste(%s)",
289 CURRENT_NAME, CURRENT_LINE, argv[2]);
290 break;
291
292 case SPASTYPE:
293 if (argc > 2)
294 (void) dopaste(argv[2]);
295 break;
296 case FORMATTYPE:
297 doformat(argv, argc);
298 break;
299#endif
300 case CHNQTYPE:
301 dochq(argv, ac);
302 break;
303
304 case CHNCTYPE:
305 dochc(argv, argc);
306 break;
307
308 case SUBSTYPE:
309 /*
310 * dosub - select substring
311 *
312 */
313 if (argc > 3)
314 dosub(argv, argc);
315 break;
316
317 case SHIFTYPE:
318 /*
319 * doshift - push back all arguments
320 * except the first one (i.e. skip
321 * argv[2])
322 */
323 if (argc > 3) {
324 for (n = argc - 1; n > 3; n--) {
325 pbstr(rquote);
326 pbstr(argv[n]);
327 pbstr(lquote);
328 pushback(COMMA);
329 }
330 pbstr(rquote);
331 pbstr(argv[3]);
332 pbstr(lquote);
333 }
334 break;
335
336 case DIVRTYPE:
337 if (argc > 2 && (n = atoi(argv[2])) != 0)
338 dodiv(n);
339 else {
340 active = stdout;
341 oindex = 0;
342 }
343 break;
344
345 case UNDVTYPE:
346 doundiv(argv, argc);
347 break;
348
349 case DIVNTYPE:
350 /*
351 * dodivnum - return the number of
352 * current output diversion
353 */
354 pbnum(oindex);
355 break;
356
357 case UNDFTYPE:
358 /*
359 * doundefine - undefine a previously
360 * defined macro(s) or m4 keyword(s).
361 */
362 if (argc > 2)
363 for (n = 2; n < argc; n++)
364 macro_undefine(argv[n]);
365 break;
366
367 case POPDTYPE:
368 /*
369 * dopopdef - remove the topmost
370 * definitions of macro(s) or m4
371 * keyword(s).
372 */
373 if (argc > 2)
374 for (n = 2; n < argc; n++)
375 macro_popdef(argv[n]);
376 break;
377
378 case MKTMTYPE:
379 /*
380 * dotemp - create a temporary file
381 */
382 if (argc > 2) {
383 int fd;
384 char *temp;
385
386 temp = xstrdup(argv[2]);
387
388 fd = mkstemp(temp);
389 if (fd == -1)
390 err(1,
391 "%s at line %lu: couldn't make temp file %s",
392 CURRENT_NAME, CURRENT_LINE, argv[2]);
393 close(fd);
394 pbstr(temp);
395 free(temp);
396 }
397 break;
398
399 case TRNLTYPE:
400 /*
401 * dotranslit - replace all characters in
402 * the source string that appears in the
403 * "from" string with the corresponding
404 * characters in the "to" string.
405 */
406 if (argc > 3) {
407 char *temp;
408
409 temp = xalloc(strlen(argv[2])+1, NULL);
410 if (argc > 4)
411 map(temp, argv[2], argv[3], argv[4]);
412 else
413 map(temp, argv[2], argv[3], null);
414 pbstr(temp);
415 free(temp);
416 } else if (argc > 2)
417 pbstr(argv[2]);
418 break;
419
420 case INDXTYPE:
421 /*
422 * doindex - find the index of the second
423 * argument string in the first argument
424 * string. -1 if not present.
425 */
426 pbnum((argc > 3) ? indx(argv[2], argv[3]) : -1);
427 break;
428
429 case ERRPTYPE:
430 /*
431 * doerrp - print the arguments to stderr
432 * file
433 */
434 if (argc > 2) {
435 for (n = 2; n < argc; n++)
436 fprintf(stderr, "%s ", argv[n]);
437 fprintf(stderr, "\n");
438 }
439 break;
440
441 case DNLNTYPE:
442 /*
443 * dodnl - eat-up-to and including
444 * newline
445 */
446 while ((c = gpbc()) != '\n' && c != EOF)
447 ;
448 break;
449
450 case M4WRTYPE:
451 /*
452 * dom4wrap - set up for
453 * wrap-up/wind-down activity
454 */
455 if (argc > 2)
456 dom4wrap(argv[2]);
457 break;
458
459 case EXITTYPE:
460 /*
461 * doexit - immediate exit from m4.
462 */
463 killdiv();
464 exit((argc > 2) ? atoi(argv[2]) : 0);
465 break;
466
467 case DEFNTYPE:
468 if (argc > 2)
469 for (n = 2; n < argc; n++)
470 dodefn(argv[n]);
471 break;
472
473 case INDIRTYPE: /* Indirect call */
474 if (argc > 2)
475 doindir(argv, argc);
476 break;
477
478 case BUILTINTYPE: /* Builtins only */
479 if (argc > 2)
480 dobuiltin(argv, argc);
481 break;
482
483 case PATSTYPE:
484 if (argc > 2)
485 dopatsubst(argv, argc);
486 break;
487 case REGEXPTYPE:
488 if (argc > 2)
489 doregexp(argv, argc);
490 break;
491 case LINETYPE:
492 doprintlineno(infile+ilevel);
493 break;
494 case FILENAMETYPE:
495 doprintfilename(infile+ilevel);
496 break;
497 case SELFTYPE:
498 pbstr(rquote);
499 pbstr(argv[1]);
500 pbstr(lquote);
501 break;
502 default:
503 m4errx(1, "eval: major botch.");
504 break;
505 }
506}
507
508/*
509 * expand_macro - user-defined macro expansion
510 */
511void
512expand_macro(const char *argv[], int argc)
513{
514 const char *t;
515 const char *p;
516 int n;
517 int argno;
518
519 t = argv[0]; /* defn string as a whole */
520 p = t;
521 while (*p)
522 p++;
523 p--; /* last character of defn */
524 while (p > t) {
525 if (*(p - 1) != ARGFLAG)
526 PUSHBACK(*p);
527 else {
528 switch (*p) {
529
530 case '#':
531 pbnum(argc - 2);
532 break;
533 case '0':
534 case '1':
535 case '2':
536 case '3':
537 case '4':
538 case '5':
539 case '6':
540 case '7':
541 case '8':
542 case '9':
543 if ((argno = *p - '0') < argc - 1)
544 pbstr(argv[argno + 1]);
545 break;
546 case '*':
547 if (argc > 2) {
548 for (n = argc - 1; n > 2; n--) {
549 pbstr(argv[n]);
550 pushback(COMMA);
551 }
552 pbstr(argv[2]);
553 }
554 break;
555 case '@':
556 if (argc > 2) {
557 for (n = argc - 1; n > 2; n--) {
558 pbstr(rquote);
559 pbstr(argv[n]);
560 pbstr(lquote);
561 pushback(COMMA);
562 }
563 pbstr(rquote);
564 pbstr(argv[2]);
565 pbstr(lquote);
566 }
567 break;
568 default:
569 PUSHBACK(*p);
570 PUSHBACK('$');
571 break;
572 }
573 p--;
574 }
575 p--;
576 }
577 if (p == t) /* do last character */
578 PUSHBACK(*p);
579}
580
581
582/*
583 * dodefine - install definition in the table
584 */
585void
586dodefine(const char *name, const char *defn)
587{
588 if (!*name && !mimic_gnu)
589 m4errx(1, "null definition.");
590 else
591 macro_define(name, defn);
592}
593
594/*
595 * dodefn - push back a quoted definition of
596 * the given name.
597 */
598static void
599dodefn(const char *name)
600{
601 struct macro_definition *p;
602
603 if ((p = lookup_macro_definition(name)) != NULL) {
604 if ((p->type & TYPEMASK) == MACRTYPE) {
605 pbstr(rquote);
606 pbstr(p->defn);
607 pbstr(lquote);
608 } else {
609 pbstr(p->defn);
610 pbstr(BUILTIN_MARKER);
611 }
612 }
613}
614
615/*
616 * dopushdef - install a definition in the hash table
617 * without removing a previous definition. Since
618 * each new entry is entered in *front* of the
619 * hash bucket, it hides a previous definition from
620 * lookup.
621 */
622static void
623dopushdef(const char *name, const char *defn)
624{
625 if (!*name && !mimic_gnu)
626 m4errx(1, "null definition.");
627 else
628 macro_pushdef(name, defn);
629}
630
631/*
632 * dump_one_def - dump the specified definition.
633 */
634static void
635dump_one_def(const char *name, struct macro_definition *p)
636{
637 if (!traceout)
638 traceout = stderr;
639 if (mimic_gnu) {
640 if ((p->type & TYPEMASK) == MACRTYPE)
641 fprintf(traceout, "%s:\t%s\n", name, p->defn);
642 else {
643 fprintf(traceout, "%s:\t<%s>\n", name, p->defn);
644 }
645 } else
646 fprintf(traceout, "`%s'\t`%s'\n", name, p->defn);
647}
648
649/*
650 * dodumpdef - dump the specified definitions in the hash
651 * table to stderr. If nothing is specified, the entire
652 * hash table is dumped.
653 */
654static void
655dodump(const char *argv[], int argc)
656{
657 int n;
658 struct macro_definition *p;
659
660 if (argc > 2) {
661 for (n = 2; n < argc; n++)
662 if ((p = lookup_macro_definition(argv[n])) != NULL)
663 dump_one_def(argv[n], p);
664 } else
665 macro_for_all(dump_one_def);
666}
667
668/*
669 * dotrace - mark some macros as traced/untraced depending upon on.
670 */
671static void
672dotrace(const char *argv[], int argc, int on)
673{
674 int n;
675
676 if (argc > 2) {
677 for (n = 2; n < argc; n++)
678 mark_traced(argv[n], on);
679 } else
680 mark_traced(NULL, on);
681}
682
683/*
684 * doifelse - select one of two alternatives - loop.
685 */
686static void
687doifelse(const char *argv[], int argc)
688{
689 cycle {
690 if (STREQ(argv[2], argv[3]))
691 pbstr(argv[4]);
692 else if (argc == 6)
693 pbstr(argv[5]);
694 else if (argc > 6) {
695 argv += 3;
696 argc -= 3;
697 continue;
698 }
699 break;
700 }
701}
702
703/*
704 * doinclude - include a given file.
705 */
706static int
707doincl(const char *ifile)
708{
709 if (ilevel + 1 == MAXINP)
710 m4errx(1, "too many include files.");
711 if (fopen_trypath(infile+ilevel+1, ifile) != NULL) {
712 ilevel++;
713 bbase[ilevel] = bufbase = bp;
714 return (1);
715 } else
716 return (0);
717}
718
719#ifdef EXTENDED
720/*
721 * dopaste - include a given file without any
722 * macro processing.
723 */
724static int
725dopaste(const char *pfile)
726{
727 FILE *pf;
728 int c;
729
730 if ((pf = fopen(pfile, "r")) != NULL) {
731 if (synch_lines)
732 fprintf(active, "#line 1 \"%s\"\n", pfile);
733 while ((c = getc(pf)) != EOF)
734 putc(c, active);
735 (void) fclose(pf);
736 emit_synchline();
737 return (1);
738 } else
739 return (0);
740}
741#endif
742
743/*
744 * dochq - change quote characters
745 */
746static void
747dochq(const char *argv[], int ac)
748{
749 if (ac == 2) {
750 lquote[0] = LQUOTE; lquote[1] = EOS;
751 rquote[0] = RQUOTE; rquote[1] = EOS;
752 } else {
753 strlcpy(lquote, argv[2], sizeof(lquote));
754 if (ac > 3) {
755 strlcpy(rquote, argv[3], sizeof(rquote));
756 } else {
757 rquote[0] = ECOMMT; rquote[1] = EOS;
758 }
759 }
760}
761
762/*
763 * dochc - change comment characters
764 */
765static void
766dochc(const char *argv[], int argc)
767{
768/* XXX Note that there is no difference between no argument and a single
769 * empty argument.
770 */
771 if (argc == 2) {
772 scommt[0] = EOS;
773 ecommt[0] = EOS;
774 } else {
775 strlcpy(scommt, argv[2], sizeof(scommt));
776 if (argc == 3) {
777 ecommt[0] = ECOMMT; ecommt[1] = EOS;
778 } else {
779 strlcpy(ecommt, argv[3], sizeof(ecommt));
780 }
781 }
782}
783
784/*
785 * dom4wrap - expand text at EOF
786 */
787static void
788dom4wrap(const char *text)
789{
790 if (wrapindex >= maxwraps) {
791 if (maxwraps == 0)
792 maxwraps = 16;
793 else
794 maxwraps *= 2;
795 m4wraps = xrealloc(m4wraps, maxwraps * sizeof(*m4wraps),
796 "too many m4wraps");
797 }
798 m4wraps[wrapindex++] = xstrdup(text);
799}
800
801/*
802 * dodivert - divert the output to a temporary file
803 */
804static void
805dodiv(int n)
806{
807 int fd;
808
809 oindex = n;
810 if (n >= maxout) {
811 if (mimic_gnu)
812 resizedivs(n + 10);
813 else
814 n = 0; /* bitbucket */
815 }
816
817 if (n < 0)
818 n = 0; /* bitbucket */
819 if (outfile[n] == NULL) {
820 char fname[] = _PATH_DIVNAME;
821
822 if ((fd = mkstemp(fname)) < 0 ||
823 (outfile[n] = fdopen(fd, "w+")) == NULL)
824 err(1, "%s: cannot divert", fname);
825 if (unlink(fname) == -1)
826 err(1, "%s: cannot unlink", fname);
827 }
828 active = outfile[n];
829}
830
831/*
832 * doundivert - undivert a specified output, or all
833 * other outputs, in numerical order.
834 */
835static void
836doundiv(const char *argv[], int argc)
837{
838 int ind;
839 int n;
840
841 if (argc > 2) {
842 for (ind = 2; ind < argc; ind++) {
843 const char *errstr;
844 n = strtonum(argv[ind], 1, INT_MAX, &errstr);
845 if (errstr) {
846 if (errno == EINVAL && mimic_gnu)
847 getdivfile(argv[ind]);
848 } else {
849 if (n < maxout && outfile[n] != NULL)
850 getdiv(n);
851 }
852 }
853 }
854 else
855 for (n = 1; n < maxout; n++)
856 if (outfile[n] != NULL)
857 getdiv(n);
858}
859
860/*
861 * dosub - select substring
862 */
863static void
864dosub(const char *argv[], int argc)
865{
866 const char *ap, *fc, *k;
867 int nc;
868
869 ap = argv[2]; /* target string */
870#ifdef EXPR
871 fc = ap + expr(argv[3]); /* first char */
872#else
873 fc = ap + atoi(argv[3]); /* first char */
874#endif
875 nc = strlen(fc);
876 if (argc >= 5)
877#ifdef EXPR
878 nc = min(nc, expr(argv[4]));
879#else
880 nc = min(nc, atoi(argv[4]));
881#endif
882 if (fc >= ap && fc < ap + strlen(ap))
883 for (k = fc + nc - 1; k >= fc; k--)
884 pushback(*k);
885}
886
887/*
888 * map:
889 * map every character of s1 that is specified in from
890 * into s3 and replace in s. (source s1 remains untouched)
891 *
892 * This is derived from the a standard implementation of map(s,from,to)
893 * function of ICON language. Within mapvec, we replace every character
894 * of "from" with the corresponding character in "to".
895 * If "to" is shorter than "from", than the corresponding entries are null,
896 * which means that those characters dissapear altogether.
897 */
898static void
899map(char *dest, const char *src, const char *from, const char *to)
900{
901 const char *tmp;
902 unsigned char sch, dch;
903 static char frombis[257];
904 static char tobis[257];
905 int i;
906 char seen[256];
907 static unsigned char mapvec[256] = {
908 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
909 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
910 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
911 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
912 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
913 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
914 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
915 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128,
916 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
917 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
918 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
919 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180,
920 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193,
921 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206,
922 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
923 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
924 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245,
925 246, 247, 248, 249, 250, 251, 252, 253, 254, 255
926 };
927
928 if (*src) {
929 if (mimic_gnu) {
930 /*
931 * expand character ranges on the fly
932 */
933 from = handledash(frombis, frombis + 256, from);
934 to = handledash(tobis, tobis + 256, to);
935 }
936 tmp = from;
937 /*
938 * create a mapping between "from" and
939 * "to"
940 */
941 for (i = 0; i < 256; i++)
942 seen[i] = 0;
943 while (*from) {
944 if (!seen[(unsigned char)(*from)]) {
945 mapvec[(unsigned char)(*from)] = (unsigned char)(*to);
946 seen[(unsigned char)(*from)] = 1;
947 }
948 from++;
949 if (*to)
950 to++;
951 }
952
953 while (*src) {
954 sch = (unsigned char)(*src++);
955 dch = mapvec[sch];
956 if ((*dest = (char)dch))
957 dest++;
958 }
959 /*
960 * restore all the changed characters
961 */
962 while (*tmp) {
963 mapvec[(unsigned char)(*tmp)] = (unsigned char)(*tmp);
964 tmp++;
965 }
966 }
967 *dest = '\0';
968}
969
970
971/*
972 * handledash:
973 * use buffer to copy the src string, expanding character ranges
974 * on the way.
975 */
976static const char *
977handledash(char *buffer, char *end, const char *src)
978{
979 char *p;
980
981 p = buffer;
982 while(*src) {
983 if (src[1] == '-' && src[2]) {
984 unsigned char i;
985 if ((unsigned char)src[0] <= (unsigned char)src[2]) {
986 for (i = (unsigned char)src[0];
987 i <= (unsigned char)src[2]; i++) {
988 *p++ = i;
989 if (p == end) {
990 *p = '\0';
991 return buffer;
992 }
993 }
994 } else {
995 for (i = (unsigned char)src[0];
996 i >= (unsigned char)src[2]; i--) {
997 *p++ = i;
998 if (p == end) {
999 *p = '\0';
1000 return buffer;
1001 }
1002 }
1003 }
1004 src += 3;
1005 } else
1006 *p++ = *src++;
1007 if (p == end)
1008 break;
1009 }
1010 *p = '\0';
1011 return buffer;
1012}