Blame - src/parser_yang_lex.c - github/CESNET/libyang

2016-10-24 11:30:02 +0200

[diff] [blame]

2692

yylloc->first_line = -1;

return ERROR;

}

i += 4;

}

}

return STRINGS;

}

}

YY_BREAK

Pavol Vican

2016-10-24 11:30:02 +0200

[diff] [blame]

2702

case 128:

2703

/* rule 128 can match eol */

PavolVican

2017-01-19 15:09:04 +0100

[diff] [blame]

2704

case 129:

2705

/* rule 129 can match eol */

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2706

YY_RULE_SETUP

Pavol Vican

42f6c65

2016-05-22 17:20:09 +0200

[diff] [blame]

2707

{ yylloc->last_column = 0; return EOL; }

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2708

YY_BREAK

PavolVican

2017-01-19 15:09:04 +0100

[diff] [blame]

2709

case 130:

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2710

YY_RULE_SETUP

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2711

{ return WHITESPACE;}

2712

YY_BREAK

PavolVican

2017-01-19 15:09:04 +0100

[diff] [blame]

2713

case 131:

2714

/* rule 131 can match eol */

Pavol Vican

2016-10-24 11:30:02 +0200

[diff] [blame]

2715

YY_RULE_SETUP

2716

{

Michal Vasko

53b7da0

2018-02-13 15:28:42 +0100

[diff] [blame]

2717

LOGVAL(yyget_extra(yyscanner), LYE_SPEC, LY_VLOG_NONE, NULL, "Invalid UTF-8 leading byte 0x%02x", yytext[0]);

Pavol Vican

2016-10-24 11:30:02 +0200

[diff] [blame]

2718

yylloc->first_line = -1;

2719

return ERROR;

2720

}

2721

YY_BREAK

PavolVican

2017-01-19 15:09:04 +0100

[diff] [blame]

2722

case 132:

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2723

YY_RULE_SETUP

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2724

ECHO;

2725

YY_BREAK

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2726

case YY_STATE_EOF(INITIAL):

2727

case YY_STATE_EOF(COMMENT1):

2728

case YY_STATE_EOF(COMMENT2):

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2729

case YY_STATE_EOF(PATH):

2730

yyterminate();

2731

2732

case YY_END_OF_BUFFER:

2733

{

2734

/* Amount of text matched not including the EOB char. */

2735

int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;

2736

2737

/* Undo the effects of YY_DO_BEFORE_ACTION. */

2738

*yy_cp = yyg->yy_hold_char;

2739

YY_RESTORE_YY_MORE_OFFSET

2740

2741

if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )

2742

{

2743

/* We're scanning a new file or input source. It's

2744

* possible that this happened because the user

2745

* just pointed yyin at a new source and called

2746

* yylex(). If so, then we have to assure

2747

* consistency between YY_CURRENT_BUFFER and our

2748

* globals. Here is the right place to do so, because

2749

* this is the first action (other than possibly a

2750

* back-up) that will match for the new input source.

2751

*/

2752

yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;

2753

YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;

2754

YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;

2755

}

2756

2757

/* Note that here we test for yy_c_buf_p "<=" to the position

2758

* of the first EOB in the buffer, since yy_c_buf_p will

2759

* already have been incremented past the NUL character

2760

* (since all states make transitions on EOB to the

2761

* end-of-buffer state). Contrast this with the test

2762

* in input().

2763

*/

2764

if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )

2765

{ /* This was really a NUL. */

2766

yy_state_type yy_next_state;

2767

2768

yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;

2769

2770

yy_current_state = yy_get_previous_state( yyscanner );

2771

2772

/* Okay, we're now positioned to make the NUL

2773

* transition. We couldn't have

2774

* yy_get_previous_state() go ahead and do it

2775

* for us because it doesn't know how to deal

2776

* with the possibility of jamming (and we don't

2777

* want to build jamming into it because then it

2778

* will run more slowly).

2779

*/

2780

2781

yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);

2782

2783

yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;

if ( yy_next_state )

{

/* Consume the NUL. */

2788

yy_cp = ++yyg->yy_c_buf_p;

2789

yy_current_state = yy_next_state;

goto yy_match;

}

else

{

yy_cp = yyg->yy_c_buf_p;

goto yy_find_action;

}

}

else switch ( yy_get_next_buffer( yyscanner ) )

2801

