![[BACK]](/icons/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / lex|
Return to misc.c CVS log | Up to [local] / src / usr.bin / lex |
1.1 deraadt 1: /* misc - miscellaneous flex routines */
2:
3: /*-
4: * Copyright (c) 1990 The Regents of the University of California.
5: * All rights reserved.
6: *
7: * This code is derived from software contributed to Berkeley by
8: * Vern Paxson.
9: *
10: * The United States Government has rights in this work pursuant
11: * to contract no. DE-AC03-76SF00098 between the United States
12: * Department of Energy and the University of California.
13: *
14: * Redistribution and use in source and binary forms are permitted provided
15: * that: (1) source distributions retain this entire copyright notice and
16: * comment, and (2) distributions including binaries display the following
17: * acknowledgement: ``This product includes software developed by the
18: * University of California, Berkeley and its contributors'' in the
19: * documentation or other materials provided with the distribution and in
20: * all advertising materials mentioning features or use of this software.
21: * Neither the name of the University nor the names of its contributors may
22: * be used to endorse or promote products derived from this software without
23: * specific prior written permission.
24: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
25: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
26: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
27: */
28:
29: /* $Header: /a/cvsroot/src/usr.bin/lex/misc.c,v 1.7 1995/05/05 05:35:35 jtc Exp $ */
30:
31: #include "flexdef.h"
32:
33:
34: void action_define( defname, value )
35: char *defname;
36: int value;
37: {
38: char buf[MAXLINE];
39:
40: if ( (int) strlen( defname ) > MAXLINE / 2 )
41: {
42: format_pinpoint_message( _( "name \"%s\" ridiculously long" ),
43: defname );
44: return;
45: }
46:
47: sprintf( buf, "#define %s %d\n", defname, value );
48: add_action( buf );
49: }
50:
51:
52: void add_action( new_text )
53: char *new_text;
54: {
55: int len = strlen( new_text );
56:
57: while ( len + action_index >= action_size - 10 /* slop */ )
58: {
59: int new_size = action_size * 2;
60:
61: if ( new_size <= 0 )
62: /* Increase just a little, to try to avoid overflow
63: * on 16-bit machines.
64: */
65: action_size += action_size / 8;
66: else
67: action_size = new_size;
68:
69: action_array =
70: reallocate_character_array( action_array, action_size );
71: }
72:
73: strcpy( &action_array[action_index], new_text );
74:
75: action_index += len;
76: }
77:
78:
79: /* allocate_array - allocate memory for an integer array of the given size */
80:
81: void *allocate_array( size, element_size )
82: int size;
83: size_t element_size;
84: {
85: register void *mem;
86: size_t num_bytes = element_size * size;
87:
88: mem = flex_alloc( num_bytes );
89: if ( ! mem )
90: flexfatal(
91: _( "memory allocation failed in allocate_array()" ) );
92:
93: return mem;
94: }
95:
96:
97: /* all_lower - true if a string is all lower-case */
98:
99: int all_lower( str )
100: register char *str;
101: {
102: while ( *str )
103: {
104: if ( ! isascii( (Char) *str ) || ! islower( *str ) )
105: return 0;
106: ++str;
107: }
108:
109: return 1;
110: }
111:
112:
113: /* all_upper - true if a string is all upper-case */
114:
115: int all_upper( str )
116: register char *str;
117: {
118: while ( *str )
119: {
120: if ( ! isascii( (Char) *str ) || ! isupper( *str ) )
121: return 0;
122: ++str;
123: }
124:
125: return 1;
126: }
127:
128:
129: /* bubble - bubble sort an integer array in increasing order
130: *
131: * synopsis
132: * int v[n], n;
133: * void bubble( v, n );
134: *
135: * description
136: * sorts the first n elements of array v and replaces them in
137: * increasing order.
138: *
139: * passed
140: * v - the array to be sorted
141: * n - the number of elements of 'v' to be sorted
142: */
143:
144: void bubble( v, n )
145: int v[], n;
146: {
147: register int i, j, k;
148:
149: for ( i = n; i > 1; --i )
150: for ( j = 1; j < i; ++j )
151: if ( v[j] > v[j + 1] ) /* compare */
152: {
153: k = v[j]; /* exchange */
154: v[j] = v[j + 1];
155: v[j + 1] = k;
156: }
157: }
158:
159:
160: /* check_char - checks a character to make sure it's within the range
161: * we're expecting. If not, generates fatal error message
162: * and exits.
163: */
164:
165: void check_char( c )
166: int c;
167: {
168: if ( c >= CSIZE )
169: lerrsf( _( "bad character '%s' detected in check_char()" ),
170: readable_form( c ) );
171:
172: if ( c >= csize )
173: lerrsf(
174: _( "scanner requires -8 flag to use the character %s" ),
175: readable_form( c ) );
176: }
177:
178:
179:
180: /* clower - replace upper-case letter to lower-case */
181:
182: Char clower( c )
183: register int c;
184: {
185: return (Char) ((isascii( c ) && isupper( c )) ? tolower( c ) : c);
186: }
187:
188:
189: /* copy_string - returns a dynamically allocated copy of a string */
190:
191: char *copy_string( str )
192: register const char *str;
193: {
194: register const char *c1;
195: register char *c2;
196: char *copy;
197: unsigned int size;
198:
199: /* find length */
200: for ( c1 = str; *c1; ++c1 )
201: ;
202:
203: size = (c1 - str + 1) * sizeof( char );
204: copy = (char *) flex_alloc( size );
205:
206: if ( copy == NULL )
207: flexfatal( _( "dynamic memory failure in copy_string()" ) );
208:
209: for ( c2 = copy; (*c2++ = *str++) != 0; )
210: ;
211:
212: return copy;
213: }
214:
215:
216: /* copy_unsigned_string -
217: * returns a dynamically allocated copy of a (potentially) unsigned string
218: */
219:
220: Char *copy_unsigned_string( str )
221: register Char *str;
222: {
223: register Char *c;
224: Char *copy;
225:
226: /* find length */
227: for ( c = str; *c; ++c )
228: ;
229:
230: copy = allocate_Character_array( c - str + 1 );
231:
232: for ( c = copy; (*c++ = *str++) != 0; )
233: ;
234:
235: return copy;
236: }
237:
238:
239: /* cshell - shell sort a character array in increasing order
240: *
241: * synopsis
242: *
243: * Char v[n];
244: * int n, special_case_0;
245: * cshell( v, n, special_case_0 );
246: *
247: * description
248: * Does a shell sort of the first n elements of array v.
249: * If special_case_0 is true, then any element equal to 0
250: * is instead assumed to have infinite weight.
251: *
252: * passed
253: * v - array to be sorted
254: * n - number of elements of v to be sorted
255: */
256:
257: void cshell( v, n, special_case_0 )
258: Char v[];
259: int n, special_case_0;
260: {
261: int gap, i, j, jg;
262: Char k;
263:
264: for ( gap = n / 2; gap > 0; gap = gap / 2 )
265: for ( i = gap; i < n; ++i )
266: for ( j = i - gap; j >= 0; j = j - gap )
267: {
268: jg = j + gap;
269:
270: if ( special_case_0 )
271: {
272: if ( v[jg] == 0 )
273: break;
274:
275: else if ( v[j] != 0 && v[j] <= v[jg] )
276: break;
277: }
278:
279: else if ( v[j] <= v[jg] )
280: break;
281:
282: k = v[j];
283: v[j] = v[jg];
284: v[jg] = k;
285: }
286: }
287:
288:
289: /* dataend - finish up a block of data declarations */
290:
291: void dataend()
292: {
293: if ( datapos > 0 )
294: dataflush();
295:
296: /* add terminator for initialization; { for vi */
297: outn( " } ;\n" );
298:
299: dataline = 0;
300: datapos = 0;
301: }
302:
303:
304: /* dataflush - flush generated data statements */
305:
306: void dataflush()
307: {
308: outc( '\n' );
309:
310: if ( ++dataline >= NUMDATALINES )
311: {
312: /* Put out a blank line so that the table is grouped into
313: * large blocks that enable the user to find elements easily.
314: */
315: outc( '\n' );
316: dataline = 0;
317: }
318:
319: /* Reset the number of characters written on the current line. */
320: datapos = 0;
321: }
322:
323:
324: /* flexerror - report an error message and terminate */
325:
326: void flexerror( msg )
327: const char msg[];
328: {
329: fprintf( stderr, "%s: %s\n", program_name, msg );
330: flexend( 1 );
331: }
332:
333:
334: /* flexfatal - report a fatal error message and terminate */
335:
336: void flexfatal( msg )
337: const char msg[];
338: {
339: fprintf( stderr, _( "%s: fatal internal error, %s\n" ),
340: program_name, msg );
341: exit( 1 );
342: }
343:
344:
345: /* htoi - convert a hexadecimal digit string to an integer value */
346:
347: int htoi( str )
348: Char str[];
349: {
350: unsigned int result;
351:
352: (void) sscanf( (char *) str, "%x", &result );
353:
354: return result;
355: }
356:
357:
358: /* lerrif - report an error message formatted with one integer argument */
359:
360: void lerrif( msg, arg )
361: const char msg[];
362: int arg;
363: {
364: char errmsg[MAXLINE];
365: (void) sprintf( errmsg, msg, arg );
366: flexerror( errmsg );
367: }
368:
369:
370: /* lerrsf - report an error message formatted with one string argument */
371:
372: void lerrsf( msg, arg )
373: const char msg[], arg[];
374: {
375: char errmsg[MAXLINE];
376:
377: (void) sprintf( errmsg, msg, arg );
378: flexerror( errmsg );
379: }
380:
381:
382: /* line_directive_out - spit out a "#line" statement */
383:
384: void line_directive_out( output_file, do_infile )
385: FILE *output_file;
386: int do_infile;
387: {
388: char directive[MAXLINE], filename[MAXLINE];
389: char *s1, *s2, *s3;
390: static char line_fmt[] = "#line %d \"%s\"\n";
391:
392: if ( ! gen_line_dirs )
393: return;
394:
395: if ( (do_infile && ! infilename) || (! do_infile && ! outfilename) )
396: /* don't know the filename to use, skip */
397: return;
398:
399: s1 = do_infile ? infilename : outfilename;
400: s2 = filename;
401: s3 = &filename[sizeof( filename ) - 2];
402:
403: while ( s2 < s3 && *s1 )
404: {
405: if ( *s1 == '\\' )
406: /* Escape the '\' */
407: *s2++ = '\\';
408:
409: *s2++ = *s1++;
410: }
411:
412: *s2 = '\0';
413:
414: if ( do_infile )
415: sprintf( directive, line_fmt, linenum, filename );
416: else
417: {
418: if ( output_file == stdout )
419: /* Account for the line directive itself. */
420: ++out_linenum;
421:
422: sprintf( directive, line_fmt, out_linenum, filename );
423: }
424:
425: /* If output_file is nil then we should put the directive in
426: * the accumulated actions.
427: */
428: if ( output_file )
429: {
430: fputs( directive, output_file );
431: }
432: else
433: add_action( directive );
434: }
435:
436:
437: /* mark_defs1 - mark the current position in the action array as
438: * representing where the user's section 1 definitions end
439: * and the prolog begins
440: */
441: void mark_defs1()
442: {
443: defs1_offset = 0;
444: action_array[action_index++] = '\0';
445: action_offset = prolog_offset = action_index;
446: action_array[action_index] = '\0';
447: }
448:
449:
450: /* mark_prolog - mark the current position in the action array as
451: * representing the end of the action prolog
452: */
453: void mark_prolog()
454: {
455: action_array[action_index++] = '\0';
456: action_offset = action_index;
457: action_array[action_index] = '\0';
458: }
459:
460:
461: /* mk2data - generate a data statement for a two-dimensional array
462: *
463: * Generates a data statement initializing the current 2-D array to "value".
464: */
465: void mk2data( value )
466: int value;
467: {
468: if ( datapos >= NUMDATAITEMS )
469: {
470: outc( ',' );
471: dataflush();
472: }
473:
474: if ( datapos == 0 )
475: /* Indent. */
476: out( " " );
477:
478: else
479: outc( ',' );
480:
481: ++datapos;
482:
483: out_dec( "%5d", value );
484: }
485:
486:
487: /* mkdata - generate a data statement
488: *
489: * Generates a data statement initializing the current array element to
490: * "value".
491: */
492: void mkdata( value )
493: int value;
494: {
495: if ( datapos >= NUMDATAITEMS )
496: {
497: outc( ',' );
498: dataflush();
499: }
500:
501: if ( datapos == 0 )
502: /* Indent. */
503: out( " " );
504: else
505: outc( ',' );
506:
507: ++datapos;
508:
509: out_dec( "%5d", value );
510: }
511:
512:
513: /* myctoi - return the integer represented by a string of digits */
514:
515: int myctoi( array )
516: char array[];
517: {
518: int val = 0;
519:
520: (void) sscanf( array, "%d", &val );
521:
522: return val;
523: }
524:
525:
526: /* myesc - return character corresponding to escape sequence */
527:
528: Char myesc( array )
529: Char array[];
530: {
531: Char c, esc_char;
532:
533: switch ( array[1] )
534: {
535: case 'b': return '\b';
536: case 'f': return '\f';
537: case 'n': return '\n';
538: case 'r': return '\r';
539: case 't': return '\t';
540:
541: #if __STDC__
542: case 'a': return '\a';
543: case 'v': return '\v';
544: #else
545: case 'a': return '\007';
546: case 'v': return '\013';
547: #endif
548:
549: case '0':
550: case '1':
551: case '2':
552: case '3':
553: case '4':
554: case '5':
555: case '6':
556: case '7':
557: { /* \<octal> */
558: int sptr = 1;
559:
560: while ( isascii( array[sptr] ) &&
561: isdigit( array[sptr] ) )
562: /* Don't increment inside loop control
563: * because if isdigit() is a macro it might
564: * expand into multiple increments ...
565: */
566: ++sptr;
567:
568: c = array[sptr];
569: array[sptr] = '\0';
570:
571: esc_char = otoi( array + 1 );
572:
573: array[sptr] = c;
574:
575: return esc_char;
576: }
577:
578: case 'x':
579: { /* \x<hex> */
580: int sptr = 2;
581:
582: while ( isascii( array[sptr] ) &&
583: isxdigit( (char) array[sptr] ) )
584: /* Don't increment inside loop control
585: * because if isdigit() is a macro it might
586: * expand into multiple increments ...
587: */
588: ++sptr;
589:
590: c = array[sptr];
591: array[sptr] = '\0';
592:
593: esc_char = htoi( array + 2 );
594:
595: array[sptr] = c;
596:
597: return esc_char;
598: }
599:
600: default:
601: return array[1];
602: }
603: }
604:
605:
606: /* otoi - convert an octal digit string to an integer value */
607:
608: int otoi( str )
609: Char str[];
610: {
611: unsigned int result;
612:
613: (void) sscanf( (char *) str, "%o", &result );
614: return result;
615: }
616:
617:
618: /* out - various flavors of outputing a (possibly formatted) string for the
619: * generated scanner, keeping track of the line count.
620: */
621:
622: void out( str )
623: const char str[];
624: {
625: fputs( str, stdout );
626: out_line_count( str );
627: }
628:
629: void out_dec( fmt, n )
630: const char fmt[];
631: int n;
632: {
633: printf( fmt, n );
634: out_line_count( fmt );
635: }
636:
637: void out_dec2( fmt, n1, n2 )
638: const char fmt[];
639: int n1, n2;
640: {
641: printf( fmt, n1, n2 );
642: out_line_count( fmt );
643: }
644:
645: void out_hex( fmt, x )
646: const char fmt[];
647: unsigned int x;
648: {
649: printf( fmt, x );
650: out_line_count( fmt );
651: }
652:
653: void out_line_count( str )
654: const char str[];
655: {
656: register int i;
657:
658: for ( i = 0; str[i]; ++i )
659: if ( str[i] == '\n' )
660: ++out_linenum;
661: }
662:
663: void out_str( fmt, str )
664: const char fmt[], str[];
665: {
666: printf( fmt, str );
667: out_line_count( fmt );
668: out_line_count( str );
669: }
670:
671: void out_str3( fmt, s1, s2, s3 )
672: const char fmt[], s1[], s2[], s3[];
673: {
674: printf( fmt, s1, s2, s3 );
675: out_line_count( fmt );
676: out_line_count( s1 );
677: out_line_count( s2 );
678: out_line_count( s3 );
679: }
680:
681: void out_str_dec( fmt, str, n )
682: const char fmt[], str[];
683: int n;
684: {
685: printf( fmt, str, n );
686: out_line_count( fmt );
687: out_line_count( str );
688: }
689:
690: void outc( c )
691: int c;
692: {
693: putc( c, stdout );
694:
695: if ( c == '\n' )
696: ++out_linenum;
697: }
698:
699: void outn( str )
700: const char str[];
701: {
702: puts( str );
703: out_line_count( str );
704: ++out_linenum;
705: }
706:
707:
708: /* readable_form - return the the human-readable form of a character
709: *
710: * The returned string is in static storage.
711: */
712:
713: char *readable_form( c )
714: register int c;
715: {
716: static char rform[10];
717:
718: if ( (c >= 0 && c < 32) || c >= 127 )
719: {
720: switch ( c )
721: {
722: case '\b': return "\\b";
723: case '\f': return "\\f";
724: case '\n': return "\\n";
725: case '\r': return "\\r";
726: case '\t': return "\\t";
727:
728: #if __STDC__
729: case '\a': return "\\a";
730: case '\v': return "\\v";
731: #endif
732:
733: default:
734: (void) sprintf( rform, "\\%.3o",
735: (unsigned int) c );
736: return rform;
737: }
738: }
739:
740: else if ( c == ' ' )
741: return "' '";
742:
743: else
744: {
745: rform[0] = c;
746: rform[1] = '\0';
747:
748: return rform;
749: }
750: }
751:
752:
753: /* reallocate_array - increase the size of a dynamic array */
754:
755: void *reallocate_array( array, size, element_size )
756: void *array;
757: int size;
758: size_t element_size;
759: {
760: register void *new_array;
761: size_t num_bytes = element_size * size;
762:
763: new_array = flex_realloc( array, num_bytes );
764: if ( ! new_array )
765: flexfatal( _( "attempt to increase array size failed" ) );
766:
767: return new_array;
768: }
769:
770:
771: /* skelout - write out one section of the skeleton file
772: *
773: * Description
774: * Copies skelfile or skel array to stdout until a line beginning with
775: * "%%" or EOF is found.
776: */
777: void skelout()
778: {
779: char buf_storage[MAXLINE];
780: char *buf = buf_storage;
781: int do_copy = 1;
782:
783: /* Loop pulling lines either from the skelfile, if we're using
784: * one, or from the skel[] array.
785: */
786: while ( skelfile ?
787: (fgets( buf, MAXLINE, skelfile ) != NULL) :
788: ((buf = (char *) skel[skel_ind++]) != 0) )
789: { /* copy from skel array */
790: if ( buf[0] == '%' )
791: { /* control line */
792: switch ( buf[1] )
793: {
794: case '%':
795: return;
796:
797: case '+':
798: do_copy = C_plus_plus;
799: break;
800:
801: case '-':
802: do_copy = ! C_plus_plus;
803: break;
804:
805: case '*':
806: do_copy = 1;
807: break;
808:
809: default:
810: flexfatal(
811: _( "bad line in skeleton file" ) );
812: }
813: }
814:
815: else if ( do_copy )
816: {
817: if ( skelfile )
818: /* Skeleton file reads include final
819: * newline, skel[] array does not.
820: */
821: out( buf );
822: else
823: outn( buf );
824: }
825: }
826: }
827:
828:
829: /* transition_struct_out - output a yy_trans_info structure
830: *
831: * outputs the yy_trans_info structure with the two elements, element_v and
832: * element_n. Formats the output with spaces and carriage returns.
833: */
834:
835: void transition_struct_out( element_v, element_n )
836: int element_v, element_n;
837: {
838: out_dec2( " {%4d,%4d },", element_v, element_n );
839:
840: datapos += TRANS_STRUCT_PRINT_LENGTH;
841:
842: if ( datapos >= 79 - TRANS_STRUCT_PRINT_LENGTH )
843: {
844: outc( '\n' );
845:
846: if ( ++dataline % 10 == 0 )
847: outc( '\n' );
848:
849: datapos = 0;
850: }
851: }
852:
853:
854: /* The following is only needed when building flex's parser using certain
855: * broken versions of bison.
856: */
857: void *yy_flex_xmalloc( size )
858: int size;
859: {
860: void *result = flex_alloc( (size_t) size );
861:
862: if ( ! result )
863: flexfatal(
864: _( "memory allocation failed in yy_flex_xmalloc()" ) );
865:
866: return result;
867: }
868:
869:
870: /* zero_out - set a region of memory to 0
871: *
872: * Sets region_ptr[0] through region_ptr[size_in_bytes - 1] to zero.
873: */
874:
875: void zero_out( region_ptr, size_in_bytes )
876: char *region_ptr;
877: size_t size_in_bytes;
878: {
879: register char *rp, *rp_end;
880:
881: rp = region_ptr;
882: rp_end = region_ptr + size_in_bytes;
883:
884: while ( rp < rp_end )
885: *rp++ = 0;
886: }