← Back to branch summary

~ubuntu-branches/ubuntu/saucy/xorg-server/saucy

« back to all changes in this revision

Viewing changes to hw/dmx/config/scanner.c

  • Committer: Package Import Robot
  • Author(s): Maarten Lankhorst
  • Date: 2013-07-16 09:36:06 UTC
  • mfrom: (1.1.57)
  • Revision ID: package-import@ubuntu.com-20130716093606-w822ywwf4bcwpylw
Tags: 2:1.14.2-0ubuntu1
https://launchpad.net/bugs/1156498
* New upstream release. (LP: #1156498)
* Remove upstreamed patch.
  - xf86setdesired-hybrid.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/dmx/config/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 36
 
11
#define YY_FLEX_SUBMINOR_VERSION 35
12
12
#if YY_FLEX_SUBMINOR_VERSION > 0
13
13
#define FLEX_BETA
14
14
#endif
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 */
56
57
 
57
58
/* Limits of integral types. */
58
59
#ifndef INT8_MIN
83
84
#define UINT32_MAX             (4294967295U)
84
85
#endif
85
86
 
86
 
#endif /* ! C99 */
87
 
 
88
87
#endif /* ! FLEXINT_H */
89
88
 
90
89
#ifdef __cplusplus
153
152
typedef struct yy_buffer_state *YY_BUFFER_STATE;
154
153
#endif
155
154
 
156
 
#ifndef YY_TYPEDEF_YY_SIZE_T
157
 
#define YY_TYPEDEF_YY_SIZE_T
158
 
typedef size_t yy_size_t;
159
 
#endif
160
 
 
161
 
extern yy_size_t yyleng;
 
155
extern int yyleng;
162
156
 
163
157
extern FILE *yyin, *yyout;
164
158
 
184
178
 
185
179
#define unput(c) yyunput( c, (yytext_ptr)  )
186
180
 
 
181
#ifndef YY_TYPEDEF_YY_SIZE_T
 
182
#define YY_TYPEDEF_YY_SIZE_T
 
183
typedef size_t yy_size_t;
 
184
#endif
 
185
 
187
186
#ifndef YY_STRUCT_YY_BUFFER_STATE
188
187
#define YY_STRUCT_YY_BUFFER_STATE
189
188
struct yy_buffer_state
201
200
        /* Number of characters read into yy_ch_buf, not including EOB
202
201
         * characters.
203
202
         */
204
 
        yy_size_t yy_n_chars;
 
203
        int yy_n_chars;
205
204
 
206
205
        /* Whether we "own" the buffer - i.e., we know we created it,
207
206
         * and can realloc() it to grow it, and should free() it to
271
270
 
272
271
/* yy_hold_char holds the character lost when yytext is formed. */
273
272
static char yy_hold_char;
274
 
static yy_size_t yy_n_chars;            /* number of characters read into yy_ch_buf */
275
 
yy_size_t yyleng;
 
273
static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 
274
int yyleng;
276
275
 
277
276
/* Points to current character in buffer. */
278
277
static char *yy_c_buf_p = (char *) 0;
300
299
 
301
300
YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
302
301
YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
303
 
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len  );
 
302
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
304
303
 
305
304
void *yyalloc (yy_size_t  );
306
305
void *yyrealloc (void *,yy_size_t  );
546
545
static int getcomment(int token, const char *text, int leng);
547
546
static int lineno = 1;
548
547
 
549
 
#line 550 "scanner.c"
 
548
#line 549 "scanner.c"
550
549
 
551
550
#define INITIAL 0
552
551
#define OTHER 1
586
585
 
587
586
void yyset_out  (FILE * out_str  );
588
587
 
589
 
yy_size_t yyget_leng (void );
 
588
int yyget_leng (void );
590
589
 
591
590
char *yyget_text (void );
592
591
 
647
646
        if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
