Something went wrong. Try again.
This repository has no description
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090
#define YY_INT_ALIGNED short int
/* A lexical scanner generated by flex */
#define yy_create_buffer regex_yy_create_buffer#define yy_delete_buffer regex_yy_delete_buffer#define yy_scan_buffer regex_yy_scan_buffer#define yy_scan_string regex_yy_scan_string#define yy_scan_bytes regex_yy_scan_bytes#define yy_init_buffer regex_yy_init_buffer#define yy_flush_buffer regex_yy_flush_buffer#define yy_load_buffer_state regex_yy_load_buffer_state#define yy_switch_to_buffer regex_yy_switch_to_buffer#define yypush_buffer_state regex_yypush_buffer_state#define yypop_buffer_state regex_yypop_buffer_state#define yyensure_buffer_stack regex_yyensure_buffer_stack#define yy_flex_debug regex_yy_flex_debug#define yyin regex_yyin#define yyleng regex_yyleng#define yylex regex_yylex#define yylineno regex_yylineno#define yyout regex_yyout#define yyrestart regex_yyrestart#define yytext regex_yytext#define yywrap regex_yywrap#define yyalloc regex_yyalloc#define yyrealloc regex_yyrealloc#define yyfree regex_yyfree
#define FLEX_SCANNER#define YY_FLEX_MAJOR_VERSION 2#define YY_FLEX_MINOR_VERSION 6#define YY_FLEX_SUBMINOR_VERSION 4#if YY_FLEX_SUBMINOR_VERSION > 0#define FLEX_BETA#endif
#ifdef yy_create_buffer#define regex_yy_create_buffer_ALREADY_DEFINED#else#define yy_create_buffer regex_yy_create_buffer#endif
#ifdef yy_delete_buffer#define regex_yy_delete_buffer_ALREADY_DEFINED#else#define yy_delete_buffer regex_yy_delete_buffer#endif
#ifdef yy_scan_buffer#define regex_yy_scan_buffer_ALREADY_DEFINED#else#define yy_scan_buffer regex_yy_scan_buffer#endif
#ifdef yy_scan_string#define regex_yy_scan_string_ALREADY_DEFINED#else#define yy_scan_string regex_yy_scan_string#endif
#ifdef yy_scan_bytes#define regex_yy_scan_bytes_ALREADY_DEFINED#else#define yy_scan_bytes regex_yy_scan_bytes#endif
#ifdef yy_init_buffer#define regex_yy_init_buffer_ALREADY_DEFINED#else#define yy_init_buffer regex_yy_init_buffer#endif
#ifdef yy_flush_buffer#define regex_yy_flush_buffer_ALREADY_DEFINED#else#define yy_flush_buffer regex_yy_flush_buffer#endif
#ifdef yy_load_buffer_state#define regex_yy_load_buffer_state_ALREADY_DEFINED#else#define yy_load_buffer_state regex_yy_load_buffer_state#endif
#ifdef yy_switch_to_buffer#define regex_yy_switch_to_buffer_ALREADY_DEFINED#else#define yy_switch_to_buffer regex_yy_switch_to_buffer#endif
#ifdef yypush_buffer_state#define regex_yypush_buffer_state_ALREADY_DEFINED#else#define yypush_buffer_state regex_yypush_buffer_state#endif
#ifdef yypop_buffer_state#define regex_yypop_buffer_state_ALREADY_DEFINED#else#define yypop_buffer_state regex_yypop_buffer_state#endif
#ifdef yyensure_buffer_stack#define regex_yyensure_buffer_stack_ALREADY_DEFINED#else#define yyensure_buffer_stack regex_yyensure_buffer_stack#endif
#ifdef yylex#define regex_yylex_ALREADY_DEFINED#else#define yylex regex_yylex#endif
#ifdef yyrestart#define regex_yyrestart_ALREADY_DEFINED#else#define yyrestart regex_yyrestart#endif
#ifdef yylex_init#define regex_yylex_init_ALREADY_DEFINED#else#define yylex_init regex_yylex_init#endif
#ifdef yylex_init_extra#define regex_yylex_init_extra_ALREADY_DEFINED#else#define yylex_init_extra regex_yylex_init_extra#endif
#ifdef yylex_destroy#define regex_yylex_destroy_ALREADY_DEFINED#else#define yylex_destroy regex_yylex_destroy#endif
#ifdef yyget_debug#define regex_yyget_debug_ALREADY_DEFINED#else#define yyget_debug regex_yyget_debug#endif
#ifdef yyset_debug#define regex_yyset_debug_ALREADY_DEFINED#else#define yyset_debug regex_yyset_debug#endif
#ifdef yyget_extra#define regex_yyget_extra_ALREADY_DEFINED#else#define yyget_extra regex_yyget_extra#endif
#ifdef yyset_extra#define regex_yyset_extra_ALREADY_DEFINED#else#define yyset_extra regex_yyset_extra#endif
#ifdef yyget_in#define regex_yyget_in_ALREADY_DEFINED#else#define yyget_in regex_yyget_in#endif
#ifdef yyset_in#define regex_yyset_in_ALREADY_DEFINED#else#define yyset_in regex_yyset_in#endif
#ifdef yyget_out#define regex_yyget_out_ALREADY_DEFINED#else#define yyget_out regex_yyget_out#endif
#ifdef yyset_out#define regex_yyset_out_ALREADY_DEFINED#else#define yyset_out regex_yyset_out#endif
#ifdef yyget_leng#define regex_yyget_leng_ALREADY_DEFINED#else#define yyget_leng regex_yyget_leng#endif
#ifdef yyget_text#define regex_yyget_text_ALREADY_DEFINED#else#define yyget_text regex_yyget_text#endif
#ifdef yyget_lineno#define regex_yyget_lineno_ALREADY_DEFINED#else#define yyget_lineno regex_yyget_lineno#endif
#ifdef yyset_lineno#define regex_yyset_lineno_ALREADY_DEFINED#else#define yyset_lineno regex_yyset_lineno#endif
#ifdef yywrap#define regex_yywrap_ALREADY_DEFINED#else#define yywrap regex_yywrap#endif
#ifdef yyalloc#define regex_yyalloc_ALREADY_DEFINED#else#define yyalloc regex_yyalloc#endif
#ifdef yyrealloc#define regex_yyrealloc_ALREADY_DEFINED#else#define yyrealloc regex_yyrealloc#endif
#ifdef yyfree#define regex_yyfree_ALREADY_DEFINED#else#define yyfree regex_yyfree#endif
#ifdef yytext#define regex_yytext_ALREADY_DEFINED#else#define yytext regex_yytext#endif
#ifdef yyleng#define regex_yyleng_ALREADY_DEFINED#else#define yyleng regex_yyleng#endif
#ifdef yyin#define regex_yyin_ALREADY_DEFINED#else#define yyin regex_yyin#endif
#ifdef yyout#define regex_yyout_ALREADY_DEFINED#else#define yyout regex_yyout#endif
#ifdef yy_flex_debug#define regex_yy_flex_debug_ALREADY_DEFINED#else#define yy_flex_debug regex_yy_flex_debug#endif
#ifdef yylineno#define regex_yylineno_ALREADY_DEFINED#else#define yylineno regex_yylineno#endif
/* First, we deal with platform-specific or compiler-specific issues. */
/* begin standard C headers. */#include <stdio.h>#include <string.h>#include <errno.h>#include <stdlib.h>
/* end standard C headers. */
/* flex integer type definitions */
#ifndef FLEXINT_H#define FLEXINT_H
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, * if you want the limit (max/min) macros for int types. */#ifndef __STDC_LIMIT_MACROS#define __STDC_LIMIT_MACROS 1#endif
#include <inttypes.h>typedef int8_t flex_int8_t;typedef uint8_t flex_uint8_t;typedef int16_t flex_int16_t;typedef uint16_t flex_uint16_t;typedef int32_t flex_int32_t;typedef uint32_t flex_uint32_t;#elsetypedef signed char flex_int8_t;typedef short int flex_int16_t;typedef int flex_int32_t;typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t;typedef unsigned int flex_uint32_t;
/* Limits of integral types. */#ifndef INT8_MIN#define INT8_MIN (-128)#endif#ifndef INT16_MIN#define INT16_MIN (-32767-1)#endif#ifndef INT32_MIN#define INT32_MIN (-2147483647-1)#endif#ifndef INT8_MAX#define INT8_MAX (127)#endif#ifndef INT16_MAX#define INT16_MAX (32767)#endif#ifndef INT32_MAX#define INT32_MAX (2147483647)#endif#ifndef UINT8_MAX#define UINT8_MAX (255U)#endif#ifndef UINT16_MAX#define UINT16_MAX (65535U)#endif#ifndef UINT32_MAX#define UINT32_MAX (4294967295U)#endif
#ifndef SIZE_MAX#define SIZE_MAX (~(size_t)0)#endif
#endif /* ! C99 */
#endif /* ! FLEXINT_H */
/* begin standard C++ headers. */
/* TODO: this is always defined, so inline it */#define yyconst const
#if defined(__GNUC__) && __GNUC__ >= 3#define yynoreturn __attribute__((__noreturn__))#else#define yynoreturn#endif
/* Returned upon end-of-file. */#define YY_NULL 0
/* Promotes a possibly negative, possibly signed char to an * integer in range [0..255] for use as an array index. */#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
/* Enter a start condition. This macro really ought to take a parameter, * but we do it the disgusting crufty way forced on us by the ()-less * definition of BEGIN. */#define BEGIN (yy_start) = 1 + 2 */* Translate the current start state into a value that can be later handed * to BEGIN to return to the state. The YYSTATE alias is for lex * compatibility. */#define YY_START (((yy_start) - 1) / 2)#define YYSTATE YY_START/* Action number for EOF rule of a given start state. */#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)/* Special action meaning "start processing a new file". */#define YY_NEW_FILE yyrestart( yyin )#define YY_END_OF_BUFFER_CHAR 0
/* Size of default input buffer. */#ifndef YY_BUF_SIZE#ifdef __ia64__/* On IA-64, the buffer size is 16k, not 8k. * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. * Ditto for the __ia64__ case accordingly. */#define YY_BUF_SIZE 32768#else#define YY_BUF_SIZE 16384#endif /* __ia64__ */#endif
/* The state buf must be large enough to hold one state per character in the main buffer. */#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
#ifndef YY_TYPEDEF_YY_BUFFER_STATE#define YY_TYPEDEF_YY_BUFFER_STATEtypedef struct yy_buffer_state *YY_BUFFER_STATE;#endif
#ifndef YY_TYPEDEF_YY_SIZE_T#define YY_TYPEDEF_YY_SIZE_Ttypedef size_t yy_size_t;#endif
extern int yyleng;
extern FILE *yyin, *yyout;
#define EOB_ACT_CONTINUE_SCAN 0#define EOB_ACT_END_OF_FILE 1#define EOB_ACT_LAST_MATCH 2 #define YY_LESS_LINENO(n) #define YY_LINENO_REWIND_TO(ptr) /* Return all but the first "n" matched characters back to the input stream. */#define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ *yy_cp = (yy_hold_char); \ YY_RESTORE_YY_MORE_OFFSET \ (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ YY_DO_BEFORE_ACTION; /* set up yytext again */ \ } \ while ( 0 )#define unput(c) yyunput( c, (yytext_ptr) )
#ifndef YY_STRUCT_YY_BUFFER_STATE#define YY_STRUCT_YY_BUFFER_STATEstruct yy_buffer_state { FILE *yy_input_file;
char *yy_ch_buf; /* input buffer */ char *yy_buf_pos; /* current position in input buffer */
/* Size of input buffer in bytes, not including room for EOB * characters. */ int yy_buf_size;
/* Number of characters read into yy_ch_buf, not including EOB * characters. */ int yy_n_chars;
/* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to * delete it. */ int yy_is_our_buffer;
/* Whether this is an "interactive" input source; if so, and * if we're using stdio for input, then we want to use getc() * instead of fread(), to make sure we stop fetching input after * each newline. */ int yy_is_interactive;
/* Whether we're considered to be at the beginning of a line. * If so, '^' rules will be active on the next match, otherwise * not. */ int yy_at_bol;
int yy_bs_lineno; /**< The line count. */ int yy_bs_column; /**< The column count. */
/* Whether to try to fill the input buffer when we reach the * end of it. */ int yy_fill_buffer;
int yy_buffer_status;
#define YY_BUFFER_NEW 0#define YY_BUFFER_NORMAL 1 /* When an EOF's been seen but there's still some text to process * then we mark the buffer as YY_EOF_PENDING, to indicate that we * shouldn't try reading from the input source any more. We might * still have a bunch of tokens to match, though, because of * possible backing-up. * * When we actually see the EOF, we change the status to "new" * (via yyrestart()), so that the user can continue scanning by * just pointing yyin at a new input file. */#define YY_BUFFER_EOF_PENDING 2
};#endif /* !YY_STRUCT_YY_BUFFER_STATE */
/* Stack of input buffers. */static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
/* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general * "scanner state". * * Returns the top of the stack, or NULL. */#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ : NULL)/* Same as previous macro, but useful when we know that the buffer stack is not * NULL or when we need an lvalue. For internal use only. */#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
/* yy_hold_char holds the character lost when yytext is formed. */static char yy_hold_char;static int yy_n_chars; /* number of characters read into yy_ch_buf */int yyleng;
/* Points to current character in buffer. */static char *yy_c_buf_p = NULL;static int yy_init = 0; /* whether we need to initialize */static int yy_start = 0; /* start state number */
/* Flag which is used to allow yywrap()'s to do buffer switches * instead of setting up a fresh yyin. A bit of a hack ... */static int yy_did_buffer_switch_on_eof;
void yyrestart ( FILE *input_file );void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );void yy_delete_buffer ( YY_BUFFER_STATE b );void yy_flush_buffer ( YY_BUFFER_STATE b );void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );void yypop_buffer_state ( void );
static void yyensure_buffer_stack ( void );static void yy_load_buffer_state ( void );static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );YY_BUFFER_STATE yy_scan_string ( const char *yy_str );YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
void *yyalloc ( yy_size_t );void *yyrealloc ( void *, yy_size_t );void yyfree ( void * );
#define yy_new_buffer yy_create_buffer#define yy_set_interactive(is_interactive) \ { \ if ( ! YY_CURRENT_BUFFER ){ \ yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ }#define yy_set_bol(at_bol) \ { \ if ( ! YY_CURRENT_BUFFER ){\ yyensure_buffer_stack (); \ YY_CURRENT_BUFFER_LVALUE = \ yy_create_buffer( yyin, YY_BUF_SIZE ); \ } \ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ }#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
/* Begin user sect3 */
#define regex_yywrap() (/*CONSTCOND*/1)#define YY_SKIP_YYWRAPtypedef flex_uint8_t YY_CHAR;
FILE *yyin = NULL, *yyout = NULL;
typedef int yy_state_type;
extern int yylineno;int yylineno = 1;
extern char *yytext;#ifdef yytext_ptr#undef yytext_ptr#endif#define yytext_ptr yytext
static yy_state_type yy_get_previous_state ( void );static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );static int yy_get_next_buffer ( void );static void yynoreturn yy_fatal_error ( const char* msg );
/* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. */#define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ yyleng = (int) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp;#define YY_NUM_RULES 20#define YY_END_OF_BUFFER 21/* This struct is not used in this scanner, but its presence is necessary. */struct yy_trans_info { flex_int32_t yy_verify; flex_int32_t yy_nxt; };static const flex_int16_t yy_accept[29] = { 0, 0, 0, 21, 19, 1, 1, 19, 6, 7, 5, 4, 11, 15, 12, 2, 8, 17, 13, 14, 16, 9, 3, 10, 0, 18, 2, 17, 0 } ;
static const YY_CHAR yy_ec[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 5, 6, 7, 8, 9, 10, 11, 12, 1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 1, 1, 1, 1, 1, 14, 1, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 4, 17, 18, 19, 1, 15, 15, 15, 15,
15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 20, 21, 22, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } ;
static const YY_CHAR yy_meta[23] = { 0, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } ;
static const flex_int16_t yy_base[30] = { 0, 0, 0, 34, 35, 35, 35, 28, 35, 35, 35, 35, 35, 35, 35, 19, 35, 10, 35, 35, 35, 35, 35, 35, 26, 35, 15, 11, 35, 26 } ;
static const flex_int16_t yy_def[30] = { 0, 28, 1, 28, 28, 28, 28, 29, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 29, 28, 28, 28, 0, 28 } ;
static const flex_int16_t yy_nxt[58] = { 0, 4, 5, 6, 4, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 4, 21, 22, 23, 27, 27, 27, 27, 24, 26, 27, 27, 25, 26, 25, 28, 3, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28 } ;
static const flex_int16_t yy_chk[58] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 17, 27, 17, 27, 29, 26, 17, 27, 24, 15, 7, 3, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28 } ;
static yy_state_type yy_last_accepting_state;static char *yy_last_accepting_cpos;
extern int yy_flex_debug;int yy_flex_debug = 0;
/* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. */#define REJECT reject_used_but_not_detected#define yymore() yymore_used_but_not_detected#define YY_MORE_ADJ 0#define YY_RESTORE_YY_MORE_OFFSETchar *yytext;/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- *//* * Main authors: * Jip J. Dekker <jip.dekker@monash.edu> *//* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */#include <cstdlib>
#define YY_DECL int yylex()
#include <minizinc/support/regex.hh>
#define INITIAL 0
#ifndef YY_NO_UNISTD_H/* Special case for "unistd.h", since it is non-ANSI. We include it way * down here because we want the user's section 1 to have been scanned first. * The user has a chance to override it with an option. */#include <unistd.h>#endif
#ifndef YY_EXTRA_TYPE#define YY_EXTRA_TYPE void *#endif
static int yy_init_globals ( void );
/* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */
int yylex_destroy ( void );
int yyget_debug ( void );
void yyset_debug ( int debug_flag );
YY_EXTRA_TYPE yyget_extra ( void );
void yyset_extra ( YY_EXTRA_TYPE user_defined );
FILE *yyget_in ( void );
void yyset_in ( FILE * _in_str );
FILE *yyget_out ( void );
void yyset_out ( FILE * _out_str );
int yyget_leng ( void );
char *yyget_text ( void );
int yyget_lineno ( void );
void yyset_lineno ( int _line_number );
/* Macros after this point can all be overridden by user definitions in * section 1. */
#ifndef YY_SKIP_YYWRAP#ifdef __cplusplusextern "C" int yywrap ( void );#elseextern int yywrap ( void );#endif#endif
#ifndef YY_NO_UNPUT static void yyunput ( int c, char *buf_ptr ); #endif
#ifndef yytext_ptrstatic void yy_flex_strncpy ( char *, const char *, int );#endif
#ifdef YY_NEED_STRLENstatic int yy_flex_strlen ( const char * );#endif
#ifndef YY_NO_INPUT#ifdef __cplusplusstatic int yyinput ( void );#elsestatic int input ( void );#endif
#endif
/* Amount of stuff to slurp up with each read. */#ifndef YY_READ_BUF_SIZE#ifdef __ia64__/* On IA-64, the buffer size is 16k, not 8k */#define YY_READ_BUF_SIZE 16384#else#define YY_READ_BUF_SIZE 8192#endif /* __ia64__ */#endif
/* Copy whatever the last rule matched to the standard output. */#ifndef ECHO/* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)#endif
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, * is returned in "result". */#ifndef YY_INPUT#define YY_INPUT(buf,result,max_size) \ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ int n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ if ( c == '\n' ) \ buf[n++] = (char) c; \ if ( c == EOF && ferror( yyin ) ) \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ result = n; \ } \ else \ { \ errno=0; \ while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ { \ if( errno != EINTR) \ { \ YY_FATAL_ERROR( "input in flex scanner failed" ); \ break; \ } \ errno=0; \ clearerr(yyin); \ } \ }\\
#endif
/* No semi-colon after return; correct usage is to write "yyterminate();" - * we don't want an extra ';' after the "return" because that will cause * some compilers to complain about unreachable statements. */#ifndef yyterminate#define yyterminate() return YY_NULL#endif
/* Number of entries by which start-condition stack grows. */#ifndef YY_START_STACK_INCR#define YY_START_STACK_INCR 25#endif
/* Report a fatal error. */#ifndef YY_FATAL_ERROR#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )#endif
/* end tables serialization structures and prototypes */
/* Default declaration of generated scanner - a define so the user can * easily add parameters. */#ifndef YY_DECL#define YY_DECL_IS_OURS 1
extern int yylex (void);
#define YY_DECL int yylex (void)#endif /* !YY_DECL */
/* Code executed at the beginning of each rule, after yytext and yyleng * have been set up. */#ifndef YY_USER_ACTION#define YY_USER_ACTION#endif
/* Code executed at the end of each rule. */#ifndef YY_BREAK#define YY_BREAK /*LINTED*/break;#endif
#define YY_RULE_SETUP \ YY_USER_ACTION
/** The main scanner function which does all the work. */YY_DECL{ yy_state_type yy_current_state; char *yy_cp, *yy_bp; int yy_act; if ( !(yy_init) ) { (yy_init) = 1;
#ifdef YY_USER_INIT YY_USER_INIT;#endif
if ( ! (yy_start) ) (yy_start) = 1; /* first start state */
if ( ! yyin ) yyin = stdin;
if ( ! yyout ) yyout = stdout;
if ( ! YY_CURRENT_BUFFER ) { yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = yy_create_buffer( yyin, YY_BUF_SIZE ); }
yy_load_buffer_state( ); }
{
while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { yy_cp = (yy_c_buf_p);
/* Support of yytext. */ *yy_cp = (yy_hold_char);
/* yy_bp points to the position in yy_ch_buf of the start of * the current run. */ yy_bp = yy_cp;
yy_current_state = (yy_start);yy_match: do { YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; (yy_last_accepting_cpos) = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 29 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; ++yy_cp; } while ( yy_base[yy_current_state] != 35 );
yy_find_action: yy_act = yy_accept[yy_current_state]; if ( yy_act == 0 ) { /* have to back up */ yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); yy_act = yy_accept[yy_current_state]; }
YY_DO_BEFORE_ACTION;
do_action: /* This label is used only to access EOF actions. */
switch ( yy_act ) { /* beginning of action switch */ case 0: /* must back up */ /* undo the effects of YY_DO_BEFORE_ACTION */ *yy_cp = (yy_hold_char); yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); goto yy_find_action;
case 1:/* rule 1 can match eol */YY_RULE_SETUP{ /* ignore white space */ } YY_BREAKcase 2:YY_RULE_SETUP{ regex_yylval.iValue = std::atoi(regex_yytext); return R_INTEGER; } YY_BREAKcase 3:YY_RULE_SETUP{ return R_UNION; } YY_BREAKcase 4:YY_RULE_SETUP{ return R_PLUS; } YY_BREAKcase 5:YY_RULE_SETUP{ return R_STAR; } YY_BREAKcase 6:YY_RULE_SETUP{ return R_GROUP_OPEN; } YY_BREAKcase 7:YY_RULE_SETUP{ return R_GROUP_CLOSE; } YY_BREAKcase 8:YY_RULE_SETUP{ return R_OPTIONAL; } YY_BREAKcase 9:YY_RULE_SETUP{ return R_QUANT_OPEN; } YY_BREAKcase 10:YY_RULE_SETUP{ return R_QUANT_CLOSE; } YY_BREAKcase 11:YY_RULE_SETUP{ return R_COMMA; } YY_BREAKcase 12:YY_RULE_SETUP{ return R_ANY; } YY_BREAKcase 13:YY_RULE_SETUP{ return R_CLASS_OPEN; } YY_BREAKcase 14:YY_RULE_SETUP{ return R_CLASS_CLOSE; } YY_BREAKcase 15:YY_RULE_SETUP{ return R_CLASS_RANGE; } YY_BREAKcase 16:YY_RULE_SETUP{ return R_CLASS_NEG; } YY_BREAKcase 17:YY_RULE_SETUP{ regex_yylval.sValue = strdup(yytext); return R_IDENTIFIER; } YY_BREAKcase 18:YY_RULE_SETUP{ regex_yylval.sValue = strdup(yytext); return R_IDENTIFIER; } YY_BREAKcase 19:YY_RULE_SETUP{ /* Catch all */ throw std::runtime_error("Illegal token in regular expression: '" + std::string(regex_yytext) + "'");} YY_BREAKcase 20:YY_RULE_SETUPECHO; YY_BREAKcase YY_STATE_EOF(INITIAL): yyterminate();
case YY_END_OF_BUFFER: { /* Amount of text matched not including the EOB char. */ int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
/* Undo the effects of YY_DO_BEFORE_ACTION. */ *yy_cp = (yy_hold_char); YY_RESTORE_YY_MORE_OFFSET
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) { /* We're scanning a new file or input source. It's * possible that this happened because the user * just pointed yyin at a new source and called * yylex(). If so, then we have to assure * consistency between YY_CURRENT_BUFFER and our * globals. Here is the right place to do so, because * this is the first action (other than possibly a * back-up) that will match for the new input source. */ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; }
/* Note that here we test for yy_c_buf_p "<=" to the position * of the first EOB in the buffer, since yy_c_buf_p will * already have been incremented past the NUL character * (since all states make transitions on EOB to the * end-of-buffer state). Contrast this with the test * in input(). */ if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) { /* This was really a NUL. */ yy_state_type yy_next_state;
(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
yy_current_state = yy_get_previous_state( );
/* Okay, we're now positioned to make the NUL * transition. We couldn't have * yy_get_previous_state() go ahead and do it * for us because it doesn't know how to deal * with the possibility of jamming (and we don't * want to build jamming into it because then it * will run more slowly). */
yy_next_state = yy_try_NUL_trans( yy_current_state );
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
if ( yy_next_state ) { /* Consume the NUL. */ yy_cp = ++(yy_c_buf_p); yy_current_state = yy_next_state; goto yy_match; }
else { yy_cp = (yy_c_buf_p); goto yy_find_action; } }
else switch ( yy_get_next_buffer( ) ) { case EOB_ACT_END_OF_FILE: { (yy_did_buffer_switch_on_eof) = 0;
if ( yywrap( ) ) { /* Note: because we've taken care in * yy_get_next_buffer() to have set up * yytext, we can now set up * yy_c_buf_p so that if some total * hoser (like flex itself) wants to * call the scanner after we return the * YY_NULL, it'll still work - another * YY_NULL will get returned. */ (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
yy_act = YY_STATE_EOF(YY_START); goto do_action; }
else { if ( ! (yy_did_buffer_switch_on_eof) ) YY_NEW_FILE; } break; }
case EOB_ACT_CONTINUE_SCAN: (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
yy_current_state = yy_get_previous_state( );
yy_cp = (yy_c_buf_p); yy_bp = (yytext_ptr) + YY_MORE_ADJ; goto yy_match;
case EOB_ACT_LAST_MATCH: (yy_c_buf_p) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
yy_current_state = yy_get_previous_state( );
yy_cp = (yy_c_buf_p); yy_bp = (yytext_ptr) + YY_MORE_ADJ; goto yy_find_action; } break; }
default: YY_FATAL_ERROR( "fatal flex scanner internal error--no action found" ); } /* end of action switch */ } /* end of scanning one token */ } /* end of user's declarations */} /* end of yylex */
/* yy_get_next_buffer - try to read in a new buffer * * Returns a code representing an action: * EOB_ACT_LAST_MATCH - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position * EOB_ACT_END_OF_FILE - end of file */static int yy_get_next_buffer (void){ char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; char *source = (yytext_ptr); int number_to_move, i; int ret_val;
if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) YY_FATAL_ERROR( "fatal flex scanner internal error--end of buffer missed" );
if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) { /* Don't try to fill the buffer, so this is an EOF. */ if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) { /* We matched a single character, the EOB, so * treat this as a final EOF. */ return EOB_ACT_END_OF_FILE; }
else { /* We matched some text prior to the EOB, first * process it. */ return EOB_ACT_LAST_MATCH; } }
/* Try to read more data. */
/* First move last chars to start of buffer. */ number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
for ( i = 0; i < number_to_move; ++i ) *(dest++) = *(source++);
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) /* don't do the read, it's not guaranteed to return an EOF, * just force an EOF */ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
else { int num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
while ( num_to_read <= 0 ) { /* Not enough room in the buffer - grow it. */
/* just a shorter name for the current buffer */ YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
int yy_c_buf_p_offset = (int) ((yy_c_buf_p) - b->yy_ch_buf);
if ( b->yy_is_our_buffer ) { int new_size = b->yy_buf_size * 2;
if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; else b->yy_buf_size *= 2;
b->yy_ch_buf = (char *) /* Include room in for 2 EOB chars. */ yyrealloc( (void *) b->yy_ch_buf, (yy_size_t) (b->yy_buf_size + 2) ); } else /* Can't grow it, we don't own it. */ b->yy_ch_buf = NULL;
if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "fatal error - scanner input buffer overflow" );
(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
}
if ( num_to_read > YY_READ_BUF_SIZE ) num_to_read = YY_READ_BUF_SIZE;
/* Read in more data. */ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), (yy_n_chars), num_to_read );
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); }
if ( (yy_n_chars) == 0 ) { if ( number_to_move == YY_MORE_ADJ ) { ret_val = EOB_ACT_END_OF_FILE; yyrestart( yyin ); }
else { ret_val = EOB_ACT_LAST_MATCH; YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_EOF_PENDING; } }
else ret_val = EOB_ACT_CONTINUE_SCAN;
if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); /* "- 2" to take care of EOB's */ YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); }
(yy_n_chars) += number_to_move; YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
return ret_val;}
/* yy_get_previous_state - get the state just before the EOB char was reached */
static yy_state_type yy_get_previous_state (void){ yy_state_type yy_current_state; char *yy_cp; yy_current_state = (yy_start);
for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) { YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 4); if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; (yy_last_accepting_cpos) = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 29 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; }
return yy_current_state;}
/* yy_try_NUL_trans - try to make a transition on the NUL character * * synopsis * next_state = yy_try_NUL_trans( current_state ); */ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ){ int yy_is_jam; char *yy_cp = (yy_c_buf_p);
YY_CHAR yy_c = 4; if ( yy_accept[yy_current_state] ) { (yy_last_accepting_state) = yy_current_state; (yy_last_accepting_cpos) = yy_cp; } while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; if ( yy_current_state >= 29 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; yy_is_jam = (yy_current_state == 28);
return yy_is_jam ? 0 : yy_current_state;}
#ifndef YY_NO_UNPUT
static void yyunput (int c, char * yy_bp ){ char *yy_cp; yy_cp = (yy_c_buf_p);
/* undo effects of setting up yytext */ *yy_cp = (yy_hold_char);
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) { /* need to shift things up to make room */ /* +2 for EOB chars. */ int number_to_move = (yy_n_chars) + 2; char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[ YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; char *source = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) *--dest = *--source;
yy_cp += (int) (dest - source); yy_bp += (int) (dest - source); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 ) YY_FATAL_ERROR( "flex scanner push-back overflow" ); }
*--yy_cp = (char) c;
(yytext_ptr) = yy_bp; (yy_hold_char) = *yy_cp; (yy_c_buf_p) = yy_cp;}
#endif
#ifndef YY_NO_INPUT#ifdef __cplusplus static int yyinput (void)#else static int input (void)#endif
{ int c; *(yy_c_buf_p) = (yy_hold_char);
if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) { /* yy_c_buf_p now points to the character we want to return. * If this occurs *before* the EOB characters, then it's a * valid NUL; if not, then we've hit the end of the buffer. */ if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) /* This was really a NUL. */ *(yy_c_buf_p) = '\0';
else { /* need more input */ int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); ++(yy_c_buf_p);
switch ( yy_get_next_buffer( ) ) { case EOB_ACT_LAST_MATCH: /* This happens because yy_g_n_b() * sees that we've accumulated a * token and flags that we need to * try matching the token before * proceeding. But for input(), * there's no matching to consider. * So convert the EOB_ACT_LAST_MATCH * to EOB_ACT_END_OF_FILE. */
/* Reset buffer status. */ yyrestart( yyin );
/*FALLTHROUGH*/
case EOB_ACT_END_OF_FILE: { if ( yywrap( ) ) return 0;
if ( ! (yy_did_buffer_switch_on_eof) ) YY_NEW_FILE;#ifdef __cplusplus return yyinput();#else return input();#endif }
case EOB_ACT_CONTINUE_SCAN: (yy_c_buf_p) = (yytext_ptr) + offset; break; } } }
c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ *(yy_c_buf_p) = '\0'; /* preserve yytext */ (yy_hold_char) = *++(yy_c_buf_p);
return c;}#endif /* ifndef YY_NO_INPUT */
/** Immediately switch to a different input stream. * @param input_file A readable stream. * * @note This function does not reset the start condition to @c INITIAL . */ void yyrestart (FILE * input_file ){ if ( ! YY_CURRENT_BUFFER ){ yyensure_buffer_stack (); YY_CURRENT_BUFFER_LVALUE = yy_create_buffer( yyin, YY_BUF_SIZE ); }
yy_init_buffer( YY_CURRENT_BUFFER, input_file ); yy_load_buffer_state( );}
/** Switch to a different input buffer. * @param new_buffer The new input buffer. * */ void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ){ /* TODO. We should be able to replace this entire function body * with * yypop_buffer_state(); * yypush_buffer_state(new_buffer); */ yyensure_buffer_stack (); if ( YY_CURRENT_BUFFER == new_buffer ) return;
if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ *(yy_c_buf_p) = (yy_hold_char); YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); }
YY_CURRENT_BUFFER_LVALUE = new_buffer; yy_load_buffer_state( );
/* We don't actually know whether we did this switch during * EOF (yywrap()) processing, but the only time this flag * is looked at is after yywrap() is called, so it's safe * to go ahead and always set it. */ (yy_did_buffer_switch_on_eof) = 1;}
static void yy_load_buffer_state (void){ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; (yy_hold_char) = *(yy_c_buf_p);}
/** Allocate and initialize an input buffer state. * @param file A readable stream. * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. * * @return the allocated buffer state. */ YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ){ YY_BUFFER_STATE b; b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_buf_size = size;
/* yy_ch_buf has to be 2 characters longer than the size given because * we need to put in 2 end-of-buffer characters. */ b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); if ( ! b->yy_ch_buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_is_our_buffer = 1;
yy_init_buffer( b, file );
return b;}
/** Destroy the buffer. * @param b a buffer created with yy_create_buffer() * */ void yy_delete_buffer (YY_BUFFER_STATE b ){ if ( ! b ) return;
if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer ) yyfree( (void *) b->yy_ch_buf );
yyfree( (void *) b );}
/* Initializes or reinitializes a buffer. * This function is sometimes called more than once on the same buffer, * such as during a yyrestart() or at EOF. */ static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
{ int oerrno = errno; yy_flush_buffer( b );
b->yy_input_file = file; b->yy_fill_buffer = 1;
/* If b is the current buffer, then yy_init_buffer was _probably_ * called from yyrestart() or through yy_get_next_buffer. * In that case, we don't want to reset the lineno or column. */ if (b != YY_CURRENT_BUFFER){ b->yy_bs_lineno = 1; b->yy_bs_column = 0; }
b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; errno = oerrno;}
/** Discard all buffered characters. On the next scan, YY_INPUT will be called. * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. * */ void yy_flush_buffer (YY_BUFFER_STATE b ){ if ( ! b ) return;
b->yy_n_chars = 0;
/* We always need two end-of-buffer characters. The first causes * a transition to the end-of-buffer state. The second causes * a jam in that state. */ b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
b->yy_buf_pos = &b->yy_ch_buf[0];
b->yy_at_bol = 1; b->yy_buffer_status = YY_BUFFER_NEW;
if ( b == YY_CURRENT_BUFFER ) yy_load_buffer_state( );}
/** Pushes the new state onto the stack. The new state becomes * the current state. This function will allocate the stack * if necessary. * @param new_buffer The new state. * */void yypush_buffer_state (YY_BUFFER_STATE new_buffer ){ if (new_buffer == NULL) return;
yyensure_buffer_stack();
/* This block is copied from yy_switch_to_buffer. */ if ( YY_CURRENT_BUFFER ) { /* Flush out information for old buffer. */ *(yy_c_buf_p) = (yy_hold_char); YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); }
/* Only push if top exists. Otherwise, replace top. */ if (YY_CURRENT_BUFFER) (yy_buffer_stack_top)++; YY_CURRENT_BUFFER_LVALUE = new_buffer;
/* copied from yy_switch_to_buffer. */ yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1;}
/** Removes and deletes the top of the stack, if present. * The next element becomes the new top. * */void yypop_buffer_state (void){ if (!YY_CURRENT_BUFFER) return;
yy_delete_buffer(YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; if ((yy_buffer_stack_top) > 0) --(yy_buffer_stack_top);
if (YY_CURRENT_BUFFER) { yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; }}
/* Allocates the stack if it does not exist. * Guarantees space for at least one push. */static void yyensure_buffer_stack (void){ yy_size_t num_to_alloc; if (!(yy_buffer_stack)) {
/* First allocation is just for 2 elements, since we don't know if this * scanner will even need a stack. We use 2 instead of 1 to avoid an * immediate realloc on the next call. */ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc (num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
(yy_buffer_stack_max) = num_to_alloc; (yy_buffer_stack_top) = 0; return; }
if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
/* Increase the buffer to prepare for a possible push. */ yy_size_t grow_size = 8 /* arbitrary grow size */;
num_to_alloc = (yy_buffer_stack_max) + grow_size; (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc ((yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state*) ); if ( ! (yy_buffer_stack) ) YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
/* zero only the new slots.*/ memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); (yy_buffer_stack_max) = num_to_alloc; }}
/** Setup the input buffer state to scan directly from a user-specified character buffer. * @param base the character buffer * @param size the size in bytes of the character buffer * * @return the newly allocated buffer state object. */YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ){ YY_BUFFER_STATE b; if ( size < 2 || base[size-2] != YY_END_OF_BUFFER_CHAR || base[size-1] != YY_END_OF_BUFFER_CHAR ) /* They forgot to leave room for the EOB's. */ return NULL;
b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); if ( ! b ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ b->yy_buf_pos = b->yy_ch_buf = base; b->yy_is_our_buffer = 0; b->yy_input_file = NULL; b->yy_n_chars = b->yy_buf_size; b->yy_is_interactive = 0; b->yy_at_bol = 1; b->yy_fill_buffer = 0; b->yy_buffer_status = YY_BUFFER_NEW;
yy_switch_to_buffer( b );
return b;}
/** Setup the input buffer state to scan a string. The next call to yylex() will * scan from a @e copy of @a str. * @param yystr a NUL-terminated string to scan * * @return the newly allocated buffer state object. * @note If you want to scan bytes that may contain NUL values, then use * yy_scan_bytes() instead. */YY_BUFFER_STATE yy_scan_string (const char * yystr ){ return yy_scan_bytes( yystr, (int) strlen(yystr) );}
/** Setup the input buffer state to scan the given bytes. The next call to yylex() will * scan from a @e copy of @a bytes. * @param yybytes the byte buffer to scan * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. * * @return the newly allocated buffer state object. */YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ){ YY_BUFFER_STATE b; char *buf; yy_size_t n; int i; /* Get memory for full buffer, including space for trailing EOB's. */ n = (yy_size_t) (_yybytes_len + 2); buf = (char *) yyalloc( n ); if ( ! buf ) YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
for ( i = 0; i < _yybytes_len; ++i ) buf[i] = yybytes[i];
buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
b = yy_scan_buffer( buf, n ); if ( ! b ) YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
/* It's okay to grow etc. this buffer, and we should throw it * away when we're done. */ b->yy_is_our_buffer = 1;
return b;}
#ifndef YY_EXIT_FAILURE#define YY_EXIT_FAILURE 2#endif
static void yynoreturn yy_fatal_error (const char* msg ){ fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE );}
/* Redefine yyless() so it works in section 3 code. */
#undef yyless#define yyless(n) \ do \ { \ /* Undo effects of setting up yytext. */ \ int yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ yytext[yyleng] = (yy_hold_char); \ (yy_c_buf_p) = yytext + yyless_macro_arg; \ (yy_hold_char) = *(yy_c_buf_p); \ *(yy_c_buf_p) = '\0'; \ yyleng = yyless_macro_arg; \ } \ while ( 0 )
/* Accessor methods (get/set functions) to struct members. */
/** Get the current line number. * */int yyget_lineno (void){ return yylineno;}
/** Get the input stream. * */FILE *yyget_in (void){ return yyin;}
/** Get the output stream. * */FILE *yyget_out (void){ return yyout;}
/** Get the length of the current token. * */int yyget_leng (void){ return yyleng;}
/** Get the current token. * */
char *yyget_text (void){ return yytext;}
/** Set the current line number. * @param _line_number line number * */void yyset_lineno (int _line_number ){ yylineno = _line_number;}
/** Set the input stream. This does not discard the current * input buffer. * @param _in_str A readable stream. * * @see yy_switch_to_buffer */void yyset_in (FILE * _in_str ){ yyin = _in_str ;}
void yyset_out (FILE * _out_str ){ yyout = _out_str ;}
int yyget_debug (void){ return yy_flex_debug;}
void yyset_debug (int _bdebug ){ yy_flex_debug = _bdebug ;}
static int yy_init_globals (void){ /* Initialization is the same as for the non-reentrant scanner. * This function is called from yylex_destroy(), so don't allocate here. */
(yy_buffer_stack) = NULL; (yy_buffer_stack_top) = 0; (yy_buffer_stack_max) = 0; (yy_c_buf_p) = NULL; (yy_init) = 0; (yy_start) = 0;
/* Defined in main.c */#ifdef YY_STDINIT yyin = stdin; yyout = stdout;#else yyin = NULL; yyout = NULL;#endif
/* For future reference: Set errno on error, since we are called by * yylex_init() */ return 0;}
/* yylex_destroy is for both reentrant and non-reentrant scanners. */int yylex_destroy (void){ /* Pop the buffer stack, destroying each element. */ while(YY_CURRENT_BUFFER){ yy_delete_buffer( YY_CURRENT_BUFFER ); YY_CURRENT_BUFFER_LVALUE = NULL; yypop_buffer_state(); }
/* Destroy the stack itself. */ yyfree((yy_buffer_stack) ); (yy_buffer_stack) = NULL;
/* Reset the globals. This is important in a non-reentrant scanner so the next time * yylex() is called, initialization will occur. */ yy_init_globals( );
return 0;}
/* * Internal utility routines. */
#ifndef yytext_ptrstatic void yy_flex_strncpy (char* s1, const char * s2, int n ){ int i; for ( i = 0; i < n; ++i ) s1[i] = s2[i];}#endif
#ifdef YY_NEED_STRLENstatic int yy_flex_strlen (const char * s ){ int n; for ( n = 0; s[n]; ++n ) ;
return n;}#endif
void *yyalloc (yy_size_t size ){ return malloc(size);}
void *yyrealloc (void * ptr, yy_size_t size ){ /* The cast to (char *) in the following accommodates both * implementations that use char* generic pointers, and those * that use void* generic pointers. It works with the latter * because both ANSI C and C++ allow castless assignment from * any pointer type to void*, and deal with argument conversions * as though doing an assignment. */ return realloc(ptr, size);}
void yyfree (void * ptr ){ free( (char *) ptr ); /* see yyrealloc() for (char *) cast */}
#define YYTABLES_NAME "yytables"