{

2802

case EOB_ACT_END_OF_FILE:

2803

{

2804

yyg->yy_did_buffer_switch_on_eof = 0;

2805

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

2806

if ( yywrap( yyscanner ) )

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2807

{

2808

/* Note: because we've taken care in

2809

* yy_get_next_buffer() to have set up

2810

* yytext, we can now set up

2811

* yy_c_buf_p so that if some total

2812

* hoser (like flex itself) wants to

2813

* call the scanner after we return the

2814

* YY_NULL, it'll still work - another

2815

* YY_NULL will get returned.

2816

*/

2817

yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;

2818

2819

yy_act = YY_STATE_EOF(YY_START);

goto do_action;

}

else

{

if ( ! yyg->yy_did_buffer_switch_on_eof )

YY_NEW_FILE;

}

break;

}

case EOB_ACT_CONTINUE_SCAN:

2832

yyg->yy_c_buf_p =

2833

yyg->yytext_ptr + yy_amount_of_matched_text;

2834

2835

yy_current_state = yy_get_previous_state( yyscanner );

2836

2837

yy_cp = yyg->yy_c_buf_p;

2838

yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;

2839

goto yy_match;

2840

2841

case EOB_ACT_LAST_MATCH:

2842

yyg->yy_c_buf_p =

2843

&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];

2844

2845

yy_current_state = yy_get_previous_state( yyscanner );

2846

2847

yy_cp = yyg->yy_c_buf_p;

2848

yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;

goto yy_find_action;

}

break;

}

default:

YY_FATAL_ERROR(

"fatal flex scanner internal error--no action found" );

2857

} /* end of action switch */

2858

} /* end of scanning one token */

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

2859

} /* end of user's declarations */

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2860

} /* end of yylex */

2861

2862

/* yy_get_next_buffer - try to read in a new buffer

2863

*

2864

* Returns a code representing an action:

2865

* EOB_ACT_LAST_MATCH -

2866

* EOB_ACT_CONTINUE_SCAN - continue scanning from current position

2867

* EOB_ACT_END_OF_FILE - end of file

2868

*/

2869

static int yy_get_next_buffer (yyscan_t yyscanner)

2870

{

2871

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

2872

char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;

2873

char *source = yyg->yytext_ptr;

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

2874

int number_to_move, i;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2875

int ret_val;

2876

2877

if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )

2878

YY_FATAL_ERROR(

2879

"fatal flex scanner internal error--end of buffer missed" );

2880

2881

if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )

2882

{ /* Don't try to fill the buffer, so this is an EOF. */

2883

if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )

2884

{

2885

/* We matched a single character, the EOB, so

2886

* treat this as a final EOF.

2887

*/

2888

return EOB_ACT_END_OF_FILE;

}

else

{

/* We matched some text prior to the EOB, first

2894

* process it.

2895

*/

2896

return EOB_ACT_LAST_MATCH;

}

}

/* Try to read more data. */

2901

2902

/* First move last chars to start of buffer. */

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

2903

number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2904

2905

for ( i = 0; i < number_to_move; ++i )

2906

*(dest++) = *(source++);

2907

2908

if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )

2909

/* don't do the read, it's not guaranteed to return an EOF,

2910

* just force an EOF

2911

*/

2912

YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;

2913

2914

else

2915

{

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

2916

int num_to_read =

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2917

YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

2918

2919

while ( num_to_read <= 0 )

2920

{ /* Not enough room in the buffer - grow it. */

2921

2922

/* just a shorter name for the current buffer */

2923

YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;

2924

2925

int yy_c_buf_p_offset =

2926

(int) (yyg->yy_c_buf_p - b->yy_ch_buf);

2927

2928

if ( b->yy_is_our_buffer )

2929

{

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

2930

int new_size = b->yy_buf_size * 2;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2931

2932

if ( new_size <= 0 )

2933

b->yy_buf_size += b->yy_buf_size / 8;

else

b->yy_buf_size *= 2;

b->yy_ch_buf = (char *)

2938

/* Include room in for 2 EOB chars. */

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

2939

yyrealloc( (void *) b->yy_ch_buf,

2940

(yy_size_t) (b->yy_buf_size + 2) , yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2941

}

2942

else

2943

/* Can't grow it, we don't own it. */

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

2944

b->yy_ch_buf = NULL;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2945

2946

if ( ! b->yy_ch_buf )

2947

YY_FATAL_ERROR(

2948

"fatal error - scanner input buffer overflow" );

2949

2950

yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];

2951

2952

num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -

number_to_move - 1;

}

if ( num_to_read > YY_READ_BUF_SIZE )

2958

num_to_read = YY_READ_BUF_SIZE;

2959

2960

/* Read in more data. */

2961

YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),

2962

