10
10
#define YY_FLEX_MAJOR_VERSION 2
11
11
#define YY_FLEX_MINOR_VERSION 5
12
#define YY_FLEX_SUBMINOR_VERSION 31
12
#define YY_FLEX_SUBMINOR_VERSION 33
13
13
#if YY_FLEX_SUBMINOR_VERSION > 0
32
32
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
34
#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
34
#if __STDC_VERSION__ >= 199901L
36
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
37
* if you want the limit (max/min) macros for int types.
39
#ifndef __STDC_LIMIT_MACROS
40
#define __STDC_LIMIT_MACROS 1
35
43
#include <inttypes.h>
36
44
typedef int8_t flex_int8_t;
37
45
typedef uint8_t flex_uint8_t;
154
162
#define YY_BUF_SIZE 16384
165
/* The state buf must be large enough to hold one state per character in the main buffer.
167
#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
157
169
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
158
170
#define YY_TYPEDEF_YY_BUFFER_STATE
159
171
typedef struct yy_buffer_state *YY_BUFFER_STATE;
357
369
0, 0, 0, 0, 0, 0, 0, 16, 0, 0,
358
370
0, 0, 24, 2, 1, 2, 11, 10, 11, 11,
359
11, 15, 12, 15, 15, 14, 19, 18, 19, 19,
371
11, 15, 12, 12, 15, 14, 19, 18, 19, 19,
360
372
16, 23, 23, 23, 23, 1, 10, 7, 3, 4,
361
373
5, 12, 13, 18, 17, 16, 21, 0, 0, 0,
362
374
6, 8, 0, 0, 9, 0, 22, 0, 0, 0,
485
497
* implied. See the License for the specific language governing
486
498
* permissions and limitations under the License.
488
* $Id: psp_parser.c 332365 2005-11-10 20:19:36Z jgallacher $
500
* $Id: psp_parser.c 398222 2006-04-29 19:20:50Z jgallacher $
490
502
* This file originally written by Sterling Hughes.
1089
1103
#line 240 "psp_parser.l"
1092
#line 1093 "psp_parser.c"
1106
#line 1107 "psp_parser.c"
1093
1107
case YY_STATE_EOF(INITIAL):
1094
1108
case YY_STATE_EOF(PYCODE):
1095
1109
case YY_STATE_EOF(INDENT):
1326
1340
/* Read in more data. */
1327
1341
YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1328
yyg->yy_n_chars, num_to_read );
1342
yyg->yy_n_chars, (size_t) num_to_read );
1330
1344
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1397
1411
static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1399
1413
register int yy_is_jam;
1400
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
1414
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
1401
1415
register char *yy_cp = yyg->yy_c_buf_p;
1403
1417
register YY_CHAR yy_c = 1;
1843
1857
/** Setup the input buffer state to scan a string. The next call to yylex() will
1844
1858
* scan from a @e copy of @a str.
1845
* @param str a NUL-terminated string to scan
1846
* @param yy_str a NUL-terminated string to scan
1859
* @param yystr a NUL-terminated string to scan
1847
1860
* @param yyscanner The scanner object.
1848
1861
* @return the newly allocated buffer state object.
1849
1862
* @note If you want to scan bytes that may contain NUL values, then use
1850
1863
* yy_scan_bytes() instead.
1852
YY_BUFFER_STATE yy_scan_string (yyconst char * yy_str , yyscan_t yyscanner)
1865
YY_BUFFER_STATE yy_scan_string (yyconst char * yystr , yyscan_t yyscanner)
1855
return yy_scan_bytes(yy_str,strlen(yy_str) ,yyscanner);
1868
return yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
1858
1871
/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1862
1875
* @param yyscanner The scanner object.
1863
1876
* @return the newly allocated buffer state object.
1865
YY_BUFFER_STATE yy_scan_bytes (yyconst char * bytes, int len , yyscan_t yyscanner)
1878
YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner)
1867
1880
YY_BUFFER_STATE b;
1872
1885
/* Get memory for full buffer, including space for trailing EOB's. */
1886
n = _yybytes_len + 2;
1874
1887
buf = (char *) yyalloc(n ,yyscanner );
1876
1889
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1878
for ( i = 0; i < len; ++i )
1891
for ( i = 0; i < _yybytes_len; ++i )
1892
buf[i] = yybytes[i];
1881
buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1894
buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1883
1896
b = yy_scan_buffer(buf,n ,yyscanner);
2066
2079
/* Accessor methods for yylval and yylloc */
2081
/* User-visible API */
2083
/* yylex_init is special because it creates the scanner itself, so it is
2084
* the ONLY reentrant function that doesn't take the scanner as the last argument.
2085
* That's why we explicitly handle the declaration, instead of using our macros.
2088
int yylex_init(yyscan_t* ptr_yy_globals)
2091
if (ptr_yy_globals == NULL){
2096
*ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
2098
if (*ptr_yy_globals == NULL){
2103
/* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
2104
memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
2106
return yy_init_globals ( *ptr_yy_globals );
2068
2109
static int yy_init_globals (yyscan_t yyscanner)
2070
2111
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2071
2112
/* Initialization is the same as for the non-reentrant scanner.
2072
This function is called once per scanner lifetime. */
2113
* This function is called from yylex_destroy(), so don't allocate here.
2074
2116
yyg->yy_buffer_stack = 0;
2075
2117
yyg->yy_buffer_stack_top = 0;
2076
2118
yyg->yy_buffer_stack_max = 0;
2077
2119
yyg->yy_c_buf_p = (char *) 0;
2079
2121
yyg->yy_start = 0;
2080
2123
yyg->yy_start_stack_ptr = 0;
2081
2124
yyg->yy_start_stack_depth = 0;
2082
yyg->yy_start_stack = (int *) 0;
2125
yyg->yy_start_stack = NULL;
2084
2127
/* Defined in main.c */
2085
2128
#ifdef YY_STDINIT
2099
/* User-visible API */
2101
/* yylex_init is special because it creates the scanner itself, so it is
2102
* the ONLY reentrant function that doesn't take the scanner as the last argument.
2103
* That's why we explicitly handle the declaration, instead of using our macros.
2106
int yylex_init(yyscan_t* ptr_yy_globals)
2109
if (ptr_yy_globals == NULL){
2114
*ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );
2116
if (*ptr_yy_globals == NULL){
2121
memset(*ptr_yy_globals,0,sizeof(struct yyguts_t));
2123
return yy_init_globals ( *ptr_yy_globals );
2126
2142
/* yylex_destroy is for both reentrant and non-reentrant scanners. */
2127
2143
int yylex_destroy (yyscan_t yyscanner)
2143
2159
yyfree(yyg->yy_start_stack ,yyscanner );
2144
2160
yyg->yy_start_stack = NULL;
2162
/* Reset the globals. This is important in a non-reentrant scanner so the next time
2163
* yylex() is called, initialization will occur. */
2164
yy_init_globals( yyscanner);
2146
2166
/* Destroy the main struct (reentrant only). */
2147
2167
yyfree ( yyscanner , yyscanner );
2156
2177
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
2158
2179
register int i;
2159
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
2160
2180
for ( i = 0; i < n; ++i )
added
removed
src/psp_parser.c
