← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/collectd/oneiric

« back to all changes in this revision

Viewing changes to src/liboconfig/scanner.c

  • Committer: Bazaar Package Importer
  • Author(s): Morten Kjeldgaard
  • Date: 2008-11-18 15:54:20 UTC
  • mfrom: (1.1.5 upstream) (3.1.1 lenny)
  • Revision ID: james.westby@ubuntu.com-20081118155420-sc2mxv2pebafkmon
Tags: 4.4.2-2ubuntu1
https://launchpad.net/bugs/298828
* Merge from Debian unstable (LP: #298828). Remaining Ubuntu changes:
* Add ubuntu_in6-glibc28.dpatch patch, fix FTBFS.
* Add ubuntu_hardening.dpatch patch, fix FTBFS.
* Add ubuntu_perl.c.dpatch, fix FTBFS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/liboconfig/scanner.c
8
8
#define FLEX_SCANNER
9
9
#define YY_FLEX_MAJOR_VERSION 2
10
10
#define YY_FLEX_MINOR_VERSION 5
11
 
#define YY_FLEX_SUBMINOR_VERSION 33
 
11
#define YY_FLEX_SUBMINOR_VERSION 35
12
12
#if YY_FLEX_SUBMINOR_VERSION > 0
13
13
#define FLEX_BETA
14
14
#endif
30
30
 
31
31
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
32
32
 
33
 
#if __STDC_VERSION__ >= 199901L
 
33
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
34
34
 
35
35
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
36
36
 * if you want the limit (max/min) macros for int types. 
53
53
typedef unsigned char flex_uint8_t; 
54
54
typedef unsigned short int flex_uint16_t;
55
55
typedef unsigned int flex_uint32_t;
56
 
#endif /* ! C99 */
57
56
 
58
57
/* Limits of integral types. */
59
58
#ifndef INT8_MIN
84
83
#define UINT32_MAX             (4294967295U)
85
84
#endif
86
85
 
 
86
#endif /* ! C99 */
 
87
 
87
88
#endif /* ! FLEXINT_H */
88
89
 
89
90
#ifdef __cplusplus
93
94
 
94
95
#else   /* ! __cplusplus */
95
96
 
96
 
#if __STDC__
 
97
/* C99 requires __STDC__ to be defined as 1. */
 
98
#if defined (__STDC__)
97
99
 
98
100
#define YY_USE_CONST
99
101
 
100
 
#endif  /* __STDC__ */
 
102
#endif  /* defined (__STDC__) */
101
103
#endif  /* ! __cplusplus */
102
104
 
103
105
#ifdef YY_USE_CONST
190
192
 
191
193
#define unput(c) yyunput( c, (yytext_ptr)  )
192
194
 
193
 
/* The following is because we cannot portably get our hands on size_t
194
 
 * (without autoconf's help, which isn't available because we want
195
 
 * flex-generated scanners to compile on their own).
196
 
 */
197
 
 
198
195
#ifndef YY_TYPEDEF_YY_SIZE_T
199
196
#define YY_TYPEDEF_YY_SIZE_T
200
 
typedef unsigned int yy_size_t;
 
197
typedef size_t yy_size_t;
201
198
#endif
202
199
 
203
200
#ifndef YY_STRUCT_YY_BUFFER_STATE
348
345
 
349
346
/* Begin user sect3 */
350
347
 
351
 
#define yywrap() 1
 
348
#define yywrap(n) 1
352
349
#define YY_SKIP_YYWRAP
353
350
 
354
351
typedef unsigned char YY_CHAR;
617
614
#include "oconfig.h"
618
615
#include "aux_types.h"
619
616
#include "parser.h"
620
 
#line 621 "scanner.c"
 
617
#line 618 "scanner.c"
621
618
 
622
619
#define INITIAL 0
623
620
 
635
632
 
636
633
static int yy_init_globals (void );
637
634
 
 
635
/* Accessor methods to globals.
 
636
   These are made visible to non-reentrant scanners for convenience. */
 
637
 
 
638
int yylex_destroy (void );
 
639
 
 
640
int yyget_debug (void );
 
641
 
 
642
void yyset_debug (int debug_flag  );
 
643
 
 
644
YY_EXTRA_TYPE yyget_extra (void );
 
645
 
 
646
void yyset_extra (YY_EXTRA_TYPE user_defined  );
 
647
 
 
648
FILE *yyget_in (void );
 
649
 
 
650
void yyset_in  (FILE * in_str  );
 
651
 
 
652
FILE *yyget_out (void );
 
653
 
 
654
void yyset_out  (FILE * out_str  );
 
655
 
 
656
int yyget_leng (void );
 
657
 
 
658
char *yyget_text (void );
 
659
 
 
660
int yyget_lineno (void );
 
661
 
 
662
void yyset_lineno (int line_number  );
 
663
 
638
664
/* Macros after this point can all be overridden by user definitions in
639
665
 * section 1.
640
666
 */
677
703
/* This used to be an fputs(), but since the string might contain NUL's,
678
704
 * we now use fwrite().
679
705
 */
680
 
#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 
706
#define ECHO fwrite( yytext, yyleng, 1, yyout )
681
707
#endif
682
708
 
683
709
/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
772
798
    
773
799
#line 42 "scanner.l"
774
800
 
775
 
#line 776 "scanner.c"
 
801
#line 802 "scanner.c"
776
802
 
777
803
        if ( !(yy_init) )
778
804
                {
929
955
#line 59 "scanner.l"
930
956
ECHO;
931
957
        YY_BREAK
932
 
#line 933 "scanner.c"
 
958
#line 959 "scanner.c"
933
959
case YY_STATE_EOF(INITIAL):
934
960
        yyterminate();
935
961
 
1184
1210
        else
1185
1211
                ret_val = EOB_ACT_CONTINUE_SCAN;
1186
1212
 
 
1213
        if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
 
1214
                /* Extend the array by 50%, plus the number we really need. */
 
1215
                yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
 
1216
                YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
 
1217
                if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
 
1218
                        YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
 
1219
        }
 
1220
 
1187
1221
        (yy_n_chars) += number_to_move;
1188
1222
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1189
1223
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1608
1642
                (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1609
1643
                                                                (num_to_alloc * sizeof(struct yy_buffer_state*)
1610
1644
                                                                );
1611
 
                
 
1645
                if ( ! (yy_buffer_stack) )
 
1646
                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
 
1647
                                                                  
1612
1648
                memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1613
1649
                                
1614
1650
                (yy_buffer_stack_max) = num_to_alloc;
1626
1662
                                                                ((yy_buffer_stack),
1627
1663
                                                                num_to_alloc * sizeof(struct yy_buffer_state*)
1628
1664
                                                                );
 
1665
                if ( ! (yy_buffer_stack) )
 
1666
                        YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1629
1667
 
1630
1668
                /* zero only the new slots.*/
1631
1669
                memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));