yyg->yy_n_chars, num_to_read );

2963

2964

YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;

2965

}

2966

2967

if ( yyg->yy_n_chars == 0 )

2968

{

2969

if ( number_to_move == YY_MORE_ADJ )

2970

{

2971

ret_val = EOB_ACT_END_OF_FILE;

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

2972

yyrestart( yyin , yyscanner);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

}

else

{

ret_val = EOB_ACT_LAST_MATCH;

2978

YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =

2979

YY_BUFFER_EOF_PENDING;

}

}

else

ret_val = EOB_ACT_CONTINUE_SCAN;

2985

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

2986

if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2987

/* Extend the array by 50%, plus the number we really need. */

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

2988

int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

2989

YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(

2990

(void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2991

if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )

2992

YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

2993

/* "- 2" to take care of EOB's */

2994

YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

2995

}

2996

2997

yyg->yy_n_chars += number_to_move;

2998

YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;

2999

YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;

3000

3001

yyg->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 */

3007

3008

static yy_state_type yy_get_previous_state (yyscan_t yyscanner)

3009

{

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3010

yy_state_type yy_current_state;

3011

char *yy_cp;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3012

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3013

3014

yy_current_state = yyg->yy_start;

3015

3016

for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )

3017

{

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3018

YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3019

if ( yy_accept[yy_current_state] )

3020

{

3021

yyg->yy_last_accepting_state = yy_current_state;

3022

yyg->yy_last_accepting_cpos = yy_cp;

3023

}

3024

while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )

3025

{

3026

yy_current_state = (int) yy_def[yy_current_state];

PavolVican

2017-01-19 15:09:04 +0100

[diff] [blame]

3027

if ( yy_current_state >= 672 )

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3028

yy_c = yy_meta[yy_c];

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3029

}

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3030

yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3031

}

3032

3033

return yy_current_state;

3034

}

3035

3036

/* yy_try_NUL_trans - try to make a transition on the NUL character

3037

*

3038

* synopsis

3039

* next_state = yy_try_NUL_trans( current_state );

3040

*/

3041

static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)

3042

{

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3043

int yy_is_jam;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3044

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3045

char *yy_cp = yyg->yy_c_buf_p;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3046

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3047

YY_CHAR yy_c = 1;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3048

if ( yy_accept[yy_current_state] )

3049

{

3050

yyg->yy_last_accepting_state = yy_current_state;

3051

yyg->yy_last_accepting_cpos = yy_cp;

3052

}

3053

while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )

3054

{

3055

yy_current_state = (int) yy_def[yy_current_state];

PavolVican

2017-01-19 15:09:04 +0100

[diff] [blame]

3056

if ( yy_current_state >= 672 )

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3057

yy_c = yy_meta[yy_c];

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3058

}

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3059

yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];

PavolVican

2017-01-19 15:09:04 +0100

[diff] [blame]

3060

yy_is_jam = (yy_current_state == 671);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3061

3062

(void)yyg;

3063

return yy_is_jam ? 0 : yy_current_state;

3064

}

3065

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

#ifndef YY_NO_UNPUT

#endif

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3070

#ifndef YY_NO_INPUT

3071

#ifdef __cplusplus

3072

static int yyinput (yyscan_t yyscanner)

3073

#else

3074

static int input (yyscan_t yyscanner)

#endif

{

int c;

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3080

3081

*yyg->yy_c_buf_p = yyg->yy_hold_char;

3082

3083

if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )

3084

{

3085

/* yy_c_buf_p now points to the character we want to return.

3086

* If this occurs *before* the EOB characters, then it's a

3087

* valid NUL; if not, then we've hit the end of the buffer.

3088

*/

3089

if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )

3090

/* This was really a NUL. */

3091

*yyg->yy_c_buf_p = '\0';

3092

3093

else

3094

{ /* need more input */

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3095

int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3096

++yyg->yy_c_buf_p;

3097

3098

switch ( yy_get_next_buffer( yyscanner ) )

3099

{

3100

case EOB_ACT_LAST_MATCH:

3101

/* This happens because yy_g_n_b()

3102

* sees that we've accumulated a

3103

* token and flags that we need to

3104

* try matching the token before

3105

* proceeding. But for input(),

3106

* there's no matching to consider.

3107

* So convert the EOB_ACT_LAST_MATCH

3108

* to EOB_ACT_END_OF_FILE.

3109

*/

3110

3111

/* Reset buffer status. */

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3112

yyrestart( yyin , yyscanner);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

/*FALLTHROUGH*/

case EOB_ACT_END_OF_FILE:

3117

{

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3118

if ( yywrap( yyscanner ) )

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

3119

return 0;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3120

3121

if ( ! yyg->yy_did_buffer_switch_on_eof )

3122

YY_NEW_FILE;

3123

#ifdef __cplusplus

3124

return yyinput(yyscanner);

3125

#else

3126

return input(yyscanner);

#endif

}

case EOB_ACT_CONTINUE_SCAN:

3131

yyg->yy_c_buf_p = yyg->yytext_ptr + offset;

break;

}

}

}

