FlexLexer.

1
2
3

21-08-2015

// -*-C++-*// FlexLexer.h -- define interfaces for lexical analyzer classes generated

// by flex

4
5
6
7
8
9
10
11
12
13

//
//
//
//
//
//
//
//
//

Copyright (c) 1993 The Regents of the University of California.

All rights reserved.
This code is derived from software contributed to Berkeley by
Kent Williams and Tom Epperly.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

14
15
16
17
18
19

//
//
//
//
//

1. Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

//
//
//

Neither the name of the University nor the names of its contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.

//
//
//
//

THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR

IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.

20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//

This file defines FlexLexer, an abstract class which specifies the

external interface provided to flex C++ lexer objects, and yyFlexLexer,
which defines a particular lexer class.
If you want to create multiple lexer classes, you use the -P flag
to rename each yyFlexLexer to some other xxFlexLexer. You then
include <FlexLexer.h> in your other sources once per lexer class:
#undef yyFlexLexer
#define yyFlexLexer xxFlexLexer
#include <FlexLexer.h>
#undef yyFlexLexer
#define yyFlexLexer zzFlexLexer
#include <FlexLexer.h>
...

46
47
48
49

#ifndef __FLEX_LEXER_H
// Never included before - need to define base class.
#define __FLEX_LEXER_H

50
51
52
53

#include <iostream>
# ifndef FLEX_STD
#
define FLEX_STD std::
Page 1

FlexLexer.h

54

21-08-2015

endif

55
56

extern "C++" {

57
58
59

struct yy_buffer_state;
typedef int yy_state_type;

60
61
62
63

class FlexLexer {
public:
virtual ~FlexLexer()

{ }

64
65
66

const char* YYText() const { return yytext; }

int YYLeng()
const
{ return yyleng; }

67
68
69
70
71
72
73

virtual void
yy_switch_to_buffer( struct yy_buffer_state* new_buffer ) = 0;
virtual struct yy_buffer_state*
yy_create_buffer( FLEX_STD istream* s, int size ) = 0;
virtual void yy_delete_buffer( struct yy_buffer_state* b ) = 0;
virtual void yyrestart( FLEX_STD istream* s ) = 0;

74
75

virtual int yylex() = 0;

76
77
78
79
80
81
82

// Call yylex with new input/output sources.

int yylex( FLEX_STD istream* new_in, FLEX_STD ostream* new_out = 0 )
{
switch_streams( new_in, new_out );
return yylex();
}

83
84
85
86
87

// Switch to new input/output streams. A nil stream pointer

// indicates "keep the current one".
virtual void switch_streams( FLEX_STD istream* new_in = 0,
FLEX_STD ostream* new_out = 0 ) = 0;

88
89

int lineno() const

{ return yylineno; }

90
91
92

int debug() const

{ return yy_flex_debug; }
void set_debug( int flag ) { yy_flex_debug = flag; }

93
94
95
96
97
98
99

protected:
char* yytext;
int yyleng;
int yylineno;
int yy_flex_debug;
};

// only maintained if you use %option yylineno

// only has effect with -d or "%option debug"

100
101
102

}
#endif // FLEXLEXER_H

103
104
105
106

#if defined(yyFlexLexer) || ! defined(yyFlexLexerOnce)

// Either this is the first time through (yyFlexLexerOnce not defined),
// or this is a repeated include to define a different flavor of
Page 2

FlexLexer.h

107
108

21-08-2015

// yyFlexLexer, as discussed in the flex manual.

#define yyFlexLexerOnce

109
110

extern "C++" {

111
112
113
114
115
116

class yyFlexLexer : public FlexLexer {

public:
// arg_yyin and arg_yyout default to the cin and cout, but we
// only make that assignment when initializing in yylex().
yyFlexLexer( FLEX_STD istream* arg_yyin = 0, FLEX_STD ostream* arg_yyout =
0 );

117
118

virtual ~yyFlexLexer();

119
120
121
122
123

void yy_switch_to_buffer( struct yy_buffer_state* new_buffer );

struct yy_buffer_state* yy_create_buffer( FLEX_STD istream* s, int size );
void yy_delete_buffer( struct yy_buffer_state* b );
void yyrestart( FLEX_STD istream* s );

124
125
126

void yypush_buffer_state( struct yy_buffer_state* new_buffer );

void yypop_buffer_state();

127
128
129
130

virtual
virtual
new_out = 0
virtual

int yylex();
void switch_streams( FLEX_STD istream* new_in, FLEX_STD ostream*
);
int yywrap();

131
132
133
134
135

protected:
virtual int LexerInput( char* buf, int max_size );
virtual void LexerOutput( const char* buf, int size );
virtual void LexerError( const char* msg );

136
137
138

void yyunput( int c, char* buf_ptr );

int yyinput();

139
140
141
142

void yy_load_buffer_state();
void yy_init_buffer( struct yy_buffer_state* b, FLEX_STD istream* s );
void yy_flush_buffer( struct yy_buffer_state* b );

143
144
145
146

int yy_start_stack_ptr;
int yy_start_stack_depth;
int* yy_start_stack;

147
148
149
150

void yy_push_state( int new_state );

void yy_pop_state();
int yy_top_state();

151
152
153
154

yy_state_type yy_get_previous_state();
yy_state_type yy_try_NUL_trans( yy_state_type current_state );
int yy_get_next_buffer();

155
156
157

FLEX_STD istream* yyin; // input source for default LexerInput

FLEX_STD ostream* yyout;
// output sink for default LexerOutput
Page 3

FlexLexer.h

21-08-2015

158

// yy_hold_char holds the character lost when yytext is formed.

char yy_hold_char;

159
160
161

// Number of characters read into yy_ch_buf.

int yy_n_chars;

162
163
164

// Points to current character in buffer.

char* yy_c_buf_p;

165
166
167

int yy_init;
int yy_start;

168
169

// whether we need to initialize

// start state number

170

// Flag which is used to allow yywrap()'s to do buffer switches

// instead of setting up a fresh yyin. A bit of a hack ...
int yy_did_buffer_switch_on_eof;

171
172
173
174
175

size_t yy_buffer_stack_top; /**< index of top of stack. */

size_t yy_buffer_stack_max; /**< capacity of stack. */
struct yy_buffer_state ** yy_buffer_stack; /**< Stack as an array. */
void yyensure_buffer_stack(void);

176
177
178
179
180

// The following are not always needed, but may be depending

// on use of certain flex features (like REJECT or yymore()).

181
182
183

yy_state_type yy_last_accepting_state;
char* yy_last_accepting_cpos;

184
185
186

yy_state_type* yy_state_buf;
yy_state_type* yy_state_ptr;

187
188
189

char* yy_full_match;
int* yy_full_state;
int yy_full_lp;

190
191
192
193

int yy_lp;
int yy_looking_for_trail_begin;

194
195
196

int
int
int
int

197
198
199
200
201

yy_more_flag;
yy_more_len;
yy_more_offset;
yy_prev_more_offset;

};

202
203

204
205

#endif // yyFlexLexer || ! yyFlexLexerOnce

206
207

Page 4