1219820Sjeff#define yy_create_buffer libsdp_yy_create_buffer 2219820Sjeff#define yy_delete_buffer libsdp_yy_delete_buffer 3219820Sjeff#define yy_scan_buffer libsdp_yy_scan_buffer 4219820Sjeff#define yy_scan_string libsdp_yy_scan_string 5219820Sjeff#define yy_scan_bytes libsdp_yy_scan_bytes 6219820Sjeff#define yy_flex_debug libsdp_yy_flex_debug 7219820Sjeff#define yy_init_buffer libsdp_yy_init_buffer 8219820Sjeff#define yy_flush_buffer libsdp_yy_flush_buffer 9219820Sjeff#define yy_load_buffer_state libsdp_yy_load_buffer_state 10219820Sjeff#define yy_switch_to_buffer libsdp_yy_switch_to_buffer 11219820Sjeff#define yyin libsdp_yyin 12219820Sjeff#define yyleng libsdp_yyleng 13219820Sjeff#define yylex libsdp_yylex 14219820Sjeff#define yyout libsdp_yyout 15219820Sjeff#define yyrestart libsdp_yyrestart 16219820Sjeff#define yytext libsdp_yytext 17219820Sjeff#define yywrap libsdp_yywrap 18219820Sjeff 19219820Sjeff/* A lexical scanner generated by flex*/ 20219820Sjeff 21219820Sjeff/* Scanner skeleton version: 22219820Sjeff * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $ 23219820Sjeff */ 24219820Sjeff 25219820Sjeff#define FLEX_SCANNER 26219820Sjeff#define YY_FLEX_MAJOR_VERSION 2 27219820Sjeff#define YY_FLEX_MINOR_VERSION 5 28219820Sjeff 29219820Sjeff#include <stdio.h> 30219820Sjeff#include <unistd.h> 31219820Sjeff 32219820Sjeff 33219820Sjeff/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */ 34219820Sjeff#ifdef c_plusplus 35219820Sjeff#ifndef __cplusplus 36219820Sjeff#define __cplusplus 37219820Sjeff#endif 38219820Sjeff#endif 39219820Sjeff 40219820Sjeff 41219820Sjeff#ifdef __cplusplus 42219820Sjeff 43219820Sjeff#include <stdlib.h> 44219820Sjeff 45219820Sjeff/* Use prototypes in function declarations. */ 46219820Sjeff#define YY_USE_PROTOS 47219820Sjeff 48219820Sjeff/* The "const" storage-class-modifier is valid. */ 49219820Sjeff#define YY_USE_CONST 50219820Sjeff 51219820Sjeff#else /* ! __cplusplus */ 52219820Sjeff 53219820Sjeff#if __STDC__ 54219820Sjeff 55219820Sjeff#define YY_USE_PROTOS 56219820Sjeff#define YY_USE_CONST 57219820Sjeff 58219820Sjeff#endif /* __STDC__ */ 59219820Sjeff#endif /* ! __cplusplus */ 60219820Sjeff 61219820Sjeff#ifdef __TURBOC__ 62219820Sjeff #pragma warn -rch 63219820Sjeff #pragma warn -use 64219820Sjeff#include <io.h> 65219820Sjeff#include <stdlib.h> 66219820Sjeff#define YY_USE_CONST 67219820Sjeff#define YY_USE_PROTOS 68219820Sjeff#endif 69219820Sjeff 70219820Sjeff#ifdef YY_USE_CONST 71219820Sjeff#define yyconst const 72219820Sjeff#else 73219820Sjeff#define yyconst 74219820Sjeff#endif 75219820Sjeff 76219820Sjeff 77219820Sjeff#ifdef YY_USE_PROTOS 78219820Sjeff#define YY_PROTO(proto) proto 79219820Sjeff#else 80219820Sjeff#define YY_PROTO(proto) () 81219820Sjeff#endif 82219820Sjeff 83219820Sjeff/* Returned upon end-of-file. */ 84219820Sjeff#define YY_NULL 0 85219820Sjeff 86219820Sjeff/* Promotes a possibly negative, possibly signed char to an unsigned 87219820Sjeff * integer for use as an array index. If the signed char is negative, 88219820Sjeff * we want to instead treat it as an 8-bit unsigned char, hence the 89219820Sjeff * double cast. 90219820Sjeff */ 91219820Sjeff#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c) 92219820Sjeff 93219820Sjeff/* Enter a start condition. This macro really ought to take a parameter, 94219820Sjeff * but we do it the disgusting crufty way forced on us by the ()-less 95219820Sjeff * definition of BEGIN. 96219820Sjeff */ 97219820Sjeff#define BEGIN yy_start = 1 + 2 * 98219820Sjeff 99219820Sjeff/* Translate the current start state into a value that can be later handed 100219820Sjeff * to BEGIN to return to the state. The YYSTATE alias is for lex 101219820Sjeff * compatibility. 102219820Sjeff */ 103219820Sjeff#define YY_START ((yy_start - 1) / 2) 104219820Sjeff#define YYSTATE YY_START 105219820Sjeff 106219820Sjeff/* Action number for EOF rule of a given start state. */ 107219820Sjeff#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) 108219820Sjeff 109219820Sjeff/* Special action meaning "start processing a new file". */ 110219820Sjeff#define YY_NEW_FILE yyrestart( yyin ) 111219820Sjeff 112219820Sjeff#define YY_END_OF_BUFFER_CHAR 0 113219820Sjeff 114219820Sjeff/* Size of default input buffer. */ 115219820Sjeff#define YY_BUF_SIZE 16384 116219820Sjeff 117219820Sjefftypedef struct yy_buffer_state *YY_BUFFER_STATE; 118219820Sjeff 119219820Sjeffextern int yyleng; 120219820Sjeffextern FILE *yyin, *yyout; 121219820Sjeff 122219820Sjeff#define EOB_ACT_CONTINUE_SCAN 0 123219820Sjeff#define EOB_ACT_END_OF_FILE 1 124219820Sjeff#define EOB_ACT_LAST_MATCH 2 125219820Sjeff 126219820Sjeff/* The funky do-while in the following #define is used to turn the definition 127219820Sjeff * int a single C statement (which needs a semi-colon terminator). This 128219820Sjeff * avoids problems with code like: 129219820Sjeff * 130219820Sjeff * if ( condition_holds ) 131219820Sjeff * yyless( 5 ); 132219820Sjeff * else 133219820Sjeff * do_something_else(); 134219820Sjeff * 135219820Sjeff * Prior to using the do-while the compiler would get upset at the 136219820Sjeff * "else" because it interpreted the "if" statement as being all 137219820Sjeff * done when it reached the ';' after the yyless() call. 138219820Sjeff */ 139219820Sjeff 140219820Sjeff/* Return all but the first 'n' matched characters back to the input stream. */ 141219820Sjeff 142219820Sjeff#define yyless(n) \ 143219820Sjeff do \ 144219820Sjeff { \ 145219820Sjeff /* Undo effects of setting up yytext. */ \ 146219820Sjeff *yy_cp = yy_hold_char; \ 147219820Sjeff YY_RESTORE_YY_MORE_OFFSET \ 148219820Sjeff yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \ 149219820Sjeff YY_DO_BEFORE_ACTION; /* set up yytext again */ \ 150219820Sjeff } \ 151219820Sjeff while ( 0 ) 152219820Sjeff 153219820Sjeff#define unput(c) yyunput( c, yytext_ptr ) 154219820Sjeff 155219820Sjeff/* Some routines like yy_flex_realloc() are emitted as static but are 156219820Sjeff not called by all lexers. This generates warnings in some compilers, 157219820Sjeff notably GCC. Arrange to suppress these. */ 158219820Sjeff#ifdef __GNUC__ 159219820Sjeff#define YY_MAY_BE_UNUSED __attribute__((unused)) 160219820Sjeff#else 161219820Sjeff#define YY_MAY_BE_UNUSED 162219820Sjeff#endif 163219820Sjeff 164219820Sjeff/* The following is because we cannot portably get our hands on size_t 165219820Sjeff * (without autoconf's help, which isn't available because we want 166219820Sjeff * flex-generated scanners to compile on their own). 167219820Sjeff */ 168219820Sjefftypedef unsigned int yy_size_t; 169219820Sjeff 170219820Sjeff 171219820Sjeffstruct yy_buffer_state 172219820Sjeff { 173219820Sjeff FILE *yy_input_file; 174219820Sjeff 175219820Sjeff char *yy_ch_buf; /* input buffer */ 176219820Sjeff char *yy_buf_pos; /* current position in input buffer */ 177219820Sjeff 178219820Sjeff /* Size of input buffer in bytes, not including room for EOB 179219820Sjeff * characters. 180219820Sjeff */ 181219820Sjeff yy_size_t yy_buf_size; 182219820Sjeff 183219820Sjeff /* Number of characters read into yy_ch_buf, not including EOB 184219820Sjeff * characters. 185219820Sjeff */ 186219820Sjeff int yy_n_chars; 187219820Sjeff 188219820Sjeff /* Whether we "own" the buffer - i.e., we know we created it, 189219820Sjeff * and can realloc() it to grow it, and should free() it to 190219820Sjeff * delete it. 191219820Sjeff */ 192219820Sjeff int yy_is_our_buffer; 193219820Sjeff 194219820Sjeff /* Whether this is an "interactive" input source; if so, and 195219820Sjeff * if we're using stdio for input, then we want to use getc() 196219820Sjeff * instead of fread(), to make sure we stop fetching input after 197219820Sjeff * each newline. 198219820Sjeff */ 199219820Sjeff int yy_is_interactive; 200219820Sjeff 201219820Sjeff /* Whether we're considered to be at the beginning of a line. 202219820Sjeff * If so, '^' rules will be active on the next match, otherwise 203219820Sjeff * not. 204219820Sjeff */ 205219820Sjeff int yy_at_bol; 206219820Sjeff 207219820Sjeff /* Whether to try to fill the input buffer when we reach the 208219820Sjeff * end of it. 209219820Sjeff */ 210219820Sjeff int yy_fill_buffer; 211219820Sjeff 212219820Sjeff int yy_buffer_status; 213219820Sjeff#define YY_BUFFER_NEW 0 214219820Sjeff#define YY_BUFFER_NORMAL 1 215219820Sjeff /* When an EOF's been seen but there's still some text to process 216219820Sjeff * then we mark the buffer as YY_EOF_PENDING, to indicate that we 217219820Sjeff * shouldn't try reading from the input source any more. We might 218219820Sjeff * still have a bunch of tokens to match, though, because of 219219820Sjeff * possible backing-up. 220219820Sjeff * 221219820Sjeff * When we actually see the EOF, we change the status to "new" 222219820Sjeff * (via yyrestart()), so that the user can continue scanning by 223219820Sjeff * just pointing yyin at a new input file. 224219820Sjeff */ 225219820Sjeff#define YY_BUFFER_EOF_PENDING 2 226219820Sjeff }; 227219820Sjeff 228219820Sjeffstatic YY_BUFFER_STATE yy_current_buffer = 0; 229219820Sjeff 230219820Sjeff/* We provide macros for accessing buffer states in case in the 231219820Sjeff * future we want to put the buffer states in a more general 232219820Sjeff * "scanner state". 233219820Sjeff */ 234219820Sjeff#define YY_CURRENT_BUFFER yy_current_buffer 235219820Sjeff 236219820Sjeff 237219820Sjeff/* yy_hold_char holds the character lost when yytext is formed. */ 238219820Sjeffstatic char yy_hold_char; 239219820Sjeff 240219820Sjeffstatic int yy_n_chars; /* number of characters read into yy_ch_buf */ 241219820Sjeff 242219820Sjeff 243219820Sjeffint yyleng; 244219820Sjeff 245219820Sjeff/* Points to current character in buffer. */ 246219820Sjeffstatic char *yy_c_buf_p = (char *) 0; 247219820Sjeffstatic int yy_init = 1; /* whether we need to initialize */ 248219820Sjeffstatic int yy_start = 0; /* start state number */ 249219820Sjeff 250219820Sjeff/* Flag which is used to allow yywrap()'s to do buffer switches 251219820Sjeff * instead of setting up a fresh yyin. A bit of a hack ... 252219820Sjeff */ 253219820Sjeffstatic int yy_did_buffer_switch_on_eof; 254219820Sjeff 255219820Sjeffvoid yyrestart YY_PROTO(( FILE *input_file )); 256219820Sjeff 257219820Sjeffvoid yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer )); 258219820Sjeffvoid yy_load_buffer_state YY_PROTO(( void )); 259219820SjeffYY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size )); 260219820Sjeffvoid yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b )); 261219820Sjeffvoid yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file )); 262219820Sjeffvoid yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b )); 263219820Sjeff#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer ) 264219820Sjeff 265219820SjeffYY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size )); 266219820SjeffYY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str )); 267219820SjeffYY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len )); 268219820Sjeff 269219820Sjeffstatic void *yy_flex_alloc YY_PROTO(( yy_size_t )); 270219820Sjeffstatic void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) YY_MAY_BE_UNUSED; 271219820Sjeffstatic void yy_flex_free YY_PROTO(( void * )); 272219820Sjeff 273219820Sjeff#define yy_new_buffer yy_create_buffer 274219820Sjeff 275219820Sjeff#define yy_set_interactive(is_interactive) \ 276219820Sjeff { \ 277219820Sjeff if ( ! yy_current_buffer ) \ 278219820Sjeff yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 279219820Sjeff yy_current_buffer->yy_is_interactive = is_interactive; \ 280219820Sjeff } 281219820Sjeff 282219820Sjeff#define yy_set_bol(at_bol) \ 283219820Sjeff { \ 284219820Sjeff if ( ! yy_current_buffer ) \ 285219820Sjeff yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \ 286219820Sjeff yy_current_buffer->yy_at_bol = at_bol; \ 287219820Sjeff } 288219820Sjeff 289219820Sjeff#define YY_AT_BOL() (yy_current_buffer->yy_at_bol) 290219820Sjeff 291219820Sjefftypedef unsigned char YY_CHAR; 292219820SjeffFILE *yyin = (FILE *) 0, *yyout = (FILE *) 0; 293219820Sjefftypedef int yy_state_type; 294219820Sjeffextern char *yytext; 295219820Sjeff#define yytext_ptr yytext 296219820Sjeff 297219820Sjeffstatic yy_state_type yy_get_previous_state YY_PROTO(( void )); 298219820Sjeffstatic yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state )); 299219820Sjeffstatic int yy_get_next_buffer YY_PROTO(( void )); 300219820Sjeffstatic void yy_fatal_error YY_PROTO(( yyconst char msg[] )); 301219820Sjeff 302219820Sjeff/* Done after the current pattern has been matched and before the 303219820Sjeff * corresponding action - sets up yytext. 304219820Sjeff */ 305219820Sjeff#define YY_DO_BEFORE_ACTION \ 306219820Sjeff yytext_ptr = yy_bp; \ 307219820Sjeff yyleng = (int) (yy_cp - yy_bp); \ 308219820Sjeff yy_hold_char = *yy_cp; \ 309219820Sjeff *yy_cp = '\0'; \ 310219820Sjeff yy_c_buf_p = yy_cp; 311219820Sjeff 312219820Sjeff#define YY_NUM_RULES 20 313219820Sjeff#define YY_END_OF_BUFFER 21 314219820Sjeffstatic yyconst short int yy_accept[171] = 315219820Sjeff { 0, 316219820Sjeff 0, 0, 0, 0, 21, 19, 18, 16, 17, 2, 317219820Sjeff 2, 19, 19, 19, 19, 19, 19, 19, 19, 19, 318219820Sjeff 18, 1, 15, 15, 2, 2, 15, 15, 15, 15, 319219820Sjeff 15, 15, 15, 15, 15, 1, 18, 17, 2, 0, 320219820Sjeff 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 321219820Sjeff 0, 0, 0, 18, 1, 1, 15, 15, 2, 15, 322219820Sjeff 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 323219820Sjeff 15, 15, 15, 1, 0, 0, 0, 0, 0, 0, 324219820Sjeff 3, 0, 11, 0, 0, 0, 10, 9, 1, 15, 325219820Sjeff 15, 15, 15, 15, 15, 3, 15, 11, 15, 15, 326219820Sjeff 327219820Sjeff 15, 10, 9, 12, 0, 0, 0, 8, 0, 0, 328219820Sjeff 0, 0, 0, 12, 15, 15, 15, 8, 15, 15, 329219820Sjeff 15, 15, 15, 0, 0, 0, 0, 0, 0, 0, 330219820Sjeff 0, 15, 15, 15, 15, 15, 15, 15, 15, 13, 331219820Sjeff 0, 0, 14, 0, 6, 7, 13, 15, 15, 14, 332219820Sjeff 15, 6, 7, 0, 0, 15, 15, 0, 0, 15, 333219820Sjeff 15, 0, 5, 15, 5, 0, 15, 4, 4, 0 334219820Sjeff } ; 335219820Sjeff 336219820Sjeffstatic yyconst int yy_ec[256] = 337219820Sjeff { 0, 338219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 339219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 340219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 341219820Sjeff 1, 2, 1, 1, 4, 1, 1, 1, 1, 1, 342219820Sjeff 1, 1, 1, 1, 5, 1, 1, 6, 7, 7, 343219820Sjeff 7, 7, 7, 7, 7, 7, 7, 1, 1, 1, 344219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 345219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 346219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 347219820Sjeff 1, 1, 1, 1, 1, 1, 8, 9, 10, 11, 348219820Sjeff 349219820Sjeff 12, 13, 14, 15, 16, 1, 1, 17, 18, 19, 350219820Sjeff 20, 21, 1, 22, 23, 24, 25, 26, 1, 1, 351219820Sjeff 27, 1, 1, 1, 1, 1, 1, 1, 1, 1, 352219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 353219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 354219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 355219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 356219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 357219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 358219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 359219820Sjeff 360219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 361219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 362219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 363219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 364219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 365219820Sjeff 1, 1, 1, 1, 1 366219820Sjeff } ; 367219820Sjeff 368219820Sjeffstatic yyconst int yy_meta[28] = 369219820Sjeff { 0, 370219820Sjeff 1, 2, 3, 1, 1, 1, 1, 1, 1, 1, 371219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 372219820Sjeff 1, 1, 1, 1, 1, 1, 1 373219820Sjeff } ; 374219820Sjeff 375219820Sjeffstatic yyconst short int yy_base[177] = 376219820Sjeff { 0, 377219820Sjeff 0, 26, 30, 56, 214, 215, 211, 215, 0, 215, 378219820Sjeff 55, 192, 46, 199, 194, 48, 193, 58, 198, 184, 379219820Sjeff 63, 0, 0, 204, 0, 65, 185, 56, 192, 187, 380219820Sjeff 58, 186, 68, 191, 177, 197, 196, 0, 77, 173, 381219820Sjeff 180, 176, 171, 176, 169, 177, 171, 168, 166, 176, 382219820Sjeff 163, 164, 172, 73, 0, 0, 0, 181, 80, 158, 383219820Sjeff 165, 161, 156, 161, 154, 162, 156, 153, 151, 161, 384219820Sjeff 148, 149, 157, 166, 152, 154, 146, 140, 151, 138, 385219820Sjeff 215, 156, 215, 134, 147, 141, 215, 215, 0, 142, 386219820Sjeff 144, 136, 130, 141, 128, 0, 146, 0, 124, 137, 387219820Sjeff 388219820Sjeff 131, 0, 0, 215, 128, 134, 129, 215, 132, 126, 389219820Sjeff 130, 119, 120, 0, 120, 126, 121, 0, 124, 118, 390219820Sjeff 122, 111, 112, 107, 120, 110, 109, 115, 104, 103, 391219820Sjeff 110, 99, 112, 102, 101, 107, 96, 95, 102, 215, 392219820Sjeff 91, 106, 215, 87, 215, 215, 0, 88, 103, 0, 393219820Sjeff 84, 0, 0, 85, 96, 83, 94, 78, 76, 75, 394219820Sjeff 73, 69, 215, 68, 0, 62, 40, 215, 0, 215, 395219820Sjeff 95, 97, 28, 99, 101, 103 396219820Sjeff } ; 397219820Sjeff 398219820Sjeffstatic yyconst short int yy_def[177] = 399219820Sjeff { 0, 400219820Sjeff 170, 1, 170, 3, 170, 170, 170, 170, 171, 170, 401219820Sjeff 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 402219820Sjeff 170, 172, 173, 174, 173, 173, 173, 173, 173, 173, 403219820Sjeff 173, 173, 173, 173, 173, 175, 170, 171, 170, 170, 404219820Sjeff 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 405219820Sjeff 170, 170, 170, 170, 176, 172, 173, 174, 173, 173, 406219820Sjeff 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 407219820Sjeff 173, 173, 173, 175, 170, 170, 170, 170, 170, 170, 408219820Sjeff 170, 170, 170, 170, 170, 170, 170, 170, 176, 173, 409219820Sjeff 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, 410219820Sjeff 411219820Sjeff 173, 173, 173, 170, 170, 170, 170, 170, 170, 170, 412219820Sjeff 170, 170, 170, 173, 173, 173, 173, 173, 173, 173, 413219820Sjeff 173, 173, 173, 170, 170, 170, 170, 170, 170, 170, 414219820Sjeff 170, 173, 173, 173, 173, 173, 173, 173, 173, 170, 415219820Sjeff 170, 170, 170, 170, 170, 170, 173, 173, 173, 173, 416219820Sjeff 173, 173, 173, 170, 170, 173, 173, 170, 170, 173, 417219820Sjeff 173, 170, 170, 173, 173, 170, 173, 170, 173, 0, 418219820Sjeff 170, 170, 170, 170, 170, 170 419219820Sjeff } ; 420219820Sjeff 421219820Sjeffstatic yyconst short int yy_nxt[243] = 422219820Sjeff { 0, 423219820Sjeff 6, 7, 8, 9, 6, 10, 11, 6, 12, 13, 424219820Sjeff 14, 6, 15, 6, 6, 6, 16, 17, 6, 6, 425219820Sjeff 6, 6, 18, 19, 20, 6, 6, 21, 57, 22, 426219820Sjeff 23, 7, 8, 24, 23, 25, 26, 23, 27, 28, 427219820Sjeff 29, 23, 30, 23, 23, 23, 31, 32, 23, 23, 428219820Sjeff 23, 23, 33, 34, 35, 23, 23, 21, 169, 36, 429219820Sjeff 39, 39, 41, 45, 54, 42, 55, 46, 48, 49, 430219820Sjeff 59, 59, 61, 65, 54, 62, 55, 66, 68, 69, 431219820Sjeff 168, 50, 39, 39, 51, 59, 59, 167, 166, 165, 432219820Sjeff 164, 70, 163, 162, 71, 38, 38, 56, 56, 58, 433219820Sjeff 434219820Sjeff 58, 74, 74, 89, 89, 161, 160, 159, 158, 157, 435219820Sjeff 156, 147, 155, 154, 140, 153, 152, 150, 151, 150, 436219820Sjeff 149, 148, 147, 146, 145, 143, 144, 143, 142, 141, 437219820Sjeff 140, 139, 138, 137, 136, 135, 134, 133, 132, 131, 438219820Sjeff 130, 129, 128, 127, 126, 125, 124, 123, 122, 121, 439219820Sjeff 120, 119, 118, 117, 116, 115, 114, 113, 112, 111, 440219820Sjeff 110, 109, 108, 107, 106, 105, 104, 56, 103, 102, 441219820Sjeff 101, 100, 99, 98, 97, 96, 95, 94, 93, 92, 442219820Sjeff 91, 90, 38, 88, 87, 86, 85, 84, 83, 82, 443219820Sjeff 81, 80, 79, 78, 77, 76, 75, 37, 56, 73, 444219820Sjeff 445219820Sjeff 72, 67, 64, 63, 60, 38, 53, 52, 47, 44, 446219820Sjeff 43, 40, 37, 170, 5, 170, 170, 170, 170, 170, 447219820Sjeff 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 448219820Sjeff 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 449219820Sjeff 170, 170 450219820Sjeff } ; 451219820Sjeff 452219820Sjeffstatic yyconst short int yy_chk[243] = 453219820Sjeff { 0, 454219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 455219820Sjeff 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 456219820Sjeff 1, 1, 1, 1, 1, 1, 1, 2, 173, 2, 457219820Sjeff 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 458219820Sjeff 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 459219820Sjeff 3, 3, 3, 3, 3, 3, 3, 4, 167, 4, 460219820Sjeff 11, 11, 13, 16, 21, 13, 21, 16, 18, 18, 461219820Sjeff 26, 26, 28, 31, 54, 28, 54, 31, 33, 33, 462219820Sjeff 166, 18, 39, 39, 18, 59, 59, 164, 162, 161, 463219820Sjeff 160, 33, 159, 158, 33, 171, 171, 172, 172, 174, 464219820Sjeff 465219820Sjeff 174, 175, 175, 176, 176, 157, 156, 155, 154, 151, 466219820Sjeff 149, 148, 144, 142, 141, 139, 138, 137, 136, 135, 467219820Sjeff 134, 133, 132, 131, 130, 129, 128, 127, 126, 125, 468219820Sjeff 124, 123, 122, 121, 120, 119, 117, 116, 115, 113, 469219820Sjeff 112, 111, 110, 109, 107, 106, 105, 101, 100, 99, 470219820Sjeff 97, 95, 94, 93, 92, 91, 90, 86, 85, 84, 471219820Sjeff 82, 80, 79, 78, 77, 76, 75, 74, 73, 72, 472219820Sjeff 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 473219820Sjeff 61, 60, 58, 53, 52, 51, 50, 49, 48, 47, 474219820Sjeff 46, 45, 44, 43, 42, 41, 40, 37, 36, 35, 475219820Sjeff 476219820Sjeff 34, 32, 30, 29, 27, 24, 20, 19, 17, 15, 477219820Sjeff 14, 12, 7, 5, 170, 170, 170, 170, 170, 170, 478219820Sjeff 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 479219820Sjeff 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 480219820Sjeff 170, 170 481219820Sjeff } ; 482219820Sjeff 483219820Sjeffstatic yy_state_type yy_last_accepting_state; 484219820Sjeffstatic char *yy_last_accepting_cpos; 485219820Sjeff 486219820Sjeff/* The intent behind this definition is that it'll catch 487219820Sjeff * any uses of REJECT which flex missed. 488219820Sjeff */ 489219820Sjeff#define REJECT reject_used_but_not_detected 490219820Sjeff#define yymore() yymore_used_but_not_detected 491219820Sjeff#define YY_MORE_ADJ 0 492219820Sjeff#define YY_RESTORE_YY_MORE_OFFSET 493219820Sjeffchar *yytext; 494219820Sjeff#line 1 "./config_scanner.l" 495219820Sjeff#define INITIAL 0 496219820Sjeff/* 497219820Sjeff * Copyright (c) 2006 Mellanox Technologies Ltd. All rights reserved. 498219820Sjeff * 499219820Sjeff * This software is available to you under a choice of one of two 500219820Sjeff * licenses. You may choose to be licensed under the terms of the GNU 501219820Sjeff * General Public License (GPL) Version 2, available from the file 502219820Sjeff * COPYING in the main directory of this source tree, or the 503219820Sjeff * OpenIB.org BSD license below: 504219820Sjeff * 505219820Sjeff * Redistribution and use in source and binary forms, with or 506219820Sjeff * without modification, are permitted provided that the following 507219820Sjeff * conditions are met: 508219820Sjeff * 509219820Sjeff * - Redistributions of source code must retain the above 510219820Sjeff * copyright notice, this list of conditions and the following 511219820Sjeff * disclaimer. 512219820Sjeff * 513219820Sjeff * - Redistributions in binary form must reproduce the above 514219820Sjeff * copyright notice, this list of conditions and the following 515219820Sjeff * disclaimer in the documentation and/or other materials 516219820Sjeff * provided with the distribution. 517219820Sjeff * 518219820Sjeff * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 519219820Sjeff * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 520219820Sjeff * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 521219820Sjeff * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 522219820Sjeff * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 523219820Sjeff * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 524219820Sjeff * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 525219820Sjeff * SOFTWARE. 526219820Sjeff * 527219820Sjeff * $Id: ibnl_scanner.ll,v 1.4 2005/02/23 21:08:37 eitan Exp $ 528219820Sjeff */ 529219820Sjeff#line 36 "./config_scanner.l" 530219820Sjeff 531219820Sjeff/* #define DEBUG 1 */ 532219820Sjeff 533219820Sjeff#define yyparse libsdp_yyparse 534219820Sjeff#define yylex libsdp_yylex 535219820Sjeff#define yyerror libsdp_yyerror 536219820Sjeff#define yylval libsdp_yylval 537219820Sjeff#define yychar libsdp_yychar 538219820Sjeff#define yydebug libsdp_yydebug 539219820Sjeff#define yynerrs libsdp_yynerrs 540219820Sjeff 541219820Sjeff#define yywrap libsdp_yywrap 542219820Sjeff 543219820Sjeff#include <string.h> 544219820Sjeff#include <stdio.h> 545219820Sjeff#include "config_parser.h" 546219820Sjeffextern long __sdp_config_line_num; 547219820Sjeff#define CANNAME 1 548219820Sjeff 549219820Sjeff#line 550 "lex.libsdp_yy.c" 550219820Sjeff 551219820Sjeff/* Macros after this point can all be overridden by user definitions in 552219820Sjeff * section 1. 553219820Sjeff */ 554219820Sjeff 555219820Sjeff#ifndef YY_SKIP_YYWRAP 556219820Sjeff#ifdef __cplusplus 557219820Sjeffextern "C" int yywrap YY_PROTO(( void )); 558219820Sjeff#else 559219820Sjeffextern int yywrap YY_PROTO(( void )); 560219820Sjeff#endif 561219820Sjeff#endif 562219820Sjeff 563219820Sjeff#ifndef YY_NO_UNPUT 564219820Sjeffstatic void yyunput YY_PROTO(( int c, char *buf_ptr )); 565219820Sjeff#endif 566219820Sjeff 567219820Sjeff#ifndef yytext_ptr 568219820Sjeffstatic void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int )); 569219820Sjeff#endif 570219820Sjeff 571219820Sjeff#ifdef YY_NEED_STRLEN 572219820Sjeffstatic int yy_flex_strlen YY_PROTO(( yyconst char * )); 573219820Sjeff#endif 574219820Sjeff 575219820Sjeff#ifndef YY_NO_INPUT 576219820Sjeff#ifdef __cplusplus 577219820Sjeffstatic int yyinput YY_PROTO(( void )); 578219820Sjeff#else 579219820Sjeffstatic int input YY_PROTO(( void )); 580219820Sjeff#endif 581219820Sjeff#endif 582219820Sjeff 583219820Sjeff#if YY_STACK_USED 584219820Sjeffstatic int yy_start_stack_ptr = 0; 585219820Sjeffstatic int yy_start_stack_depth = 0; 586219820Sjeffstatic int *yy_start_stack = 0; 587219820Sjeff#ifndef YY_NO_PUSH_STATE 588219820Sjeffstatic void yy_push_state YY_PROTO(( int new_state )); 589219820Sjeff#endif 590219820Sjeff#ifndef YY_NO_POP_STATE 591219820Sjeffstatic void yy_pop_state YY_PROTO(( void )); 592219820Sjeff#endif 593219820Sjeff#ifndef YY_NO_TOP_STATE 594219820Sjeffstatic int yy_top_state YY_PROTO(( void )); 595219820Sjeff#endif 596219820Sjeff 597219820Sjeff#else 598219820Sjeff#define YY_NO_PUSH_STATE 1 599219820Sjeff#define YY_NO_POP_STATE 1 600219820Sjeff#define YY_NO_TOP_STATE 1 601219820Sjeff#endif 602219820Sjeff 603219820Sjeff#ifdef YY_MALLOC_DECL 604219820SjeffYY_MALLOC_DECL 605219820Sjeff#else 606219820Sjeff#if __STDC__ 607219820Sjeff#ifndef __cplusplus 608219820Sjeff#include <stdlib.h> 609219820Sjeff#endif 610219820Sjeff#else 611219820Sjeff/* Just try to get by without declaring the routines. This will fail 612219820Sjeff * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int) 613219820Sjeff * or sizeof(void*) != sizeof(int). 614219820Sjeff */ 615219820Sjeff#endif 616219820Sjeff#endif 617219820Sjeff 618219820Sjeff/* Amount of stuff to slurp up with each read. */ 619219820Sjeff#ifndef YY_READ_BUF_SIZE 620219820Sjeff#define YY_READ_BUF_SIZE 8192 621219820Sjeff#endif 622219820Sjeff 623219820Sjeff/* Copy whatever the last rule matched to the standard output. */ 624219820Sjeff 625219820Sjeff#ifndef ECHO 626219820Sjeff/* This used to be an fputs(), but since the string might contain NUL's, 627219820Sjeff * we now use fwrite(). 628219820Sjeff */ 629219820Sjeff#define ECHO (void) fwrite( yytext, yyleng, 1, yyout ) 630219820Sjeff#endif 631219820Sjeff 632219820Sjeff/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, 633219820Sjeff * is returned in "result". 634219820Sjeff */ 635219820Sjeff#ifndef YY_INPUT 636219820Sjeff#define YY_INPUT(buf,result,max_size) \ 637219820Sjeff if ( yy_current_buffer->yy_is_interactive ) \ 638219820Sjeff { \ 639219820Sjeff int c = '*', n; \ 640219820Sjeff for ( n = 0; n < max_size && \ 641219820Sjeff (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ 642219820Sjeff buf[n] = (char) c; \ 643219820Sjeff if ( c == '\n' ) \ 644219820Sjeff buf[n++] = (char) c; \ 645219820Sjeff if ( c == EOF && ferror( yyin ) ) \ 646219820Sjeff YY_FATAL_ERROR( "input in flex scanner failed" ); \ 647219820Sjeff result = n; \ 648219820Sjeff } \ 649219820Sjeff else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \ 650219820Sjeff && ferror( yyin ) ) \ 651219820Sjeff YY_FATAL_ERROR( "input in flex scanner failed" ); 652219820Sjeff#endif 653219820Sjeff 654219820Sjeff/* No semi-colon after return; correct usage is to write "yyterminate();" - 655219820Sjeff * we don't want an extra ';' after the "return" because that will cause 656219820Sjeff * some compilers to complain about unreachable statements. 657219820Sjeff */ 658219820Sjeff#ifndef yyterminate 659219820Sjeff#define yyterminate() return YY_NULL 660219820Sjeff#endif 661219820Sjeff 662219820Sjeff/* Number of entries by which start-condition stack grows. */ 663219820Sjeff#ifndef YY_START_STACK_INCR 664219820Sjeff#define YY_START_STACK_INCR 25 665219820Sjeff#endif 666219820Sjeff 667219820Sjeff/* Report a fatal error. */ 668219820Sjeff#ifndef YY_FATAL_ERROR 669219820Sjeff#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) 670219820Sjeff#endif 671219820Sjeff 672219820Sjeff/* Default declaration of generated scanner - a define so the user can 673219820Sjeff * easily add parameters. 674219820Sjeff */ 675219820Sjeff#ifndef YY_DECL 676219820Sjeff#define YY_DECL int yylex YY_PROTO(( void )) 677219820Sjeff#endif 678219820Sjeff 679219820Sjeff/* Code executed at the beginning of each rule, after yytext and yyleng 680219820Sjeff * have been set up. 681219820Sjeff */ 682219820Sjeff#ifndef YY_USER_ACTION 683219820Sjeff#define YY_USER_ACTION 684219820Sjeff#endif 685219820Sjeff 686219820Sjeff/* Code executed at the end of each rule. */ 687219820Sjeff#ifndef YY_BREAK 688219820Sjeff#define YY_BREAK break; 689219820Sjeff#endif 690219820Sjeff 691219820Sjeff#define YY_RULE_SETUP \ 692219820Sjeff if ( yyleng > 0 ) \ 693219820Sjeff yy_current_buffer->yy_at_bol = \ 694219820Sjeff (yytext[yyleng - 1] == '\n'); \ 695219820Sjeff YY_USER_ACTION 696219820Sjeff 697219820SjeffYY_DECL 698219820Sjeff { 699219820Sjeff register yy_state_type yy_current_state; 700219820Sjeff register char *yy_cp = NULL, *yy_bp = NULL; 701219820Sjeff register int yy_act; 702219820Sjeff 703219820Sjeff#line 55 "./config_scanner.l" 704219820Sjeff 705219820Sjeff 706219820Sjeff#line 707 "lex.libsdp_yy.c" 707219820Sjeff 708219820Sjeff if ( yy_init ) 709219820Sjeff { 710219820Sjeff yy_init = 0; 711219820Sjeff 712219820Sjeff#ifdef YY_USER_INIT 713219820Sjeff YY_USER_INIT; 714219820Sjeff#endif 715219820Sjeff 716219820Sjeff if ( ! yy_start ) 717219820Sjeff yy_start = 1; /* first start state */ 718219820Sjeff 719219820Sjeff if ( ! yyin ) 720219820Sjeff yyin = stdin; 721219820Sjeff 722219820Sjeff if ( ! yyout ) 723219820Sjeff yyout = stdout; 724219820Sjeff 725219820Sjeff if ( ! yy_current_buffer ) 726219820Sjeff yy_current_buffer = 727219820Sjeff yy_create_buffer( yyin, YY_BUF_SIZE ); 728219820Sjeff 729219820Sjeff yy_load_buffer_state(); 730219820Sjeff } 731219820Sjeff 732219820Sjeff while ( 1 ) /* loops until end-of-file is reached */ 733219820Sjeff { 734219820Sjeff yy_cp = yy_c_buf_p; 735219820Sjeff 736219820Sjeff /* Support of yytext. */ 737219820Sjeff *yy_cp = yy_hold_char; 738219820Sjeff 739219820Sjeff /* yy_bp points to the position in yy_ch_buf of the start of 740219820Sjeff * the current run. 741219820Sjeff */ 742219820Sjeff yy_bp = yy_cp; 743219820Sjeff 744219820Sjeff yy_current_state = yy_start; 745219820Sjeff yy_current_state += YY_AT_BOL(); 746219820Sjeffyy_match: 747219820Sjeff do 748219820Sjeff { 749219820Sjeff register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; 750219820Sjeff if ( yy_accept[yy_current_state] ) 751219820Sjeff { 752219820Sjeff yy_last_accepting_state = yy_current_state; 753219820Sjeff yy_last_accepting_cpos = yy_cp; 754219820Sjeff } 755219820Sjeff while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 756219820Sjeff { 757219820Sjeff yy_current_state = (int) yy_def[yy_current_state]; 758219820Sjeff if ( yy_current_state >= 171 ) 759219820Sjeff yy_c = yy_meta[(unsigned int) yy_c]; 760219820Sjeff } 761219820Sjeff yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 762219820Sjeff ++yy_cp; 763219820Sjeff } 764219820Sjeff while ( yy_base[yy_current_state] != 215 ); 765219820Sjeff 766219820Sjeffyy_find_action: 767219820Sjeff yy_act = yy_accept[yy_current_state]; 768219820Sjeff if ( yy_act == 0 ) 769219820Sjeff { /* have to back up */ 770219820Sjeff yy_cp = yy_last_accepting_cpos; 771219820Sjeff yy_current_state = yy_last_accepting_state; 772219820Sjeff yy_act = yy_accept[yy_current_state]; 773219820Sjeff } 774219820Sjeff 775219820Sjeff YY_DO_BEFORE_ACTION; 776219820Sjeff 777219820Sjeff 778219820Sjeffdo_action: /* This label is used only to access EOF actions. */ 779219820Sjeff 780219820Sjeff 781219820Sjeff switch ( yy_act ) 782219820Sjeff { /* beginning of action switch */ 783219820Sjeff case 0: /* must back up */ 784219820Sjeff /* undo the effects of YY_DO_BEFORE_ACTION */ 785219820Sjeff *yy_cp = yy_hold_char; 786219820Sjeff yy_cp = yy_last_accepting_cpos; 787219820Sjeff yy_current_state = yy_last_accepting_state; 788219820Sjeff goto yy_find_action; 789219820Sjeff 790219820Sjeffcase 1: 791219820SjeffYY_RULE_SETUP 792219820Sjeff#line 57 "./config_scanner.l" 793219820Sjeff{} 794219820Sjeff YY_BREAK 795219820Sjeffcase 2: 796219820SjeffYY_RULE_SETUP 797219820Sjeff#line 59 "./config_scanner.l" 798219820Sjeff{ 799219820Sjeff yylval.ival = atoi(yytext); 800219820Sjeff#ifdef DEBUG 801219820Sjeff printf("INT:%d\n",yylval.ival); 802219820Sjeff#endif 803219820Sjeff return INT; 804219820Sjeff} 805219820Sjeff YY_BREAK 806219820Sjeffcase 3: 807219820SjeffYY_RULE_SETUP 808219820Sjeff#line 67 "./config_scanner.l" 809219820Sjeff{ 810219820Sjeff yylval.ival = LOG; 811219820Sjeff#ifdef DEBUG 812219820Sjeff printf("LOG\n"); 813219820Sjeff#endif 814219820Sjeff return LOG; 815219820Sjeff} 816219820Sjeff YY_BREAK 817219820Sjeffcase 4: 818219820SjeffYY_RULE_SETUP 819219820Sjeff#line 75 "./config_scanner.l" 820219820Sjeff{ 821219820Sjeff yylval.ival = DEST; 822219820Sjeff#ifdef DEBUG 823219820Sjeff printf("DEST\n"); 824219820Sjeff#endif 825219820Sjeff return DEST; 826219820Sjeff} 827219820Sjeff YY_BREAK 828219820Sjeffcase 5: 829219820SjeffYY_RULE_SETUP 830219820Sjeff#line 83 "./config_scanner.l" 831219820Sjeff{ 832219820Sjeff yylval.ival = LEVEL; 833219820Sjeff#ifdef DEBUG 834219820Sjeff printf("LEVEL\n"); 835219820Sjeff#endif 836219820Sjeff return LEVEL; 837219820Sjeff} 838219820Sjeff YY_BREAK 839219820Sjeffcase 6: 840219820SjeffYY_RULE_SETUP 841219820Sjeff#line 91 "./config_scanner.l" 842219820Sjeff{ 843219820Sjeff yylval.ival = STDERR; 844219820Sjeff#ifdef DEBUG 845219820Sjeff printf("STDERR\n"); 846219820Sjeff#endif 847219820Sjeff return STDERR; 848219820Sjeff} 849219820Sjeff YY_BREAK 850219820Sjeffcase 7: 851219820SjeffYY_RULE_SETUP 852219820Sjeff#line 99 "./config_scanner.l" 853219820Sjeff{ 854219820Sjeff yylval.ival = SYSLOG; 855219820Sjeff#ifdef DEBUG 856219820Sjeff printf("SYSLOG\n"); 857219820Sjeff#endif 858219820Sjeff return SYSLOG; 859219820Sjeff} 860219820Sjeff YY_BREAK 861219820Sjeffcase 8: 862219820SjeffYY_RULE_SETUP 863219820Sjeff#line 107 "./config_scanner.l" 864219820Sjeff{ 865219820Sjeff yylval.ival = FILENAME; 866219820Sjeff#ifdef DEBUG 867219820Sjeff printf("FILENAME\n"); 868219820Sjeff#endif 869219820Sjeff BEGIN(CANNAME); 870219820Sjeff return FILENAME; 871219820Sjeff} 872219820Sjeff YY_BREAK 873219820Sjeffcase 9: 874219820SjeffYY_RULE_SETUP 875219820Sjeff#line 116 "./config_scanner.l" 876219820Sjeff{ 877219820Sjeff yylval.ival = USE; 878219820Sjeff#ifdef DEBUG 879219820Sjeff printf("USE\n"); 880219820Sjeff#endif 881219820Sjeff return USE; 882219820Sjeff} 883219820Sjeff YY_BREAK 884219820Sjeffcase 10: 885219820SjeffYY_RULE_SETUP 886219820Sjeff#line 124 "./config_scanner.l" 887219820Sjeff{ 888219820Sjeff yylval.ival = TCP; 889219820Sjeff#ifdef DEBUG 890219820Sjeff printf("TCP\n"); 891219820Sjeff#endif 892219820Sjeff return TCP; 893219820Sjeff} 894219820Sjeff YY_BREAK 895219820Sjeffcase 11: 896219820SjeffYY_RULE_SETUP 897219820Sjeff#line 132 "./config_scanner.l" 898219820Sjeff{ 899219820Sjeff yylval.ival = SDP; 900219820Sjeff#ifdef DEBUG 901219820Sjeff printf("SDP\n"); 902219820Sjeff#endif 903219820Sjeff return SDP; 904219820Sjeff} 905219820Sjeff YY_BREAK 906219820Sjeffcase 12: 907219820SjeffYY_RULE_SETUP 908219820Sjeff#line 140 "./config_scanner.l" 909219820Sjeff{ 910219820Sjeff yylval.ival = BOTH; 911219820Sjeff#ifdef DEBUG 912219820Sjeff printf("BOTH\n"); 913219820Sjeff#endif 914219820Sjeff return BOTH; 915219820Sjeff} 916219820Sjeff YY_BREAK 917219820Sjeffcase 13: 918219820SjeffYY_RULE_SETUP 919219820Sjeff#line 148 "./config_scanner.l" 920219820Sjeff{ 921219820Sjeff yylval.ival = CLIENT; 922219820Sjeff#ifdef DEBUG 923219820Sjeff printf("CLIENT\n"); 924219820Sjeff#endif 925219820Sjeff BEGIN(CANNAME); 926219820Sjeff return CLIENT; 927219820Sjeff} 928219820Sjeff YY_BREAK 929219820Sjeffcase 14: 930219820SjeffYY_RULE_SETUP 931219820Sjeff#line 157 "./config_scanner.l" 932219820Sjeff{ 933219820Sjeff yylval.ival = SERVER; 934219820Sjeff#ifdef DEBUG 935219820Sjeff printf("SERVER\n"); 936219820Sjeff#endif 937219820Sjeff BEGIN(CANNAME); 938219820Sjeff return SERVER; 939219820Sjeff} 940219820Sjeff YY_BREAK 941219820Sjeffcase 15: 942219820SjeffYY_RULE_SETUP 943219820Sjeff#line 166 "./config_scanner.l" 944219820Sjeff{ 945219820Sjeff yylval.sval = (char *)malloc(strlen(yytext) + 1); 946219820Sjeff strcpy(yylval.sval, yytext); 947219820Sjeff#ifdef DEBUG 948219820Sjeff printf("NAME:%s\n",yylval.sval); 949219820Sjeff#endif 950219820Sjeff BEGIN(0); 951219820Sjeff return (NAME); 952219820Sjeff} 953219820Sjeff YY_BREAK 954219820Sjeffcase 16: 955219820SjeffYY_RULE_SETUP 956219820Sjeff#line 176 "./config_scanner.l" 957219820Sjeff{ 958219820Sjeff __sdp_config_line_num++; 959219820Sjeff#ifdef DEBUG 960219820Sjeff printf("LINE\n"); 961219820Sjeff#endif 962219820Sjeff yylval.ival = LINE; 963219820Sjeff return(LINE); 964219820Sjeff} 965219820Sjeff YY_BREAK 966219820Sjeffcase 17: 967219820SjeffYY_RULE_SETUP 968219820Sjeff#line 185 "./config_scanner.l" 969219820Sjeff{ 970219820Sjeff __sdp_config_line_num++; 971219820Sjeff} 972219820Sjeff YY_BREAK 973219820Sjeffcase 18: 974219820SjeffYY_RULE_SETUP 975219820Sjeff#line 189 "./config_scanner.l" 976219820Sjeff{} 977219820Sjeff YY_BREAK 978219820Sjeffcase 19: 979219820SjeffYY_RULE_SETUP 980219820Sjeff#line 191 "./config_scanner.l" 981219820Sjeff{ 982219820Sjeff#ifdef DEBUG 983219820Sjeff printf("CHAR:%c\n",yytext[0]); 984219820Sjeff#endif 985219820Sjeff return(yytext[0]); 986219820Sjeff} 987219820Sjeff YY_BREAK 988219820Sjeffcase 20: 989219820SjeffYY_RULE_SETUP 990219820Sjeff#line 198 "./config_scanner.l" 991219820SjeffECHO; 992219820Sjeff YY_BREAK 993219820Sjeff#line 994 "lex.libsdp_yy.c" 994219820Sjeffcase YY_STATE_EOF(INITIAL): 995219820Sjeffcase YY_STATE_EOF(CANNAME): 996219820Sjeff yyterminate(); 997219820Sjeff 998219820Sjeff case YY_END_OF_BUFFER: 999219820Sjeff { 1000219820Sjeff /* Amount of text matched not including the EOB char. */ 1001219820Sjeff int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1; 1002219820Sjeff 1003219820Sjeff /* Undo the effects of YY_DO_BEFORE_ACTION. */ 1004219820Sjeff *yy_cp = yy_hold_char; 1005219820Sjeff YY_RESTORE_YY_MORE_OFFSET 1006219820Sjeff 1007219820Sjeff if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW ) 1008219820Sjeff { 1009219820Sjeff /* We're scanning a new file or input source. It's 1010219820Sjeff * possible that this happened because the user 1011219820Sjeff * just pointed yyin at a new source and called 1012219820Sjeff * yylex(). If so, then we have to assure 1013219820Sjeff * consistency between yy_current_buffer and our 1014219820Sjeff * globals. Here is the right place to do so, because 1015219820Sjeff * this is the first action (other than possibly a 1016219820Sjeff * back-up) that will match for the new input source. 1017219820Sjeff */ 1018219820Sjeff yy_n_chars = yy_current_buffer->yy_n_chars; 1019219820Sjeff yy_current_buffer->yy_input_file = yyin; 1020219820Sjeff yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL; 1021219820Sjeff } 1022219820Sjeff 1023219820Sjeff /* Note that here we test for yy_c_buf_p "<=" to the position 1024219820Sjeff * of the first EOB in the buffer, since yy_c_buf_p will 1025219820Sjeff * already have been incremented past the NUL character 1026219820Sjeff * (since all states make transitions on EOB to the 1027219820Sjeff * end-of-buffer state). Contrast this with the test 1028219820Sjeff * in input(). 1029219820Sjeff */ 1030219820Sjeff if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1031219820Sjeff { /* This was really a NUL. */ 1032219820Sjeff yy_state_type yy_next_state; 1033219820Sjeff 1034219820Sjeff yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text; 1035219820Sjeff 1036219820Sjeff yy_current_state = yy_get_previous_state(); 1037219820Sjeff 1038219820Sjeff /* Okay, we're now positioned to make the NUL 1039219820Sjeff * transition. We couldn't have 1040219820Sjeff * yy_get_previous_state() go ahead and do it 1041219820Sjeff * for us because it doesn't know how to deal 1042219820Sjeff * with the possibility of jamming (and we don't 1043219820Sjeff * want to build jamming into it because then it 1044219820Sjeff * will run more slowly). 1045219820Sjeff */ 1046219820Sjeff 1047219820Sjeff yy_next_state = yy_try_NUL_trans( yy_current_state ); 1048219820Sjeff 1049219820Sjeff yy_bp = yytext_ptr + YY_MORE_ADJ; 1050219820Sjeff 1051219820Sjeff if ( yy_next_state ) 1052219820Sjeff { 1053219820Sjeff /* Consume the NUL. */ 1054219820Sjeff yy_cp = ++yy_c_buf_p; 1055219820Sjeff yy_current_state = yy_next_state; 1056219820Sjeff goto yy_match; 1057219820Sjeff } 1058219820Sjeff 1059219820Sjeff else 1060219820Sjeff { 1061219820Sjeff yy_cp = yy_c_buf_p; 1062219820Sjeff goto yy_find_action; 1063219820Sjeff } 1064219820Sjeff } 1065219820Sjeff 1066219820Sjeff else switch ( yy_get_next_buffer() ) 1067219820Sjeff { 1068219820Sjeff case EOB_ACT_END_OF_FILE: 1069219820Sjeff { 1070219820Sjeff yy_did_buffer_switch_on_eof = 0; 1071219820Sjeff 1072219820Sjeff if ( yywrap() ) 1073219820Sjeff { 1074219820Sjeff /* Note: because we've taken care in 1075219820Sjeff * yy_get_next_buffer() to have set up 1076219820Sjeff * yytext, we can now set up 1077219820Sjeff * yy_c_buf_p so that if some total 1078219820Sjeff * hoser (like flex itself) wants to 1079219820Sjeff * call the scanner after we return the 1080219820Sjeff * YY_NULL, it'll still work - another 1081219820Sjeff * YY_NULL will get returned. 1082219820Sjeff */ 1083219820Sjeff yy_c_buf_p = yytext_ptr + YY_MORE_ADJ; 1084219820Sjeff 1085219820Sjeff yy_act = YY_STATE_EOF(YY_START); 1086219820Sjeff goto do_action; 1087219820Sjeff } 1088219820Sjeff 1089219820Sjeff else 1090219820Sjeff { 1091219820Sjeff if ( ! yy_did_buffer_switch_on_eof ) 1092219820Sjeff YY_NEW_FILE; 1093219820Sjeff } 1094219820Sjeff break; 1095219820Sjeff } 1096219820Sjeff 1097219820Sjeff case EOB_ACT_CONTINUE_SCAN: 1098219820Sjeff yy_c_buf_p = 1099219820Sjeff yytext_ptr + yy_amount_of_matched_text; 1100219820Sjeff 1101219820Sjeff yy_current_state = yy_get_previous_state(); 1102219820Sjeff 1103219820Sjeff yy_cp = yy_c_buf_p; 1104219820Sjeff yy_bp = yytext_ptr + YY_MORE_ADJ; 1105219820Sjeff goto yy_match; 1106219820Sjeff 1107219820Sjeff case EOB_ACT_LAST_MATCH: 1108219820Sjeff yy_c_buf_p = 1109219820Sjeff &yy_current_buffer->yy_ch_buf[yy_n_chars]; 1110219820Sjeff 1111219820Sjeff yy_current_state = yy_get_previous_state(); 1112219820Sjeff 1113219820Sjeff yy_cp = yy_c_buf_p; 1114219820Sjeff yy_bp = yytext_ptr + YY_MORE_ADJ; 1115219820Sjeff goto yy_find_action; 1116219820Sjeff } 1117219820Sjeff break; 1118219820Sjeff } 1119219820Sjeff 1120219820Sjeff default: 1121219820Sjeff YY_FATAL_ERROR( 1122219820Sjeff "fatal flex scanner internal error--no action found" ); 1123219820Sjeff } /* end of action switch */ 1124219820Sjeff } /* end of scanning one token */ 1125219820Sjeff } /* end of yylex */ 1126219820Sjeff 1127219820Sjeff 1128219820Sjeff/* yy_get_next_buffer - try to read in a new buffer 1129219820Sjeff * 1130219820Sjeff * Returns a code representing an action: 1131219820Sjeff * EOB_ACT_LAST_MATCH - 1132219820Sjeff * EOB_ACT_CONTINUE_SCAN - continue scanning from current position 1133219820Sjeff * EOB_ACT_END_OF_FILE - end of file 1134219820Sjeff */ 1135219820Sjeff 1136219820Sjeffstatic int yy_get_next_buffer() 1137219820Sjeff { 1138219820Sjeff register char *dest = yy_current_buffer->yy_ch_buf; 1139219820Sjeff register char *source = yytext_ptr; 1140219820Sjeff register int number_to_move, i; 1141219820Sjeff int ret_val; 1142219820Sjeff 1143219820Sjeff if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] ) 1144219820Sjeff YY_FATAL_ERROR( 1145219820Sjeff "fatal flex scanner internal error--end of buffer missed" ); 1146219820Sjeff 1147219820Sjeff if ( yy_current_buffer->yy_fill_buffer == 0 ) 1148219820Sjeff { /* Don't try to fill the buffer, so this is an EOF. */ 1149219820Sjeff if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 ) 1150219820Sjeff { 1151219820Sjeff /* We matched a single character, the EOB, so 1152219820Sjeff * treat this as a final EOF. 1153219820Sjeff */ 1154219820Sjeff return EOB_ACT_END_OF_FILE; 1155219820Sjeff } 1156219820Sjeff 1157219820Sjeff else 1158219820Sjeff { 1159219820Sjeff /* We matched some text prior to the EOB, first 1160219820Sjeff * process it. 1161219820Sjeff */ 1162219820Sjeff return EOB_ACT_LAST_MATCH; 1163219820Sjeff } 1164219820Sjeff } 1165219820Sjeff 1166219820Sjeff /* Try to read more data. */ 1167219820Sjeff 1168219820Sjeff /* First move last chars to start of buffer. */ 1169219820Sjeff number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1; 1170219820Sjeff 1171219820Sjeff for ( i = 0; i < number_to_move; ++i ) 1172219820Sjeff *(dest++) = *(source++); 1173219820Sjeff 1174219820Sjeff if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING ) 1175219820Sjeff /* don't do the read, it's not guaranteed to return an EOF, 1176219820Sjeff * just force an EOF 1177219820Sjeff */ 1178219820Sjeff yy_current_buffer->yy_n_chars = yy_n_chars = 0; 1179219820Sjeff 1180219820Sjeff else 1181219820Sjeff { 1182219820Sjeff int num_to_read = 1183219820Sjeff yy_current_buffer->yy_buf_size - number_to_move - 1; 1184219820Sjeff 1185219820Sjeff while ( num_to_read <= 0 ) 1186219820Sjeff { /* Not enough room in the buffer - grow it. */ 1187219820Sjeff#ifdef YY_USES_REJECT 1188219820Sjeff YY_FATAL_ERROR( 1189219820Sjeff"input buffer overflow, can't enlarge buffer because scanner uses REJECT" ); 1190219820Sjeff#else 1191219820Sjeff 1192219820Sjeff /* just a shorter name for the current buffer */ 1193219820Sjeff YY_BUFFER_STATE b = yy_current_buffer; 1194219820Sjeff 1195219820Sjeff int yy_c_buf_p_offset = 1196219820Sjeff (int) (yy_c_buf_p - b->yy_ch_buf); 1197219820Sjeff 1198219820Sjeff if ( b->yy_is_our_buffer ) 1199219820Sjeff { 1200219820Sjeff int new_size = b->yy_buf_size * 2; 1201219820Sjeff 1202219820Sjeff if ( new_size <= 0 ) 1203219820Sjeff b->yy_buf_size += b->yy_buf_size / 8; 1204219820Sjeff else 1205219820Sjeff b->yy_buf_size *= 2; 1206219820Sjeff 1207219820Sjeff b->yy_ch_buf = (char *) 1208219820Sjeff /* Include room in for 2 EOB chars. */ 1209219820Sjeff yy_flex_realloc( (void *) b->yy_ch_buf, 1210219820Sjeff b->yy_buf_size + 2 ); 1211219820Sjeff } 1212219820Sjeff else 1213219820Sjeff /* Can't grow it, we don't own it. */ 1214219820Sjeff b->yy_ch_buf = 0; 1215219820Sjeff 1216219820Sjeff if ( ! b->yy_ch_buf ) 1217219820Sjeff YY_FATAL_ERROR( 1218219820Sjeff "fatal error - scanner input buffer overflow" ); 1219219820Sjeff 1220219820Sjeff yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; 1221219820Sjeff 1222219820Sjeff num_to_read = yy_current_buffer->yy_buf_size - 1223219820Sjeff number_to_move - 1; 1224219820Sjeff#endif 1225219820Sjeff } 1226219820Sjeff 1227219820Sjeff if ( num_to_read > YY_READ_BUF_SIZE ) 1228219820Sjeff num_to_read = YY_READ_BUF_SIZE; 1229219820Sjeff 1230219820Sjeff /* Read in more data. */ 1231219820Sjeff YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]), 1232219820Sjeff yy_n_chars, num_to_read ); 1233219820Sjeff 1234219820Sjeff yy_current_buffer->yy_n_chars = yy_n_chars; 1235219820Sjeff } 1236219820Sjeff 1237219820Sjeff if ( yy_n_chars == 0 ) 1238219820Sjeff { 1239219820Sjeff if ( number_to_move == YY_MORE_ADJ ) 1240219820Sjeff { 1241219820Sjeff ret_val = EOB_ACT_END_OF_FILE; 1242219820Sjeff yyrestart( yyin ); 1243219820Sjeff } 1244219820Sjeff 1245219820Sjeff else 1246219820Sjeff { 1247219820Sjeff ret_val = EOB_ACT_LAST_MATCH; 1248219820Sjeff yy_current_buffer->yy_buffer_status = 1249219820Sjeff YY_BUFFER_EOF_PENDING; 1250219820Sjeff } 1251219820Sjeff } 1252219820Sjeff 1253219820Sjeff else 1254219820Sjeff ret_val = EOB_ACT_CONTINUE_SCAN; 1255219820Sjeff 1256219820Sjeff yy_n_chars += number_to_move; 1257219820Sjeff yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR; 1258219820Sjeff yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; 1259219820Sjeff 1260219820Sjeff yytext_ptr = &yy_current_buffer->yy_ch_buf[0]; 1261219820Sjeff 1262219820Sjeff return ret_val; 1263219820Sjeff } 1264219820Sjeff 1265219820Sjeff 1266219820Sjeff/* yy_get_previous_state - get the state just before the EOB char was reached */ 1267219820Sjeff 1268219820Sjeffstatic yy_state_type yy_get_previous_state() 1269219820Sjeff { 1270219820Sjeff register yy_state_type yy_current_state; 1271219820Sjeff register char *yy_cp; 1272219820Sjeff 1273219820Sjeff yy_current_state = yy_start; 1274219820Sjeff yy_current_state += YY_AT_BOL(); 1275219820Sjeff 1276219820Sjeff for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp ) 1277219820Sjeff { 1278219820Sjeff register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); 1279219820Sjeff if ( yy_accept[yy_current_state] ) 1280219820Sjeff { 1281219820Sjeff yy_last_accepting_state = yy_current_state; 1282219820Sjeff yy_last_accepting_cpos = yy_cp; 1283219820Sjeff } 1284219820Sjeff while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1285219820Sjeff { 1286219820Sjeff yy_current_state = (int) yy_def[yy_current_state]; 1287219820Sjeff if ( yy_current_state >= 171 ) 1288219820Sjeff yy_c = yy_meta[(unsigned int) yy_c]; 1289219820Sjeff } 1290219820Sjeff yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1291219820Sjeff } 1292219820Sjeff 1293219820Sjeff return yy_current_state; 1294219820Sjeff } 1295219820Sjeff 1296219820Sjeff 1297219820Sjeff/* yy_try_NUL_trans - try to make a transition on the NUL character 1298219820Sjeff * 1299219820Sjeff * synopsis 1300219820Sjeff * next_state = yy_try_NUL_trans( current_state ); 1301219820Sjeff */ 1302219820Sjeff 1303219820Sjeff#ifdef YY_USE_PROTOS 1304219820Sjeffstatic yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state ) 1305219820Sjeff#else 1306219820Sjeffstatic yy_state_type yy_try_NUL_trans( yy_current_state ) 1307219820Sjeffyy_state_type yy_current_state; 1308219820Sjeff#endif 1309219820Sjeff { 1310219820Sjeff register int yy_is_jam; 1311219820Sjeff register char *yy_cp = yy_c_buf_p; 1312219820Sjeff 1313219820Sjeff register YY_CHAR yy_c = 1; 1314219820Sjeff if ( yy_accept[yy_current_state] ) 1315219820Sjeff { 1316219820Sjeff yy_last_accepting_state = yy_current_state; 1317219820Sjeff yy_last_accepting_cpos = yy_cp; 1318219820Sjeff } 1319219820Sjeff while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) 1320219820Sjeff { 1321219820Sjeff yy_current_state = (int) yy_def[yy_current_state]; 1322219820Sjeff if ( yy_current_state >= 171 ) 1323219820Sjeff yy_c = yy_meta[(unsigned int) yy_c]; 1324219820Sjeff } 1325219820Sjeff yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c]; 1326219820Sjeff yy_is_jam = (yy_current_state == 170); 1327219820Sjeff 1328219820Sjeff return yy_is_jam ? 0 : yy_current_state; 1329219820Sjeff } 1330219820Sjeff 1331219820Sjeff 1332219820Sjeff#ifndef YY_NO_UNPUT 1333219820Sjeff#ifdef YY_USE_PROTOS 1334219820Sjeffstatic void yyunput( int c, register char *yy_bp ) 1335219820Sjeff#else 1336219820Sjeffstatic void yyunput( c, yy_bp ) 1337219820Sjeffint c; 1338219820Sjeffregister char *yy_bp; 1339219820Sjeff#endif 1340219820Sjeff { 1341219820Sjeff register char *yy_cp = yy_c_buf_p; 1342219820Sjeff 1343219820Sjeff /* undo effects of setting up yytext */ 1344219820Sjeff *yy_cp = yy_hold_char; 1345219820Sjeff 1346219820Sjeff if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1347219820Sjeff { /* need to shift things up to make room */ 1348219820Sjeff /* +2 for EOB chars. */ 1349219820Sjeff register int number_to_move = yy_n_chars + 2; 1350219820Sjeff register char *dest = &yy_current_buffer->yy_ch_buf[ 1351219820Sjeff yy_current_buffer->yy_buf_size + 2]; 1352219820Sjeff register char *source = 1353219820Sjeff &yy_current_buffer->yy_ch_buf[number_to_move]; 1354219820Sjeff 1355219820Sjeff while ( source > yy_current_buffer->yy_ch_buf ) 1356219820Sjeff *--dest = *--source; 1357219820Sjeff 1358219820Sjeff yy_cp += (int) (dest - source); 1359219820Sjeff yy_bp += (int) (dest - source); 1360219820Sjeff yy_current_buffer->yy_n_chars = 1361219820Sjeff yy_n_chars = yy_current_buffer->yy_buf_size; 1362219820Sjeff 1363219820Sjeff if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 ) 1364219820Sjeff YY_FATAL_ERROR( "flex scanner push-back overflow" ); 1365219820Sjeff } 1366219820Sjeff 1367219820Sjeff *--yy_cp = (char) c; 1368219820Sjeff 1369219820Sjeff 1370219820Sjeff yytext_ptr = yy_bp; 1371219820Sjeff yy_hold_char = *yy_cp; 1372219820Sjeff yy_c_buf_p = yy_cp; 1373219820Sjeff } 1374219820Sjeff#endif /* ifndef YY_NO_UNPUT */ 1375219820Sjeff 1376219820Sjeff 1377219820Sjeff#ifndef YY_NO_INPUT 1378219820Sjeff#ifdef __cplusplus 1379219820Sjeffstatic int yyinput() 1380219820Sjeff#else 1381219820Sjeffstatic int input() 1382219820Sjeff#endif 1383219820Sjeff { 1384219820Sjeff int c; 1385219820Sjeff 1386219820Sjeff *yy_c_buf_p = yy_hold_char; 1387219820Sjeff 1388219820Sjeff if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) 1389219820Sjeff { 1390219820Sjeff /* yy_c_buf_p now points to the character we want to return. 1391219820Sjeff * If this occurs *before* the EOB characters, then it's a 1392219820Sjeff * valid NUL; if not, then we've hit the end of the buffer. 1393219820Sjeff */ 1394219820Sjeff if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] ) 1395219820Sjeff /* This was really a NUL. */ 1396219820Sjeff *yy_c_buf_p = '\0'; 1397219820Sjeff 1398219820Sjeff else 1399219820Sjeff { /* need more input */ 1400219820Sjeff int offset = yy_c_buf_p - yytext_ptr; 1401219820Sjeff ++yy_c_buf_p; 1402219820Sjeff 1403219820Sjeff switch ( yy_get_next_buffer() ) 1404219820Sjeff { 1405219820Sjeff case EOB_ACT_LAST_MATCH: 1406219820Sjeff /* This happens because yy_g_n_b() 1407219820Sjeff * sees that we've accumulated a 1408219820Sjeff * token and flags that we need to 1409219820Sjeff * try matching the token before 1410219820Sjeff * proceeding. But for input(), 1411219820Sjeff * there's no matching to consider. 1412219820Sjeff * So convert the EOB_ACT_LAST_MATCH 1413219820Sjeff * to EOB_ACT_END_OF_FILE. 1414219820Sjeff */ 1415219820Sjeff 1416219820Sjeff /* Reset buffer status. */ 1417219820Sjeff yyrestart( yyin ); 1418219820Sjeff 1419219820Sjeff /* fall through */ 1420219820Sjeff 1421219820Sjeff case EOB_ACT_END_OF_FILE: 1422219820Sjeff { 1423219820Sjeff if ( yywrap() ) 1424219820Sjeff return EOF; 1425219820Sjeff 1426219820Sjeff if ( ! yy_did_buffer_switch_on_eof ) 1427219820Sjeff YY_NEW_FILE; 1428219820Sjeff#ifdef __cplusplus 1429219820Sjeff return yyinput(); 1430219820Sjeff#else 1431219820Sjeff return input(); 1432219820Sjeff#endif 1433219820Sjeff } 1434219820Sjeff 1435219820Sjeff case EOB_ACT_CONTINUE_SCAN: 1436219820Sjeff yy_c_buf_p = yytext_ptr + offset; 1437219820Sjeff break; 1438219820Sjeff } 1439219820Sjeff } 1440219820Sjeff } 1441219820Sjeff 1442219820Sjeff c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */ 1443219820Sjeff *yy_c_buf_p = '\0'; /* preserve yytext */ 1444219820Sjeff yy_hold_char = *++yy_c_buf_p; 1445219820Sjeff 1446219820Sjeff yy_current_buffer->yy_at_bol = (c == '\n'); 1447219820Sjeff 1448219820Sjeff return c; 1449219820Sjeff } 1450219820Sjeff#endif /* YY_NO_INPUT */ 1451219820Sjeff 1452219820Sjeff#ifdef YY_USE_PROTOS 1453219820Sjeffvoid yyrestart( FILE *input_file ) 1454219820Sjeff#else 1455219820Sjeffvoid yyrestart( input_file ) 1456219820SjeffFILE *input_file; 1457219820Sjeff#endif 1458219820Sjeff { 1459219820Sjeff if ( ! yy_current_buffer ) 1460219820Sjeff yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); 1461219820Sjeff 1462219820Sjeff yy_init_buffer( yy_current_buffer, input_file ); 1463219820Sjeff yy_load_buffer_state(); 1464219820Sjeff } 1465219820Sjeff 1466219820Sjeff 1467219820Sjeff#ifdef YY_USE_PROTOS 1468219820Sjeffvoid yy_switch_to_buffer( YY_BUFFER_STATE new_buffer ) 1469219820Sjeff#else 1470219820Sjeffvoid yy_switch_to_buffer( new_buffer ) 1471219820SjeffYY_BUFFER_STATE new_buffer; 1472219820Sjeff#endif 1473219820Sjeff { 1474219820Sjeff if ( yy_current_buffer == new_buffer ) 1475219820Sjeff return; 1476219820Sjeff 1477219820Sjeff if ( yy_current_buffer ) 1478219820Sjeff { 1479219820Sjeff /* Flush out information for old buffer. */ 1480219820Sjeff *yy_c_buf_p = yy_hold_char; 1481219820Sjeff yy_current_buffer->yy_buf_pos = yy_c_buf_p; 1482219820Sjeff yy_current_buffer->yy_n_chars = yy_n_chars; 1483219820Sjeff } 1484219820Sjeff 1485219820Sjeff yy_current_buffer = new_buffer; 1486219820Sjeff yy_load_buffer_state(); 1487219820Sjeff 1488219820Sjeff /* We don't actually know whether we did this switch during 1489219820Sjeff * EOF (yywrap()) processing, but the only time this flag 1490219820Sjeff * is looked at is after yywrap() is called, so it's safe 1491219820Sjeff * to go ahead and always set it. 1492219820Sjeff */ 1493219820Sjeff yy_did_buffer_switch_on_eof = 1; 1494219820Sjeff } 1495219820Sjeff 1496219820Sjeff 1497219820Sjeff#ifdef YY_USE_PROTOS 1498219820Sjeffvoid yy_load_buffer_state( void ) 1499219820Sjeff#else 1500219820Sjeffvoid yy_load_buffer_state() 1501219820Sjeff#endif 1502219820Sjeff { 1503219820Sjeff yy_n_chars = yy_current_buffer->yy_n_chars; 1504219820Sjeff yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos; 1505219820Sjeff yyin = yy_current_buffer->yy_input_file; 1506219820Sjeff yy_hold_char = *yy_c_buf_p; 1507219820Sjeff } 1508219820Sjeff 1509219820Sjeff 1510219820Sjeff#ifdef YY_USE_PROTOS 1511219820SjeffYY_BUFFER_STATE yy_create_buffer( FILE *file, int size ) 1512219820Sjeff#else 1513219820SjeffYY_BUFFER_STATE yy_create_buffer( file, size ) 1514219820SjeffFILE *file; 1515219820Sjeffint size; 1516219820Sjeff#endif 1517219820Sjeff { 1518219820Sjeff YY_BUFFER_STATE b; 1519219820Sjeff 1520219820Sjeff b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1521219820Sjeff if ( ! b ) 1522219820Sjeff YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1523219820Sjeff 1524219820Sjeff b->yy_buf_size = size; 1525219820Sjeff 1526219820Sjeff /* yy_ch_buf has to be 2 characters longer than the size given because 1527219820Sjeff * we need to put in 2 end-of-buffer characters. 1528219820Sjeff */ 1529219820Sjeff b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 ); 1530219820Sjeff if ( ! b->yy_ch_buf ) 1531219820Sjeff YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); 1532219820Sjeff 1533219820Sjeff b->yy_is_our_buffer = 1; 1534219820Sjeff 1535219820Sjeff yy_init_buffer( b, file ); 1536219820Sjeff 1537219820Sjeff return b; 1538219820Sjeff } 1539219820Sjeff 1540219820Sjeff 1541219820Sjeff#ifdef YY_USE_PROTOS 1542219820Sjeffvoid yy_delete_buffer( YY_BUFFER_STATE b ) 1543219820Sjeff#else 1544219820Sjeffvoid yy_delete_buffer( b ) 1545219820SjeffYY_BUFFER_STATE b; 1546219820Sjeff#endif 1547219820Sjeff { 1548219820Sjeff if ( ! b ) 1549219820Sjeff return; 1550219820Sjeff 1551219820Sjeff if ( b == yy_current_buffer ) 1552219820Sjeff yy_current_buffer = (YY_BUFFER_STATE) 0; 1553219820Sjeff 1554219820Sjeff if ( b->yy_is_our_buffer ) 1555219820Sjeff yy_flex_free( (void *) b->yy_ch_buf ); 1556219820Sjeff 1557219820Sjeff yy_flex_free( (void *) b ); 1558219820Sjeff } 1559219820Sjeff 1560219820Sjeff 1561219820Sjeff 1562219820Sjeff#ifdef YY_USE_PROTOS 1563219820Sjeffvoid yy_init_buffer( YY_BUFFER_STATE b, FILE *file ) 1564219820Sjeff#else 1565219820Sjeffvoid yy_init_buffer( b, file ) 1566219820SjeffYY_BUFFER_STATE b; 1567219820SjeffFILE *file; 1568219820Sjeff#endif 1569219820Sjeff 1570219820Sjeff 1571219820Sjeff { 1572219820Sjeff yy_flush_buffer( b ); 1573219820Sjeff 1574219820Sjeff b->yy_input_file = file; 1575219820Sjeff b->yy_fill_buffer = 1; 1576219820Sjeff 1577219820Sjeff#if YY_ALWAYS_INTERACTIVE 1578219820Sjeff b->yy_is_interactive = 1; 1579219820Sjeff#else 1580219820Sjeff#if YY_NEVER_INTERACTIVE 1581219820Sjeff b->yy_is_interactive = 0; 1582219820Sjeff#else 1583219820Sjeff b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; 1584219820Sjeff#endif 1585219820Sjeff#endif 1586219820Sjeff } 1587219820Sjeff 1588219820Sjeff 1589219820Sjeff#ifdef YY_USE_PROTOS 1590219820Sjeffvoid yy_flush_buffer( YY_BUFFER_STATE b ) 1591219820Sjeff#else 1592219820Sjeffvoid yy_flush_buffer( b ) 1593219820SjeffYY_BUFFER_STATE b; 1594219820Sjeff#endif 1595219820Sjeff 1596219820Sjeff { 1597219820Sjeff if ( ! b ) 1598219820Sjeff return; 1599219820Sjeff 1600219820Sjeff b->yy_n_chars = 0; 1601219820Sjeff 1602219820Sjeff /* We always need two end-of-buffer characters. The first causes 1603219820Sjeff * a transition to the end-of-buffer state. The second causes 1604219820Sjeff * a jam in that state. 1605219820Sjeff */ 1606219820Sjeff b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; 1607219820Sjeff b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; 1608219820Sjeff 1609219820Sjeff b->yy_buf_pos = &b->yy_ch_buf[0]; 1610219820Sjeff 1611219820Sjeff b->yy_at_bol = 1; 1612219820Sjeff b->yy_buffer_status = YY_BUFFER_NEW; 1613219820Sjeff 1614219820Sjeff if ( b == yy_current_buffer ) 1615219820Sjeff yy_load_buffer_state(); 1616219820Sjeff } 1617219820Sjeff 1618219820Sjeff 1619219820Sjeff#ifndef YY_NO_SCAN_BUFFER 1620219820Sjeff#ifdef YY_USE_PROTOS 1621219820SjeffYY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size ) 1622219820Sjeff#else 1623219820SjeffYY_BUFFER_STATE yy_scan_buffer( base, size ) 1624219820Sjeffchar *base; 1625219820Sjeffyy_size_t size; 1626219820Sjeff#endif 1627219820Sjeff { 1628219820Sjeff YY_BUFFER_STATE b; 1629219820Sjeff 1630219820Sjeff if ( size < 2 || 1631219820Sjeff base[size-2] != YY_END_OF_BUFFER_CHAR || 1632219820Sjeff base[size-1] != YY_END_OF_BUFFER_CHAR ) 1633219820Sjeff /* They forgot to leave room for the EOB's. */ 1634219820Sjeff return 0; 1635219820Sjeff 1636219820Sjeff b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) ); 1637219820Sjeff if ( ! b ) 1638219820Sjeff YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); 1639219820Sjeff 1640219820Sjeff b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */ 1641219820Sjeff b->yy_buf_pos = b->yy_ch_buf = base; 1642219820Sjeff b->yy_is_our_buffer = 0; 1643219820Sjeff b->yy_input_file = 0; 1644219820Sjeff b->yy_n_chars = b->yy_buf_size; 1645219820Sjeff b->yy_is_interactive = 0; 1646219820Sjeff b->yy_at_bol = 1; 1647219820Sjeff b->yy_fill_buffer = 0; 1648219820Sjeff b->yy_buffer_status = YY_BUFFER_NEW; 1649219820Sjeff 1650219820Sjeff yy_switch_to_buffer( b ); 1651219820Sjeff 1652219820Sjeff return b; 1653219820Sjeff } 1654219820Sjeff#endif 1655219820Sjeff 1656219820Sjeff 1657219820Sjeff#ifndef YY_NO_SCAN_STRING 1658219820Sjeff#ifdef YY_USE_PROTOS 1659219820SjeffYY_BUFFER_STATE yy_scan_string( yyconst char *yy_str ) 1660219820Sjeff#else 1661219820SjeffYY_BUFFER_STATE yy_scan_string( yy_str ) 1662219820Sjeffyyconst char *yy_str; 1663219820Sjeff#endif 1664219820Sjeff { 1665219820Sjeff int len; 1666219820Sjeff for ( len = 0; yy_str[len]; ++len ) 1667219820Sjeff ; 1668219820Sjeff 1669219820Sjeff return yy_scan_bytes( yy_str, len ); 1670219820Sjeff } 1671219820Sjeff#endif 1672219820Sjeff 1673219820Sjeff 1674219820Sjeff#ifndef YY_NO_SCAN_BYTES 1675219820Sjeff#ifdef YY_USE_PROTOS 1676219820SjeffYY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len ) 1677219820Sjeff#else 1678219820SjeffYY_BUFFER_STATE yy_scan_bytes( bytes, len ) 1679219820Sjeffyyconst char *bytes; 1680219820Sjeffint len; 1681219820Sjeff#endif 1682219820Sjeff { 1683219820Sjeff YY_BUFFER_STATE b; 1684219820Sjeff char *buf; 1685219820Sjeff yy_size_t n; 1686219820Sjeff int i; 1687219820Sjeff 1688219820Sjeff /* Get memory for full buffer, including space for trailing EOB's. */ 1689219820Sjeff n = len + 2; 1690219820Sjeff buf = (char *) yy_flex_alloc( n ); 1691219820Sjeff if ( ! buf ) 1692219820Sjeff YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); 1693219820Sjeff 1694219820Sjeff for ( i = 0; i < len; ++i ) 1695219820Sjeff buf[i] = bytes[i]; 1696219820Sjeff 1697219820Sjeff buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR; 1698219820Sjeff 1699219820Sjeff b = yy_scan_buffer( buf, n ); 1700219820Sjeff if ( ! b ) 1701219820Sjeff YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); 1702219820Sjeff 1703219820Sjeff /* It's okay to grow etc. this buffer, and we should throw it 1704219820Sjeff * away when we're done. 1705219820Sjeff */ 1706219820Sjeff b->yy_is_our_buffer = 1; 1707219820Sjeff 1708219820Sjeff return b; 1709219820Sjeff } 1710219820Sjeff#endif 1711219820Sjeff 1712219820Sjeff 1713219820Sjeff#ifndef YY_NO_PUSH_STATE 1714219820Sjeff#ifdef YY_USE_PROTOS 1715219820Sjeffstatic void yy_push_state( int new_state ) 1716219820Sjeff#else 1717219820Sjeffstatic void yy_push_state( new_state ) 1718219820Sjeffint new_state; 1719219820Sjeff#endif 1720219820Sjeff { 1721219820Sjeff if ( yy_start_stack_ptr >= yy_start_stack_depth ) 1722219820Sjeff { 1723219820Sjeff yy_size_t new_size; 1724219820Sjeff 1725219820Sjeff yy_start_stack_depth += YY_START_STACK_INCR; 1726219820Sjeff new_size = yy_start_stack_depth * sizeof( int ); 1727219820Sjeff 1728219820Sjeff if ( ! yy_start_stack ) 1729219820Sjeff yy_start_stack = (int *) yy_flex_alloc( new_size ); 1730219820Sjeff 1731219820Sjeff else 1732219820Sjeff yy_start_stack = (int *) yy_flex_realloc( 1733219820Sjeff (void *) yy_start_stack, new_size ); 1734219820Sjeff 1735219820Sjeff if ( ! yy_start_stack ) 1736219820Sjeff YY_FATAL_ERROR( 1737219820Sjeff "out of memory expanding start-condition stack" ); 1738219820Sjeff } 1739219820Sjeff 1740219820Sjeff yy_start_stack[yy_start_stack_ptr++] = YY_START; 1741219820Sjeff 1742219820Sjeff BEGIN(new_state); 1743219820Sjeff } 1744219820Sjeff#endif 1745219820Sjeff 1746219820Sjeff 1747219820Sjeff#ifndef YY_NO_POP_STATE 1748219820Sjeffstatic void yy_pop_state() 1749219820Sjeff { 1750219820Sjeff if ( --yy_start_stack_ptr < 0 ) 1751219820Sjeff YY_FATAL_ERROR( "start-condition stack underflow" ); 1752219820Sjeff 1753219820Sjeff BEGIN(yy_start_stack[yy_start_stack_ptr]); 1754219820Sjeff } 1755219820Sjeff#endif 1756219820Sjeff 1757219820Sjeff 1758219820Sjeff#ifndef YY_NO_TOP_STATE 1759219820Sjeffstatic int yy_top_state() 1760219820Sjeff { 1761219820Sjeff return yy_start_stack[yy_start_stack_ptr - 1]; 1762219820Sjeff } 1763219820Sjeff#endif 1764219820Sjeff 1765219820Sjeff#ifndef YY_EXIT_FAILURE 1766219820Sjeff#define YY_EXIT_FAILURE 2 1767219820Sjeff#endif 1768219820Sjeff 1769219820Sjeff#ifdef YY_USE_PROTOS 1770219820Sjeffstatic void yy_fatal_error( yyconst char msg[] ) 1771219820Sjeff#else 1772219820Sjeffstatic void yy_fatal_error( msg ) 1773219820Sjeffchar msg[]; 1774219820Sjeff#endif 1775219820Sjeff { 1776219820Sjeff (void) fprintf( stderr, "%s\n", msg ); 1777219820Sjeff exit( YY_EXIT_FAILURE ); 1778219820Sjeff } 1779219820Sjeff 1780219820Sjeff 1781219820Sjeff 1782219820Sjeff/* Redefine yyless() so it works in section 3 code. */ 1783219820Sjeff 1784219820Sjeff#undef yyless 1785219820Sjeff#define yyless(n) \ 1786219820Sjeff do \ 1787219820Sjeff { \ 1788219820Sjeff /* Undo effects of setting up yytext. */ \ 1789219820Sjeff yytext[yyleng] = yy_hold_char; \ 1790219820Sjeff yy_c_buf_p = yytext + n; \ 1791219820Sjeff yy_hold_char = *yy_c_buf_p; \ 1792219820Sjeff *yy_c_buf_p = '\0'; \ 1793219820Sjeff yyleng = n; \ 1794219820Sjeff } \ 1795219820Sjeff while ( 0 ) 1796219820Sjeff 1797219820Sjeff 1798219820Sjeff/* Internal utility routines. */ 1799219820Sjeff 1800219820Sjeff#ifndef yytext_ptr 1801219820Sjeff#ifdef YY_USE_PROTOS 1802219820Sjeffstatic void yy_flex_strncpy( char *s1, yyconst char *s2, int n ) 1803219820Sjeff#else 1804219820Sjeffstatic void yy_flex_strncpy( s1, s2, n ) 1805219820Sjeffchar *s1; 1806219820Sjeffyyconst char *s2; 1807219820Sjeffint n; 1808219820Sjeff#endif 1809219820Sjeff { 1810219820Sjeff register int i; 1811219820Sjeff for ( i = 0; i < n; ++i ) 1812219820Sjeff s1[i] = s2[i]; 1813219820Sjeff } 1814219820Sjeff#endif 1815219820Sjeff 1816219820Sjeff#ifdef YY_NEED_STRLEN 1817219820Sjeff#ifdef YY_USE_PROTOS 1818219820Sjeffstatic int yy_flex_strlen( yyconst char *s ) 1819219820Sjeff#else 1820219820Sjeffstatic int yy_flex_strlen( s ) 1821219820Sjeffyyconst char *s; 1822219820Sjeff#endif 1823219820Sjeff { 1824219820Sjeff register int n; 1825219820Sjeff for ( n = 0; s[n]; ++n ) 1826219820Sjeff ; 1827219820Sjeff 1828219820Sjeff return n; 1829219820Sjeff } 1830219820Sjeff#endif 1831219820Sjeff 1832219820Sjeff 1833219820Sjeff#ifdef YY_USE_PROTOS 1834219820Sjeffstatic void *yy_flex_alloc( yy_size_t size ) 1835219820Sjeff#else 1836219820Sjeffstatic void *yy_flex_alloc( size ) 1837219820Sjeffyy_size_t size; 1838219820Sjeff#endif 1839219820Sjeff { 1840219820Sjeff return (void *) malloc( size ); 1841219820Sjeff } 1842219820Sjeff 1843219820Sjeff#ifdef YY_USE_PROTOS 1844219820Sjeffstatic void *yy_flex_realloc( void *ptr, yy_size_t size ) 1845219820Sjeff#else 1846219820Sjeffstatic void *yy_flex_realloc( ptr, size ) 1847219820Sjeffvoid *ptr; 1848219820Sjeffyy_size_t size; 1849219820Sjeff#endif 1850219820Sjeff { 1851219820Sjeff /* The cast to (char *) in the following accommodates both 1852219820Sjeff * implementations that use char* generic pointers, and those 1853219820Sjeff * that use void* generic pointers. It works with the latter 1854219820Sjeff * because both ANSI C and C++ allow castless assignment from 1855219820Sjeff * any pointer type to void*, and deal with argument conversions 1856219820Sjeff * as though doing an assignment. 1857219820Sjeff */ 1858219820Sjeff return (void *) realloc( (char *) ptr, size ); 1859219820Sjeff } 1860219820Sjeff 1861219820Sjeff#ifdef YY_USE_PROTOS 1862219820Sjeffstatic void yy_flex_free( void *ptr ) 1863219820Sjeff#else 1864219820Sjeffstatic void yy_flex_free( ptr ) 1865219820Sjeffvoid *ptr; 1866219820Sjeff#endif 1867219820Sjeff { 1868219820Sjeff free( ptr ); 1869219820Sjeff } 1870219820Sjeff 1871219820Sjeff#if YY_MAIN 1872219820Sjeffint main() 1873219820Sjeff { 1874219820Sjeff yylex(); 1875219820Sjeff return 0; 1876219820Sjeff } 1877219820Sjeff#endif 1878219820Sjeff#line 198 "./config_scanner.l" 1879219820Sjeff 1880219820Sjeff 1881219820Sjeffint yywrap () 1882219820Sjeff{ 1883219820Sjeff return (1); 1884219820Sjeff} 1885219820Sjeff 1886