c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */

3138

*yyg->yy_c_buf_p = '\0'; /* preserve yytext */

3139

yyg->yy_hold_char = *++yyg->yy_c_buf_p;

return c;

}

#endif /* ifndef YY_NO_INPUT */

3144

3145

/** Immediately switch to a different input stream.

3146

* @param input_file A readable stream.

3147

* @param yyscanner The scanner object.

3148

* @note This function does not reset the start condition to @c INITIAL .

3149

*/

3150

void yyrestart (FILE * input_file , yyscan_t yyscanner)

3151

{

3152

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3153

3154

if ( ! YY_CURRENT_BUFFER ){

3155

yyensure_buffer_stack (yyscanner);

3156

YY_CURRENT_BUFFER_LVALUE =

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3157

yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3158

}

3159

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3160

yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner);

3161

yy_load_buffer_state( yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3162

}

3163

3164

/** Switch to a different input buffer.

3165

* @param new_buffer The new input buffer.

3166

* @param yyscanner The scanner object.

3167

*/

3168

void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)

3169

{

3170

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3171

3172

/* TODO. We should be able to replace this entire function body

3173

* with

3174

* yypop_buffer_state();

3175

* yypush_buffer_state(new_buffer);

3176

*/

3177

yyensure_buffer_stack (yyscanner);

3178

if ( YY_CURRENT_BUFFER == new_buffer )

3179

return;

3180

3181

if ( YY_CURRENT_BUFFER )

3182

{

3183

/* Flush out information for old buffer. */

3184

*yyg->yy_c_buf_p = yyg->yy_hold_char;

3185

YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;

3186

YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;

3187

}

3188

3189

YY_CURRENT_BUFFER_LVALUE = new_buffer;

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3190

yy_load_buffer_state( yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3191

3192

/* We don't actually know whether we did this switch during

3193

* EOF (yywrap()) processing, but the only time this flag

3194

* is looked at is after yywrap() is called, so it's safe

3195

* to go ahead and always set it.

3196

*/

3197

yyg->yy_did_buffer_switch_on_eof = 1;

3198

}

3199

3200

static void yy_load_buffer_state (yyscan_t yyscanner)

3201

{

3202

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3203

yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;

3204

yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;

3205

yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;

3206

yyg->yy_hold_char = *yyg->yy_c_buf_p;

3207

}

3208

3209

/** Allocate and initialize an input buffer state.

3210

* @param file A readable stream.

3211

* @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.

3212

* @param yyscanner The scanner object.

3213

* @return the allocated buffer state.

3214

*/

3215

YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner)

{

YY_BUFFER_STATE b;

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3219

b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3220

if ( ! b )

3221

YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

3222

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3223

b->yy_buf_size = size;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3224

3225

/* yy_ch_buf has to be 2 characters longer than the size given because

3226

* we need to put in 2 end-of-buffer characters.

3227

*/

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3228

b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3229

if ( ! b->yy_ch_buf )

3230

YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

3231

3232

b->yy_is_our_buffer = 1;

3233

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3234

yy_init_buffer( b, file , yyscanner);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

return b;

}

/** Destroy the buffer.

3240

* @param b a buffer created with yy_create_buffer()

3241

* @param yyscanner The scanner object.

3242

*/

3243

void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)

3244

