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