648
647
                { \
649
648
                int c = '*'; \
650
 
                size_t n; \
 
649
                unsigned n; \
651
650
                for ( n = 0; n < max_size && \
652
651
                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
653
652
                        buf[n] = (char) c; \
734
733
    
735
734
#line 63 "scanner.l"
736
735
 
737
 
#line 738 "scanner.c"
 
736
#line 737 "scanner.c"
738
737
 
739
738
        if ( !(yy_init) )
740
739
                {
924
923
#line 84 "scanner.l"
925
924
ECHO;
926
925
        YY_BREAK
927
 
#line 928 "scanner.c"
 
926
#line 927 "scanner.c"
928
927
 
929
928
        case YY_END_OF_BUFFER:
930
929
                {
1108
1107
 
1109
1108
        else
1110
1109
                {
1111
 
                        yy_size_t num_to_read =
 
1110
                        int num_to_read =
1112
1111
                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1113
1112
 
1114
1113
                while ( num_to_read <= 0 )
1115
1114
                        { /* Not enough room in the buffer - grow it. */
1116
1115
 
1117
1116
                        /* just a shorter name for the current buffer */
1118
 
                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
 
1117
                        YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1119
1118
 
1120
1119
                        int yy_c_buf_p_offset =
1121
1120
                                (int) ((yy_c_buf_p) - b->yy_ch_buf);
1122
1121
 
1123
1122
                        if ( b->yy_is_our_buffer )
1124
1123
                                {
1125
 
                                yy_size_t new_size = b->yy_buf_size * 2;
 
1124
                                int new_size = b->yy_buf_size * 2;
1126
1125
 
1127
1126
                                if ( new_size <= 0 )
1128
1127
                                        b->yy_buf_size += b->yy_buf_size / 8;
1153
1152
 
1154
1153
                /* Read in more data. */
1155
1154
                YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1156
 
                        (yy_n_chars), num_to_read );
 
1155
                        (yy_n_chars), (size_t) num_to_read );
1157
1156
 
1158
1157
                YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1159
1158
                }
1249
1248
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1250
1249
        yy_is_jam = (yy_current_state == 72);
1251
1250
 
1252
 
                return yy_is_jam ? 0 : yy_current_state;
 
1251
        return yy_is_jam ? 0 : yy_current_state;
1253
1252
}
1254
1253
 
1255
1254
    static void yyunput (int c, register char * yy_bp )
1264
1263
        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1265
1264
                { /* need to shift things up to make room */
1266
1265
                /* +2 for EOB chars. */
1267
 
                register yy_size_t number_to_move = (yy_n_chars) + 2;
 
1266
                register int number_to_move = (yy_n_chars) + 2;
1268
1267
                register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1269
1268
                                        YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1270
1269
                register char *source =
1313
1312
 
1314
1313
                else
1315
1314
                        { /* need more input */
1316
 
                        yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
 
1315
                        int offset = (yy_c_buf_p) - (yytext_ptr);
1317
1316
                        ++(yy_c_buf_p);
1318
1317
 
1319
1318
                        switch ( yy_get_next_buffer(  ) )
1475
1474
        yyfree((void *) b  );
1476
1475
}
1477
1476
 
 
1477
#ifndef __cplusplus
 
1478
extern int isatty (int );
 
1479
#endif /* __cplusplus */
 
1480
    
1478
1481
/* Initializes or reinitializes a buffer.
1479
1482
 * This function is sometimes called more than once on the same buffer,
1480
1483
 * such as during a yyrestart() or at EOF.
1587
1590
 */
1588
1591
static void yyensure_buffer_stack (void)
1589
1592
{
1590
 
        yy_size_t num_to_alloc;
 
1593
        int num_to_alloc;
1591
1594
    
1592
1595
        if (!(yy_buffer_stack)) {
1593
1596
 
1679
1682
 
1680
1683
/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1681
1684
 * scan from a @e copy of @a bytes.
1682
 
 * @param yybytes the byte buffer to scan
1683
 
 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
 
1685
 * @param bytes the byte buffer to scan
 
1686
 * @param len the number of bytes in the buffer pointed to by @a bytes.
1684
1687
 * 
1685
1688
 * @return the newly allocated buffer state object.
1686
1689
 */
1687
 
YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, yy_size_t  _yybytes_len )
 
1690
YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
1688
1691
{
1689
1692
        YY_BUFFER_STATE b;
1690
1693
        char *buf;
1771
1774
/** Get the length of the current token.
1772
1775
 * 
1773
1776
 */
1774
 
yy_size_t yyget_leng  (void)
 
1777
int yyget_leng  (void)
1775
1778
{
1776
1779
        return yyleng;
1777
1780
}