{

3245

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

if ( ! b )

return;

if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */

3251

YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

3252

3253

if ( b->yy_is_our_buffer )

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3254

yyfree( (void *) b->yy_ch_buf , yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3255

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3256

yyfree( (void *) b , yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3257

}

3258

3259

/* Initializes or reinitializes a buffer.

3260

* This function is sometimes called more than once on the same buffer,

3261

* such as during a yyrestart() or at EOF.

3262

*/

3263

static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)

{

int oerrno = errno;

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3268

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3269

yy_flush_buffer( b , yyscanner);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3270

3271

b->yy_input_file = file;

3272

b->yy_fill_buffer = 1;

3273

3274

/* If b is the current buffer, then yy_init_buffer was _probably_

3275

* called from yyrestart() or through yy_get_next_buffer.

3276

* In that case, we don't want to reset the lineno or column.

3277

*/

3278

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.

3289

* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.

3290

* @param yyscanner The scanner object.

3291

*/

3292

void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)

3293

{

3294

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

if ( ! b )

return;

b->yy_n_chars = 0;

/* We always need two end-of-buffer characters. The first causes

3301

* a transition to the end-of-buffer state. The second causes

3302

* a jam in that state.

3303

*/

3304

b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;

3305

b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

3306

3307

b->yy_buf_pos = &b->yy_ch_buf[0];

3308

3309

b->yy_at_bol = 1;

3310

b->yy_buffer_status = YY_BUFFER_NEW;

3311

3312

if ( b == YY_CURRENT_BUFFER )

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3313

yy_load_buffer_state( yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3314

}

3315

3316

/** Pushes the new state onto the stack. The new state becomes

3317

* the current state. This function will allocate the stack

3318

* if necessary.

3319

* @param new_buffer The new state.

3320

* @param yyscanner The scanner object.

3321

*/

3322

void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)

3323

{

3324

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3325

if (new_buffer == NULL)

3326

return;

3327

3328

yyensure_buffer_stack(yyscanner);

3329

3330

/* This block is copied from yy_switch_to_buffer. */

3331

if ( YY_CURRENT_BUFFER )

3332

{

3333

/* Flush out information for old buffer. */

3334

*yyg->yy_c_buf_p = yyg->yy_hold_char;

3335

YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;

3336

YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;

3337

}

3338

3339

/* Only push if top exists. Otherwise, replace top. */

3340

if (YY_CURRENT_BUFFER)

3341

yyg->yy_buffer_stack_top++;

3342

YY_CURRENT_BUFFER_LVALUE = new_buffer;

3343

3344

/* copied from yy_switch_to_buffer. */

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3345

yy_load_buffer_state( yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3346

yyg->yy_did_buffer_switch_on_eof = 1;

3347

}

3348

3349

/** Removes and deletes the top of the stack, if present.

3350

* The next element becomes the new top.

3351

* @param yyscanner The scanner object.

3352

*/

3353

void yypop_buffer_state (yyscan_t yyscanner)

3354

{

3355

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3356

if (!YY_CURRENT_BUFFER)

3357

return;

3358

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3359

yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3360

YY_CURRENT_BUFFER_LVALUE = NULL;

3361

if (yyg->yy_buffer_stack_top > 0)

3362

--yyg->yy_buffer_stack_top;

3363

3364

if (YY_CURRENT_BUFFER) {

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3365

yy_load_buffer_state( yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3366

yyg->yy_did_buffer_switch_on_eof = 1;

}

}

/* Allocates the stack if it does not exist.

3371

* Guarantees space for at least one push.

3372

*/

3373

static void yyensure_buffer_stack (yyscan_t yyscanner)

3374

{

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3375

yy_size_t num_to_alloc;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3376

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3377

3378

if (!yyg->yy_buffer_stack) {

3379

3380

/* First allocation is just for 2 elements, since we don't know if this

3381

* scanner will even need a stack. We use 2 instead of 1 to avoid an

3382

* immediate realloc on the next call.

3383

*/

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

3384

num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3385

yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc

3386

(num_to_alloc * sizeof(struct yy_buffer_state*)

3387

, yyscanner);

3388

if ( ! yyg->yy_buffer_stack )

3389

YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3390

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3391

memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3392

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3393

yyg->yy_buffer_stack_max = num_to_alloc;

3394

yyg->yy_buffer_stack_top = 0;

return;

}

if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){

3399

3400

/* Increase the buffer to prepare for a possible push. */

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3401

yy_size_t grow_size = 8 /* arbitrary grow size */;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3402

3403

num_to_alloc = yyg->yy_buffer_stack_max + grow_size;

3404

yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc

3405

(yyg->yy_buffer_stack,

3406

num_to_alloc * sizeof(struct yy_buffer_state*)

3407

, yyscanner);

3408

if ( ! yyg->yy_buffer_stack )

3409

YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

3410

3411

/* zero only the new slots.*/

3412

memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));

3413

yyg->yy_buffer_stack_max = num_to_alloc;

}

}

/** Setup the input buffer state to scan directly from a user-specified character buffer.

3418

* @param base the character buffer

3419

* @param size the size in bytes of the character buffer

3420

* @param yyscanner The scanner object.

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3421

* @return the newly allocated buffer state object.

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3422

*/

3423

YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)

{

YY_BUFFER_STATE b;

if ( size < 2 ||

base[size-2] != YY_END_OF_BUFFER_CHAR ||

3429

base[size-1] != YY_END_OF_BUFFER_CHAR )

3430

/* They forgot to leave room for the EOB's. */

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

3431

return NULL;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3432

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3433

b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3434

if ( ! b )

3435

YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );

3436

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3437

b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3438

b->yy_buf_pos = b->yy_ch_buf = base;

3439

b->yy_is_our_buffer = 0;

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

3440

b->yy_input_file = NULL;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3441

b->yy_n_chars = b->yy_buf_size;

3442

b->yy_is_interactive = 0;

3443

b->yy_at_bol = 1;

3444

b->yy_fill_buffer = 0;

3445

b->yy_buffer_status = YY_BUFFER_NEW;

3446

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3447

yy_switch_to_buffer( b , yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

return b;

}

/** Setup the input buffer state to scan a string. The next call to yylex() will

3453

* scan from a @e copy of @a str.

3454

* @param yystr a NUL-terminated string to scan

3455

* @param yyscanner The scanner object.

3456

* @return the newly allocated buffer state object.

3457

* @note If you want to scan bytes that may contain NUL values, then use

3458

* yy_scan_bytes() instead.

3459

*/

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3460

YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner)

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3461

{

3462

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3463

return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3464

}

3465

3466

/** Setup the input buffer state to scan the given bytes. The next call to yylex() will

3467

* scan from a @e copy of @a bytes.

3468

* @param yybytes the byte buffer to scan

3469

* @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.

3470

* @param yyscanner The scanner object.

3471

* @return the newly allocated buffer state object.

3472

*/

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3473

YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner)

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

{

YY_BUFFER_STATE b;

char *buf;

yy_size_t n;

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3478

int i;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3479

3480

/* Get memory for full buffer, including space for trailing EOB's. */

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3481

n = (yy_size_t) (_yybytes_len + 2);

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3482

buf = (char *) yyalloc( n , yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3483

if ( ! buf )

3484

YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

3485

3486

for ( i = 0; i < _yybytes_len; ++i )

3487

buf[i] = yybytes[i];

3488

3489

buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

3490

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3491

b = yy_scan_buffer( buf, n , yyscanner);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3492

if ( ! b )

3493

YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );

3494

3495

/* It's okay to grow etc. this buffer, and we should throw it

3496

* away when we're done.

3497

*/

3498

b->yy_is_our_buffer = 1;

return b;

}

#ifndef YY_EXIT_FAILURE

3504

#define YY_EXIT_FAILURE 2

3505

#endif

3506

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3507

static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner)

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3508

{

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3509

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3510

(void)yyg;

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3511

fprintf( stderr, "%s\n", msg );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3512

exit( YY_EXIT_FAILURE );

3513

}

3514

3515

/* Redefine yyless() so it works in section 3 code. */

#undef yyless

#define yyless(n) \

do \

{ \

/* Undo effects of setting up yytext. */ \

Radek Krejci

c79c6b1

2016-07-26 15:11:49 +0200

[diff] [blame]

3522

int yyless_macro_arg = (n); \

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3523

YY_LESS_LINENO(yyless_macro_arg);\

3524

yytext[yyleng] = yyg->yy_hold_char; \

3525

yyg->yy_c_buf_p = yytext + yyless_macro_arg; \

3526

yyg->yy_hold_char = *yyg->yy_c_buf_p; \

3527

*yyg->yy_c_buf_p = '\0'; \

3528

yyleng = yyless_macro_arg; \

} \

while ( 0 )

/* Accessor methods (get/set functions) to struct members. */

3533

3534

/** Get the user-defined data for this scanner.

3535

* @param yyscanner The scanner object.

3536

*/

3537

YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)

3538

{

3539

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

return yyextra;

}

/** Get the current line number.

3544

* @param yyscanner The scanner object.

3545

*/

3546

int yyget_lineno (yyscan_t yyscanner)

3547

{

3548

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3549

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3550

if (! YY_CURRENT_BUFFER)

return 0;

return yylineno;

}

/** Get the current column number.

3557

* @param yyscanner The scanner object.

3558

*/

3559

int yyget_column (yyscan_t yyscanner)

3560

{

3561

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3562

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3563

if (! YY_CURRENT_BUFFER)

return 0;

return yycolumn;

}

/** Get the input stream.

3570

* @param yyscanner The scanner object.

3571

*/

3572

FILE *yyget_in (yyscan_t yyscanner)

3573

{

3574

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

return yyin;

}

/** Get the output stream.

3579

* @param yyscanner The scanner object.

3580

*/

3581

FILE *yyget_out (yyscan_t yyscanner)

3582

{

3583

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

return yyout;

}

/** Get the length of the current token.

3588

* @param yyscanner The scanner object.

3589

*/

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

3590

int yyget_leng (yyscan_t yyscanner)

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3591

{

3592

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

return yyleng;

}

/** Get the current token.

3597

* @param yyscanner The scanner object.

3598

*/

3599

3600

char *yyget_text (yyscan_t yyscanner)

3601

{

3602

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

return yytext;

}

/** Set the user-defined data. This data is never touched by the scanner.

3607

* @param user_defined The data to be associated with this scanner.

3608

* @param yyscanner The scanner object.

3609

*/

3610

void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)

3611

{

3612

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3613

yyextra = user_defined ;

3614

}

3615

3616

/** Set the current line number.

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3617

* @param _line_number line number

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3618

* @param yyscanner The scanner object.

3619

*/

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3620

void yyset_lineno (int _line_number , yyscan_t yyscanner)

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3621

{

3622

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3623

3624

/* lineno is only valid if an input buffer exists. */

3625

if (! YY_CURRENT_BUFFER )

3626

YY_FATAL_ERROR( "yyset_lineno called with no buffer" );

3627

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3628

yylineno = _line_number;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3629

}

3630

3631

/** Set the current column.

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3632

* @param _column_no column number

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3633

* @param yyscanner The scanner object.

3634

*/

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3635

void yyset_column (int _column_no , yyscan_t yyscanner)

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3636

{

3637

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3638

3639

/* column is only valid if an input buffer exists. */

3640

if (! YY_CURRENT_BUFFER )

3641

YY_FATAL_ERROR( "yyset_column called with no buffer" );

3642

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3643

yycolumn = _column_no;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3644

}

3645

3646

/** Set the input stream. This does not discard the current

3647

* input buffer.

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3648

* @param _in_str A readable stream.

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3649

* @param yyscanner The scanner object.

3650

* @see yy_switch_to_buffer

3651

*/

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3652

void yyset_in (FILE * _in_str , yyscan_t yyscanner)

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3653

{

3654

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3655

yyin = _in_str ;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3656

}

3657

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3658

void yyset_out (FILE * _out_str , yyscan_t yyscanner)

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3659

{

3660

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3661

yyout = _out_str ;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3662

}

3663

3664

int yyget_debug (yyscan_t yyscanner)

3665

{

3666

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3667

return yy_flex_debug;

3668

}

3669

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3670

void yyset_debug (int _bdebug , yyscan_t yyscanner)

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3671

{

3672

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3673

yy_flex_debug = _bdebug ;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3674

}

3675

3676

/* Accessor methods for yylval and yylloc */

3677

3678

YYSTYPE * yyget_lval (yyscan_t yyscanner)

3679

{

3680

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

return yylval;

}

void yyset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner)

3685

{

3686

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3687

yylval = yylval_param;

3688

}

3689

Pavol Vican

4ca887b

2016-04-08 09:59:17 +0200

[diff] [blame]

3690

YYLTYPE *yyget_lloc (yyscan_t yyscanner)

3691

{

3692

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

return yylloc;

}

void yyset_lloc (YYLTYPE * yylloc_param , yyscan_t yyscanner)

3697

{

3698

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3699

yylloc = yylloc_param;

3700

}

3701

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3702

/* User-visible API */

3703

3704

/* yylex_init is special because it creates the scanner itself, so it is

3705

* the ONLY reentrant function that doesn't take the scanner as the last argument.

3706

* That's why we explicitly handle the declaration, instead of using our macros.

3707

*/

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3708

int yylex_init(yyscan_t* ptr_yy_globals)

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3709

{

3710

if (ptr_yy_globals == NULL){

errno = EINVAL;

return 1;

}

*ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL );

3716

3717

if (*ptr_yy_globals == NULL){

errno = ENOMEM;

return 1;

}

/* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */

3723

memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

3724

3725

return yy_init_globals ( *ptr_yy_globals );

3726

}

3727

3728

/* yylex_init_extra has the same functionality as yylex_init, but follows the

3729

* convention of taking the scanner as the last argument. Note however, that

3730

* this is a *pointer* to a scanner, as it will be allocated by this call (and

3731

* is the reason, too, why this function also must handle its own declaration).

3732

* The user defined value in the first argument will be available to yyalloc in

3733

* the yyextra field.

3734

*/

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3735

int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals )

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3736

{

3737

struct yyguts_t dummy_yyguts;

3738

3739

yyset_extra (yy_user_defined, &dummy_yyguts);

3740

3741

if (ptr_yy_globals == NULL){

3742

errno = EINVAL;

3743

return 1;

3744

}

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3745

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3746

*ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3747

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3748

if (*ptr_yy_globals == NULL){

3749

errno = ENOMEM;

3750

return 1;

3751

}

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3752

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3753

/* By setting to 0xAA, we expose bugs in

3754

yy_init_globals. Leave at 0x00 for releases. */

3755

memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3756

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3757

yyset_extra (yy_user_defined, *ptr_yy_globals);

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3758

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3759

return yy_init_globals ( *ptr_yy_globals );

3760

}

3761

3762

static int yy_init_globals (yyscan_t yyscanner)

3763

{

3764

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3765

/* Initialization is the same as for the non-reentrant scanner.

3766

* This function is called from yylex_destroy(), so don't allocate here.

3767

*/

3768

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

3769

yyg->yy_buffer_stack = NULL;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3770

yyg->yy_buffer_stack_top = 0;

3771

yyg->yy_buffer_stack_max = 0;

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

3772

yyg->yy_c_buf_p = NULL;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

yyg->yy_init = 0;

yyg->yy_start = 0;

yyg->yy_start_stack_ptr = 0;

3777

yyg->yy_start_stack_depth = 0;

3778

yyg->yy_start_stack = NULL;

3779

3780

/* Defined in main.c */

#ifdef YY_STDINIT

yyin = stdin;

yyout = stdout;

#else

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

3785

yyin = NULL;

3786

yyout = NULL;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3787

#endif

3788

3789

/* 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. */

3796

int yylex_destroy (yyscan_t yyscanner)

3797

{

3798

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3799

3800

/* Pop the buffer stack, destroying each element. */

3801

while(YY_CURRENT_BUFFER){

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3802

yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3803

YY_CURRENT_BUFFER_LVALUE = NULL;

3804

yypop_buffer_state(yyscanner);

3805

}

3806

3807

/* Destroy the stack itself. */

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3808

yyfree(yyg->yy_buffer_stack , yyscanner);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3809

yyg->yy_buffer_stack = NULL;

3810

3811

/* Destroy the start condition stack. */

Radek Krejci

2017-09-12 15:47:49 +0200

[diff] [blame]

3812

yyfree( yyg->yy_start_stack , yyscanner );

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3813

yyg->yy_start_stack = NULL;

3814

3815

/* Reset the globals. This is important in a non-reentrant scanner so the next time

3816

* yylex() is called, initialization will occur. */

3817

yy_init_globals( yyscanner);

3818

3819

/* Destroy the main struct (reentrant only). */

3820

yyfree ( yyscanner , yyscanner );

yyscanner = NULL;

return 0;

}

/*

* Internal utility routines.

3827

*/

3828

3829

#ifndef yytext_ptr

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3830

static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner)

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3831

{

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3832

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3833

(void)yyg;

3834

3835

int i;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3836

for ( i = 0; i < n; ++i )

s1[i] = s2[i];

}

#endif

#ifdef YY_NEED_STRLEN

Pavol Vican

2016-11-02 08:55:22 +0100

[diff] [blame]

3842

static int yy_flex_strlen (const char * s , yyscan_t yyscanner)

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3843

{

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3844

int n;

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3845

for ( n = 0; s[n]; ++n )

;

return n;

}

#endif

void *yyalloc (yy_size_t size , yyscan_t yyscanner)

3853

{

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3854

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3855

(void)yyg;

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

3856

return malloc(size);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3857

}

3858

3859

void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)

3860

{

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3861

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3862

(void)yyg;

3863

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3864

/* The cast to (char *) in the following accommodates both

3865

* implementations that use char* generic pointers, and those

3866

* that use void* generic pointers. It works with the latter

3867

* because both ANSI C and C++ allow castless assignment from

3868

* any pointer type to void*, and deal with argument conversions

3869

* as though doing an assignment.

3870

*/

Radek Krejci

2016-11-01 17:00:32 +0100

[diff] [blame]

3871

return realloc(ptr, size);

Pavol Vican

2016-03-30 12:24:43 +0200

[diff] [blame]

3872

}

3873

3874

void yyfree (void * ptr , yyscan_t yyscanner)

3875

{

Pavol Vican

2016-07-21 13:36:50 +0200

[diff] [blame]

3876

struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;

3877

(void)yyg;

Pavol Vican