scan.c File Reference

#include <stdio.h>
#include <stdlib.h>

Include dependency graph for scan.c:

Go to the source code of this file.

Classes
struct	yy_buffer_state

Macros
#define	FLEX_SCANNER
#define	YY_READ_BUF_SIZE   8192
#define	YY_END_TOK   0
#define	ECHO   (void) fwrite( (char *) yytext, yyleng, 1, yyout )
#define	YY_INPUT(buf, result, max_size)
#define	YY_NULL   0
#define	yyterminate()   return ( YY_NULL )
#define	YY_FATAL_ERROR(msg)
#define	yywrap()   1
#define	BEGIN   yy_start = 1 + 2 *
#define	YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
#define	YY_NEW_FILE
#define	YY_DECL   int yylex ( void )
#define	YY_BREAK   break;
#define	YY_END_OF_BUFFER_CHAR   0
#define	YY_BUF_SIZE   (YY_READ_BUF_SIZE * 2) /* size of default input buffer */
#define	YY_CHAR   unsigned char
#define	INITIAL   0
#define	ACTION_ECHO   fprintf( temp_action_file, "%s", yytext )
#define	MARK_END_OF_PROLOG   fprintf( temp_action_file, "%%%% end of prolog\n" );
#define	YY_DECL   int flexscan()
#define	RETURNCHAR
#define	RETURNNAME
#define	PUT_BACK_STRING(str, start)
#define	CHECK_REJECT(str)
#define	CHECK_YYMORE(str)
#define	SECT2   1
#define	SECT2PROLOG   2
#define	SECT3   3
#define	CODEBLOCK   4
#define	PICKUPDEF   5
#define	SC   6
#define	CARETISBOL   7
#define	NUM   8
#define	QUOTE   9
#define	FIRSTCCL   10
#define	CCL   11
#define	ACTION   12
#define	RECOVER   13
#define	BRACEERROR   14
#define	C_COMMENT   15
#define	ACTION_COMMENT   16
#define	ACTION_STRING   17
#define	PERCENT_BRACE_ACTION   18
#define	USED_LIST   19
#define	CODEBLOCK_2   20
#define	XLATION   21
#define	YY_DO_BEFORE_ACTION
#define	EOB_ACT_CONTINUE_SCAN   0
#define	EOB_ACT_END_OF_FILE   1
#define	EOB_ACT_LAST_MATCH   2
#define	yyless(n)
#define	unput(c)   yyunput( c, yytext )
#define	EOF_NOT_SEEN   0
#define	EOF_PENDING   1
#define	EOF_DONE   2
#define	YY_CURRENT_BUFFER   yy_current_buffer
#define	YY_USER_ACTION
#define	YY_USER_INIT
#define	YY_END_OF_BUFFER   121
#define	YY_TRAILING_MASK   0x2000
#define	YY_TRAILING_HEAD_MASK   0x4000
#define	REJECT
#define	yymore()   yymore_used_but_not_detected
#define	YY_MORE_ADJ   0
#define	yy_new_buffer   yy_create_buffer

Typedefs
typedef struct yy_buffer_state *	YY_BUFFER_STATE
typedef int	yy_state_type

Functions
void	yyrestart (FILE *input_file)
void	yy_switch_to_buffer (YY_BUFFER_STATE new_buffer)
void	yy_load_buffer_state (void)
YY_BUFFER_STATE	yy_create_buffer (FILE *file, int size)
void	yy_delete_buffer (YY_BUFFER_STATE b)
void	yy_init_buffer (YY_BUFFER_STATE b, FILE *file)
Char	myesc ()
	if (yy_init)
	while (1)
void	set_input_file (char *file)

Variables
YY_CHAR *	yytext
int	yyleng
FILE *	yyin = (FILE *) 0
FILE *	yyout = (FILE *) 0
	YY_DECL
YY_CHAR *	yy_cp
YY_CHAR *	yy_bp
int	yy_act
int	i
int	indented_code = false
int	checking_used = false
int	new_xlation = false
int	doing_codeblock = false
Char	nmdef [MAXLINE]

Macro Definition Documentation

#define ACTION   12

Definition at line 197 of file scan.c.

#define ACTION_COMMENT   16

Definition at line 201 of file scan.c.

#define ACTION_ECHO   fprintf( temp_action_file, "%s", yytext )

Definition at line 160 of file scan.c.

#define ACTION_STRING   17

Definition at line 202 of file scan.c.

#define BEGIN   yy_start = 1 + 2 *

Definition at line 97 of file scan.c.

#define BRACEERROR   14

Definition at line 199 of file scan.c.

#define C_COMMENT   15

Definition at line 200 of file scan.c.

#define CARETISBOL   7

Definition at line 192 of file scan.c.

#define CCL   11

Definition at line 196 of file scan.c.

#define CHECK_REJECT

(

str

)

Value:

if ( all_upper( str ) ) \
            reject = true;

Definition at line 179 of file scan.c.

#define CHECK_YYMORE

(

str

)

Value:

if ( all_lower( str ) ) \
            yymore_used = true;

Definition at line 183 of file scan.c.

#define CODEBLOCK   4

Definition at line 189 of file scan.c.

#define CODEBLOCK_2   20

Definition at line 205 of file scan.c.

#define ECHO   (void) fwrite( (char *) yytext, yyleng, 1, yyout )

Definition at line 49 of file scan.c.

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 219 of file scan.c.

#define EOB_ACT_END_OF_FILE   1

Definition at line 220 of file scan.c.

#define EOB_ACT_LAST_MATCH   2

Definition at line 221 of file scan.c.

#define EOF_DONE   2

Definition at line 256 of file scan.c.

#define EOF_NOT_SEEN   0

Definition at line 251 of file scan.c.

#define EOF_PENDING   1

Definition at line 255 of file scan.c.

#define FIRSTCCL   10

Definition at line 195 of file scan.c.

#define FLEX_SCANNER

Definition at line 5 of file scan.c.

#define INITIAL   0

Definition at line 129 of file scan.c.

#define MARK_END_OF_PROLOG   fprintf( temp_action_file, "%%%% end of prolog\n" );

Definition at line 161 of file scan.c.

#define NUM   8

Definition at line 193 of file scan.c.

#define PERCENT_BRACE_ACTION   18

Definition at line 203 of file scan.c.

#define PICKUPDEF   5

Definition at line 190 of file scan.c.

#define PUT_BACK_STRING	(		str,
			start
	)

Value:

for ( i = strlen( (char *) (str) ) - 1; i >= start; --i ) \
            unput((str)[i])

Definition at line 175 of file scan.c.

#define QUOTE   9

Definition at line 194 of file scan.c.

#define RECOVER   13

Definition at line 198 of file scan.c.

#define REJECT

Value:

{ \
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
yy_cp = yy_full_match; /* restore poss. backed-over text */ \
yy_lp = yy_full_lp; /* restore orig. accepting pos. */ \
yy_state_ptr = yy_full_state; /* restore orig. state */ \
yy_current_state = *yy_state_ptr; /* restore curr. state */ \
++yy_lp; \
goto find_rule; \
}

Definition at line 920 of file scan.c.

#define RETURNCHAR

Value:

yylval = yytext[0]; \
        return ( CHAR );

Definition at line 167 of file scan.c.

#define RETURNNAME

Value:

(void) strcpy( nmstr, (char *) yytext ); \
        return ( NAME );

Definition at line 171 of file scan.c.

#define SC   6

Definition at line 191 of file scan.c.

#define SECT2   1

Definition at line 186 of file scan.c.

#define SECT2PROLOG   2

Definition at line 187 of file scan.c.

#define SECT3   3

Definition at line 188 of file scan.c.

#define unput

(

c

)

yyunput( c, yytext )

Definition at line 234 of file scan.c.

#define USED_LIST   19

Definition at line 204 of file scan.c.

#define XLATION   21

Definition at line 206 of file scan.c.

#define YY_BREAK   break;

Definition at line 117 of file scan.c.

#define YY_BUF_SIZE   (YY_READ_BUF_SIZE * 2) /* size of default input buffer */

Definition at line 122 of file scan.c.

#define YY_CHAR   unsigned char

Definition at line 127 of file scan.c.

#define YY_CURRENT_BUFFER   yy_current_buffer

Definition at line 265 of file scan.c.

#define YY_DECL   int yylex ( void )

Definition at line 164 of file scan.c.

#define YY_DECL   int flexscan()

Definition at line 164 of file scan.c.

#define YY_DO_BEFORE_ACTION

Value:

yytext = yy_bp; \
        yyleng = yy_cp - yy_bp; \
        yy_hold_char = *yy_cp; \
        *yy_cp = '\0'; \
        yy_c_buf_p = yy_cp;

Definition at line 212 of file scan.c.

#define YY_END_OF_BUFFER   121

Definition at line 292 of file scan.c.

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 119 of file scan.c.

#define YY_END_TOK   0

Definition at line 41 of file scan.c.

#define YY_FATAL_ERROR

(

msg

)

Value:

do \
                { \
                (void) fputs( msg, stderr ); \
                (void) putc( '\n', stderr ); \
                exit( 1 ); \
                } \
        while ( 0 )

Definition at line 81 of file scan.c.

#define YY_INPUT	(		buf,
			result,
			max_size
	)

Value:

if ( (result = read( fileno(yyin), (char *) buf, max_size )) < 0 ) \
            YY_FATAL_ERROR( "read() in flex scanner failed" );

Definition at line 54 of file scan.c.

#define YY_MORE_ADJ   0

Definition at line 931 of file scan.c.

#define yy_new_buffer   yy_create_buffer

Definition at line 957 of file scan.c.

#define YY_NEW_FILE

Value:

do \
                { \
                yy_init_buffer( yy_current_buffer, yyin ); \
                yy_load_buffer_state(); \
                } \
        while ( 0 )

Definition at line 103 of file scan.c.

#define YY_NULL   0

Definition at line 57 of file scan.c.

#define YY_READ_BUF_SIZE   8192

Definition at line 37 of file scan.c.

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

Definition at line 100 of file scan.c.

#define YY_TRAILING_HEAD_MASK   0x4000

Definition at line 919 of file scan.c.

#define YY_TRAILING_MASK   0x2000

Definition at line 918 of file scan.c.

#define YY_USER_ACTION

Definition at line 276 of file scan.c.

#define YY_USER_INIT

Definition at line 280 of file scan.c.

#define yyless

(

n

)

Value:

do \
                { \
                /* undo effects of setting up yytext */ \
                *yy_cp = yy_hold_char; \
                yy_c_buf_p = yy_cp = yy_bp + n; \
                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
                } \
        while ( 0 )

Definition at line 224 of file scan.c.

#define yymore

(

)

yymore_used_but_not_detected

Definition at line 930 of file scan.c.

#define yyterminate

(

)

return ( YY_NULL )

Definition at line 63 of file scan.c.

int yywrap

(

)

1

Definition at line 91 of file scan.c.

Typedef Documentation

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 125 of file scan.c.

typedef int yy_state_type

Definition at line 293 of file scan.c.

Function Documentation

if

(

yy_init

)

Definition at line 972 of file scan.c.

        {
        YY_USER_INIT;

        if ( ! yy_start )
            yy_start = 1;       /* first start state */

        if ( ! yyin )
            yyin = stdin;

        if ( ! yyout )
            yyout = stdout;

        if ( yy_current_buffer )
            yy_init_buffer( yy_current_buffer, yyin );
        else
            yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );

        yy_load_buffer_state();

        yy_init = 0;
        }

Char myesc

(

)

void set_input_file

(

char *

file

)

Definition at line 2233 of file scan.c.

    {
    if ( file )
        {
        infilename = file;
        yyin = fopen( infilename, "r" );

        if ( yyin == NULL )
            lerrsf( "can't open %s", file );
        }

    else
        {
        yyin = stdin;
        infilename = "<stdin>";
        }
    }

while

(

1

)

Definition at line 995 of file scan.c.

        {
        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;
        if ( yy_bp[-1] == '\n' )
            ++yy_current_state;
        yy_state_ptr = yy_state_buf;
        *yy_state_ptr++ = yy_current_state;
yy_match:
        do
            {
            YY_CHAR yy_c = yy_ec[(int)*yy_cp];
            while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                {
                yy_current_state = yy_def[yy_current_state];
                if ( yy_current_state >= 391 )
                    yy_c = yy_meta[(int)yy_c];
                }
            yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
            *yy_state_ptr++ = yy_current_state;
            ++yy_cp;
            }
        while ( yy_current_state != 390 );

yy_find_action:
        yy_current_state = *--yy_state_ptr;
        yy_lp = yy_accept[yy_current_state];
find_rule: /* we branch to this label when backtracking */
        for ( ; ; ) /* until we find what rule we matched */
            {
            if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
                {
                yy_act = yy_acclist[yy_lp];
                if ( yy_act & YY_TRAILING_HEAD_MASK ||
                     yy_looking_for_trail_begin )
                    {
                    if ( yy_act == yy_looking_for_trail_begin )
                        {
                        yy_looking_for_trail_begin = 0;
                        yy_act &= ~YY_TRAILING_HEAD_MASK;
                        break;
                        }
                    }
                else if ( yy_act & YY_TRAILING_MASK )
                    {
                    yy_looking_for_trail_begin = yy_act & ~YY_TRAILING_MASK;
                    yy_looking_for_trail_begin |= YY_TRAILING_HEAD_MASK;
                    }
                else
                    {
                    yy_full_match = yy_cp;
                    yy_full_state = yy_state_ptr;
                    yy_full_lp = yy_lp;
                    break;
                    }
                ++yy_lp;
                goto find_rule;
                }
            --yy_cp;
            yy_current_state = *--yy_state_ptr;
            yy_lp = yy_accept[yy_current_state];
            }

        YY_DO_BEFORE_ACTION;
        YY_USER_ACTION;

do_action:      /* this label is used only to access EOF actions */


        switch ( yy_act )
            {
case 1:
# line 82 "scan.l"
indented_code = true; BEGIN(CODEBLOCK);
        YY_BREAK
case 2:
# line 83 "scan.l"
++linenum; /* treat as a comment */
        YY_BREAK
case 3:
# line 84 "scan.l"
ECHO; BEGIN(C_COMMENT);
        YY_BREAK
case 4:
# line 85 "scan.l"
return ( SCDECL );
        YY_BREAK
case 5:
# line 86 "scan.l"
return ( XSCDECL );
        YY_BREAK
case 6:
# line 87 "scan.l"
{
                        ++linenum;
                        line_directive_out( stdout );
                        indented_code = false;
                        BEGIN(CODEBLOCK);
                        }
        YY_BREAK
case 7:
# line 94 "scan.l"
return ( WHITESPACE );
        YY_BREAK
case 8:
# line 96 "scan.l"
{
                        sectnum = 2;
                        line_directive_out( stdout );
                        BEGIN(SECT2PROLOG);
                        return ( SECTEND );
                        }
        YY_BREAK
case 9:
# line 103 "scan.l"
{
        pinpoint_message( "warning - %%used/%%unused have been deprecated" );
                        checking_used = REALLY_USED; BEGIN(USED_LIST);
                        }
        YY_BREAK
case 10:
# line 107 "scan.l"
{
                        checking_used = REALLY_NOT_USED; BEGIN(USED_LIST);
        pinpoint_message( "warning - %%used/%%unused have been deprecated" );
                        checking_used = REALLY_NOT_USED; BEGIN(USED_LIST);
                        }
        YY_BREAK
case 11:
# line 114 "scan.l"
{
#ifdef NOTDEF
                        fprintf( stderr,
                             "old-style lex command at line %d ignored:\n\t%s",
                                 linenum, yytext );
#endif
                        ++linenum;
                        }
        YY_BREAK
case 12:
# line 123 "scan.l"
/* ignore old lex directive */
        YY_BREAK
case 13:
# line 125 "scan.l"
{
                        ++linenum;
                        xlation =
                            (int *) malloc( sizeof( int ) * (unsigned) csize );

                        if ( ! xlation )
                            flexfatal(
                                "dynamic memory failure building %t table" );

                        for ( i = 0; i < csize; ++i )
                            xlation[i] = 0;

                        num_xlations = 0;

                        BEGIN(XLATION);
                        }
        YY_BREAK
case 14:
# line 142 "scan.l"
synerr( "unrecognized '%' directive" );
        YY_BREAK
case 15:
# line 144 "scan.l"
{
                        (void) strcpy( nmstr, (char *) yytext );
                        didadef = false;
                        BEGIN(PICKUPDEF);
                        }
        YY_BREAK
case 16:
# line 150 "scan.l"
RETURNNAME;
        YY_BREAK
case 17:
# line 151 "scan.l"
++linenum; /* allows blank lines in section 1 */
        YY_BREAK
case 18:
# line 152 "scan.l"
++linenum; return ( '\n' );
        YY_BREAK
case 19:
# line 153 "scan.l"
synerr( "illegal character" ); BEGIN(RECOVER);
        YY_BREAK
case 20:
# line 156 "scan.l"
ECHO; BEGIN(INITIAL);
        YY_BREAK
case 21:
# line 157 "scan.l"
++linenum; ECHO; BEGIN(INITIAL);
        YY_BREAK
case 22:
# line 158 "scan.l"
ECHO;
        YY_BREAK
case 23:
# line 159 "scan.l"
ECHO;
        YY_BREAK
case 24:
# line 160 "scan.l"
++linenum; ECHO;
        YY_BREAK
case 25:
# line 163 "scan.l"
++linenum; BEGIN(INITIAL);
        YY_BREAK
case 26:
# line 164 "scan.l"
ECHO; CHECK_REJECT(yytext);
        YY_BREAK
case 27:
# line 165 "scan.l"
ECHO; CHECK_YYMORE(yytext);
        YY_BREAK
case 28:
# line 166 "scan.l"
ECHO;
        YY_BREAK
case 29:
# line 167 "scan.l"
{
                        ++linenum;
                        ECHO;
                        if ( indented_code )
                            BEGIN(INITIAL);
                        }
        YY_BREAK
case 30:
# line 175 "scan.l"
/* separates name and definition */
        YY_BREAK
case 31:
# line 177 "scan.l"
{
                        (void) strcpy( (char *) nmdef, (char *) yytext );

                        for ( i = strlen( (char *) nmdef ) - 1;
                              i >= 0 &&
                              (nmdef[i] == ' ' || nmdef[i] == '\t');
                              --i )
                            ;

                        nmdef[i + 1] = '\0';

                        ndinstal( nmstr, nmdef );
                        didadef = true;
                        }
        YY_BREAK
case 32:
# line 192 "scan.l"
{
                        if ( ! didadef )
                            synerr( "incomplete name definition" );
                        BEGIN(INITIAL);
                        ++linenum;
                        }
        YY_BREAK
case 33:
# line 199 "scan.l"
++linenum; BEGIN(INITIAL); RETURNNAME;
        YY_BREAK
case 34:
# line 202 "scan.l"
++linenum; BEGIN(INITIAL);
        YY_BREAK
case 35:
# line 203 "scan.l"

        YY_BREAK
case 36:
# line 204 "scan.l"
{
                        if ( all_upper( yytext ) )
                            reject_really_used = checking_used;
                        else
                            synerr( "unrecognized %used/%unused construct" );
                        }
        YY_BREAK
case 37:
# line 210 "scan.l"
{
                        if ( all_lower( yytext ) )
                            yymore_really_used = checking_used;
                        else
                            synerr( "unrecognized %used/%unused construct" );
                        }
        YY_BREAK
case 38:
# line 216 "scan.l"
synerr( "unrecognized %used/%unused construct" );
        YY_BREAK
case 39:
# line 219 "scan.l"
++linenum; BEGIN(INITIAL);
        YY_BREAK
case 40:
# line 220 "scan.l"
++num_xlations; new_xlation = true;
        YY_BREAK
case 41:
# line 221 "scan.l"
synerr( "bad row in translation table" );
        YY_BREAK
case 42:
# line 222 "scan.l"
/* ignore whitespace */
        YY_BREAK
case 43:
# line 224 "scan.l"
{
                        xlation[myesc( yytext )] =
                                (new_xlation ? num_xlations : -num_xlations);
                        new_xlation = false;
                        }
        YY_BREAK
case 44:
# line 229 "scan.l"
{
                        xlation[yytext[0]] =
                                (new_xlation ? num_xlations : -num_xlations);
                        new_xlation = false;
                        }
        YY_BREAK
case 45:
# line 235 "scan.l"
++linenum;
        YY_BREAK
case 46:
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
yy_c_buf_p = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
# line 238 "scan.l"
{
                        ++linenum;
                        ACTION_ECHO;
                        MARK_END_OF_PROLOG;
                        BEGIN(SECT2);
                        }
        YY_BREAK
case 47:
# line 245 "scan.l"
++linenum; ACTION_ECHO;
        YY_BREAK
case YY_STATE_EOF(SECT2PROLOG):
# line 247 "scan.l"
MARK_END_OF_PROLOG; yyterminate();
        YY_BREAK
case 49:
# line 249 "scan.l"
++linenum; /* allow blank lines in section 2 */
        YY_BREAK
case 50:
# line 251 "scan.l"
{
                        indented_code = (yytext[0] != '%');
                        doing_codeblock = true;
                        bracelevel = 1;

                        if ( indented_code )
                            ACTION_ECHO;

                        BEGIN(CODEBLOCK_2);
                        }
        YY_BREAK
case 51:
# line 262 "scan.l"
BEGIN(SC); return ( '<' );
        YY_BREAK
case 52:
# line 263 "scan.l"
return ( '^' );
        YY_BREAK
case 53:
# line 264 "scan.l"
BEGIN(QUOTE); return ( '"' );
        YY_BREAK
case 54:
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
# line 265 "scan.l"
BEGIN(NUM); return ( '{' );
        YY_BREAK
case 55:
# line 266 "scan.l"
BEGIN(BRACEERROR);
        YY_BREAK
case 56:
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
# line 267 "scan.l"
return ( '$' );
        YY_BREAK
case 57:
# line 269 "scan.l"
{
                        bracelevel = 1;
                        BEGIN(PERCENT_BRACE_ACTION);
                        return ( '\n' );
                        }
        YY_BREAK
case 58:
# line 274 "scan.l"
continued_action = true; ++linenum; return ( '\n' );
        YY_BREAK
case 59:
# line 276 "scan.l"
{
                        /* this rule is separate from the one below because
                         * otherwise we get variable trailing context, so
                         * we can't build the scanner using -{f,F}
                         */
                        bracelevel = 0;
                        continued_action = false;
                        BEGIN(ACTION);
                        return ( '\n' );
                        }
        YY_BREAK
case 60:
# line 287 "scan.l"
{
                        bracelevel = 0;
                        continued_action = false;
                        BEGIN(ACTION);
                        return ( '\n' );
                        }
        YY_BREAK
case 61:
# line 294 "scan.l"
++linenum; return ( '\n' );
        YY_BREAK
case 62:
# line 296 "scan.l"
return ( EOF_OP );
        YY_BREAK
case 63:
# line 298 "scan.l"
{
                        sectnum = 3;
                        BEGIN(SECT3);
                        return ( EOF ); /* to stop the parser */
                        }
        YY_BREAK
case 64:
# line 304 "scan.l"
{
                        int cclval;

                        (void) strcpy( nmstr, (char *) yytext );

                        /* check to see if we've already encountered this ccl */
                        if ( (cclval = ccllookup( (Char *) nmstr )) )
                            {
                            yylval = cclval;
                            ++cclreuse;
                            return ( PREVCCL );
                            }
                        else
                            {
                            /* we fudge a bit.  We know that this ccl will
                             * soon be numbered as lastccl + 1 by cclinit
                             */
                            cclinstal( (Char *) nmstr, lastccl + 1 );

                            /* push back everything but the leading bracket
                             * so the ccl can be rescanned
                             */
                            PUT_BACK_STRING((Char *) nmstr, 1);

                            BEGIN(FIRSTCCL);
                            return ( '[' );
                            }
                        }
        YY_BREAK
case 65:
# line 333 "scan.l"
{
                        Char *nmdefptr;
                        Char *ndlookup();

                        (void) strcpy( nmstr, (char *) yytext );
                        nmstr[yyleng - 1] = '\0';  /* chop trailing brace */

                        /* lookup from "nmstr + 1" to chop leading brace */
                        if ( ! (nmdefptr = ndlookup( nmstr + 1 )) )
                            synerr( "undefined {name}" );

                        else
                            { /* push back name surrounded by ()'s */
                            unput(')');
                            PUT_BACK_STRING(nmdefptr, 0);
                            unput('(');
                            }
                        }
        YY_BREAK
case 66:
# line 352 "scan.l"
return ( yytext[0] );
        YY_BREAK
case 67:
# line 353 "scan.l"
RETURNCHAR;
        YY_BREAK
case 68:
# line 354 "scan.l"
++linenum; return ( '\n' );
        YY_BREAK
case 69:
# line 357 "scan.l"
return ( ',' );
        YY_BREAK
case 70:
# line 358 "scan.l"
BEGIN(SECT2); return ( '>' );
        YY_BREAK
case 71:
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
# line 359 "scan.l"
BEGIN(CARETISBOL); return ( '>' );
        YY_BREAK
case 72:
# line 360 "scan.l"
RETURNNAME;
        YY_BREAK
case 73:
# line 361 "scan.l"
synerr( "bad start condition name" );
        YY_BREAK
case 74:
# line 363 "scan.l"
BEGIN(SECT2); return ( '^' );
        YY_BREAK
case 75:
# line 366 "scan.l"
RETURNCHAR;
        YY_BREAK
case 76:
# line 367 "scan.l"
BEGIN(SECT2); return ( '"' );
        YY_BREAK
case 77:
# line 369 "scan.l"
{
                        synerr( "missing quote" );
                        BEGIN(SECT2);
                        ++linenum;
                        return ( '"' );
                        }
        YY_BREAK
case 78:
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
# line 377 "scan.l"
BEGIN(CCL); return ( '^' );
        YY_BREAK
case 79:
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
# line 378 "scan.l"
return ( '^' );
        YY_BREAK
case 80:
# line 379 "scan.l"
BEGIN(CCL); yylval = '-'; return ( CHAR );
        YY_BREAK
case 81:
# line 380 "scan.l"
BEGIN(CCL); RETURNCHAR;
        YY_BREAK
case 82:
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
yy_c_buf_p = yy_cp = yy_bp + 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
# line 382 "scan.l"
return ( '-' );
        YY_BREAK
case 83:
# line 383 "scan.l"
RETURNCHAR;
        YY_BREAK
case 84:
# line 384 "scan.l"
BEGIN(SECT2); return ( ']' );
        YY_BREAK
case 85:
# line 387 "scan.l"
{
                        yylval = myctoi( yytext );
                        return ( NUMBER );
                        }
        YY_BREAK
case 86:
# line 392 "scan.l"
return ( ',' );
        YY_BREAK
case 87:
# line 393 "scan.l"
BEGIN(SECT2); return ( '}' );
        YY_BREAK
case 88:
# line 395 "scan.l"
{
                        synerr( "bad character inside {}'s" );
                        BEGIN(SECT2);
                        return ( '}' );
                        }
        YY_BREAK
case 89:
# line 401 "scan.l"
{
                        synerr( "missing }" );
                        BEGIN(SECT2);
                        ++linenum;
                        return ( '}' );
                        }
        YY_BREAK
case 90:
# line 409 "scan.l"
synerr( "bad name in {}'s" ); BEGIN(SECT2);
        YY_BREAK
case 91:
# line 410 "scan.l"
synerr( "missing }" ); ++linenum; BEGIN(SECT2);
        YY_BREAK
case 92:
# line 413 "scan.l"
bracelevel = 0;
        YY_BREAK
case 93:
# line 414 "scan.l"
{
                        ACTION_ECHO;
                        CHECK_REJECT(yytext);
                        }
        YY_BREAK
case 94:
# line 418 "scan.l"
{
                        ACTION_ECHO;
                        CHECK_YYMORE(yytext);
                        }
        YY_BREAK
case 95:
# line 422 "scan.l"
ACTION_ECHO;
        YY_BREAK
case 96:
# line 423 "scan.l"
{
                        ++linenum;
                        ACTION_ECHO;
                        if ( bracelevel == 0 ||
                             (doing_codeblock && indented_code) )
                            {
                            if ( ! doing_codeblock )
                                fputs( "\tYY_BREAK\n", temp_action_file );

                            doing_codeblock = false;
                            BEGIN(SECT2);
                            }
                        }
        YY_BREAK
        /* Reject and YYmore() are checked for above, in PERCENT_BRACE_ACTION */
case 97:
# line 439 "scan.l"
ACTION_ECHO; ++bracelevel;
        YY_BREAK
case 98:
# line 440 "scan.l"
ACTION_ECHO; --bracelevel;
        YY_BREAK
case 99:
# line 441 "scan.l"
ACTION_ECHO;
        YY_BREAK
case 100:
# line 442 "scan.l"
ACTION_ECHO;
        YY_BREAK
case 101:
# line 443 "scan.l"
ACTION_ECHO; BEGIN(ACTION_COMMENT);
        YY_BREAK
case 102:
# line 444 "scan.l"
ACTION_ECHO; /* character constant */
        YY_BREAK
case 103:
# line 445 "scan.l"
ACTION_ECHO; BEGIN(ACTION_STRING);
        YY_BREAK
case 104:
# line 446 "scan.l"
{
                        ++linenum;
                        ACTION_ECHO;
                        if ( bracelevel == 0 )
                            {
                            fputs( "\tYY_BREAK\n", temp_action_file );
                            BEGIN(SECT2);
                            }
                        }
        YY_BREAK
case 105:
# line 455 "scan.l"
ACTION_ECHO;
        YY_BREAK
case 106:
# line 457 "scan.l"
ACTION_ECHO; BEGIN(ACTION);
        YY_BREAK
case 107:
# line 458 "scan.l"
ACTION_ECHO;
        YY_BREAK
case 108:
# line 459 "scan.l"
ACTION_ECHO;
        YY_BREAK
case 109:
# line 460 "scan.l"
++linenum; ACTION_ECHO;
        YY_BREAK
case 110:
# line 461 "scan.l"
ACTION_ECHO;
        YY_BREAK
case 111:
# line 463 "scan.l"
ACTION_ECHO;
        YY_BREAK
case 112:
# line 464 "scan.l"
ACTION_ECHO;
        YY_BREAK
case 113:
# line 465 "scan.l"
++linenum; ACTION_ECHO;
        YY_BREAK
case 114:
# line 466 "scan.l"
ACTION_ECHO; BEGIN(ACTION);
        YY_BREAK
case 115:
# line 467 "scan.l"
ACTION_ECHO;
        YY_BREAK
case YY_STATE_EOF(ACTION):
case YY_STATE_EOF(ACTION_COMMENT):
case YY_STATE_EOF(ACTION_STRING):
# line 469 "scan.l"
{
                        synerr( "EOF encountered inside an action" );
                        yyterminate();
                        }
        YY_BREAK
case 117:
# line 475 "scan.l"
{
                        yylval = myesc( yytext );
                        return ( CHAR );
                        }
        YY_BREAK
case 118:
# line 480 "scan.l"
{
                        yylval = myesc( yytext );
                        BEGIN(CCL);
                        return ( CHAR );
                        }
        YY_BREAK
case 119:
# line 487 "scan.l"
ECHO;
        YY_BREAK
case 120:
# line 488 "scan.l"
ECHO;
        YY_BREAK
            case YY_STATE_EOF(INITIAL):
            case YY_STATE_EOF(SECT2):
            case YY_STATE_EOF(SECT3):
            case YY_STATE_EOF(CODEBLOCK):
            case YY_STATE_EOF(PICKUPDEF):
            case YY_STATE_EOF(SC):
            case YY_STATE_EOF(CARETISBOL):
            case YY_STATE_EOF(NUM):
            case YY_STATE_EOF(QUOTE):
            case YY_STATE_EOF(FIRSTCCL):
            case YY_STATE_EOF(CCL):
            case YY_STATE_EOF(RECOVER):
            case YY_STATE_EOF(BRACEERROR):
            case YY_STATE_EOF(C_COMMENT):
            case YY_STATE_EOF(PERCENT_BRACE_ACTION):
            case YY_STATE_EOF(USED_LIST):
            case YY_STATE_EOF(CODEBLOCK_2):
            case YY_STATE_EOF(XLATION):
                yyterminate();

            case YY_END_OF_BUFFER:
                {
                /* amount of text matched not including the EOB char */
                int yy_amount_of_matched_text = yy_cp - yytext - 1;

                /* undo the effects of YY_DO_BEFORE_ACTION */
                *yy_cp = yy_hold_char;

                /* 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 yyinput().
                 */
                if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
                    /* this was really a NUL */
                    {
                    yy_state_type yy_next_state;

                    yy_c_buf_p = yytext + 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 + 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
                        {
                        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 + YY_MORE_ADJ;

                            yy_act = YY_STATE_EOF((yy_start - 1) / 2);
                            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 + yy_amount_of_matched_text;

                        yy_current_state = yy_get_previous_state();

                        yy_cp = yy_c_buf_p;
                        yy_bp = yytext + YY_MORE_ADJ;
                        goto yy_match;

                    case EOB_ACT_LAST_MATCH:
                        yy_c_buf_p =
                            &yy_current_buffer->yy_ch_buf[yy_n_chars];

                        yy_current_state = yy_get_previous_state();

                        yy_cp = yy_c_buf_p;
                        yy_bp = yytext + YY_MORE_ADJ;
                        goto yy_find_action;
                    }
                break;
                }

            default:
#ifdef FLEX_DEBUG
                printf( "action # %d\n", yy_act );
#endif
                YY_FATAL_ERROR(
                        "fatal flex scanner internal error--no action found" );
            }
        }

YY_BUFFER_STATE yy_create_buffer	(	FILE *	file,
		int	size
	)

Definition at line 2156 of file scan.c.

    {
    YY_BUFFER_STATE b;

    b = (YY_BUFFER_STATE) malloc( 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 = (YY_CHAR *) malloc( (unsigned) (b->yy_buf_size + 2) );

    if ( ! b->yy_ch_buf )
        YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

    yy_init_buffer( b, file );

    return ( b );
    }

void yy_delete_buffer

(

YY_BUFFER_STATE

b

)

Definition at line 2181 of file scan.c.

    {
    if ( b == yy_current_buffer )
        yy_current_buffer = (YY_BUFFER_STATE) 0;

    free( (char *) b->yy_ch_buf );
    free( (char *) b );
    }

void yy_init_buffer	(	YY_BUFFER_STATE	b,
		FILE *	file
	)

Definition at line 2191 of file scan.c.

    {
    b->yy_input_file = file;

    /* we put in the '\n' and start reading from [1] so that an
     * initial match-at-newline will be true.
     */

    b->yy_ch_buf[0] = '\n';
    b->yy_n_chars = 1;

    /* 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[1] = YY_END_OF_BUFFER_CHAR;
    b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;

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

    b->yy_eof_status = EOF_NOT_SEEN;
    }

void yy_load_buffer_state

(

void

)

Definition at line 2147 of file scan.c.

    {
    yy_n_chars = yy_current_buffer->yy_n_chars;
    yytext = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
    yyin = yy_current_buffer->yy_input_file;
    yy_hold_char = *yy_c_buf_p;
    }

void yy_switch_to_buffer

(

YY_BUFFER_STATE

new_buffer

)

Definition at line 2122 of file scan.c.

    {
    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->yy_buf_pos = yy_c_buf_p;
        yy_current_buffer->yy_n_chars = yy_n_chars;
        }

    yy_current_buffer = 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;
    }

void yyrestart

(

FILE *

input_file

)

Definition at line 2115 of file scan.c.

    {
    yy_init_buffer( yy_current_buffer, input_file );
    yy_load_buffer_state();
    }

Variable Documentation

int checking_used = false

Definition at line 967 of file scan.c.

int doing_codeblock = false

Definition at line 968 of file scan.c.

int i

Definition at line 967 of file scan.c.

int indented_code = false

Definition at line 967 of file scan.c.

int new_xlation = false

Definition at line 967 of file scan.c.

Char nmdef[MAXLINE]

Definition at line 969 of file scan.c.

int yy_act

Definition at line 963 of file scan.c.

YY_CHAR * yy_bp

Definition at line 962 of file scan.c.

YY_CHAR* yy_cp

Definition at line 962 of file scan.c.

YY_DECL

Initial value:

{
    yy_state_type yy_current_state

Definition at line 960 of file scan.c.

FILE* yyin = (FILE *) 0

Definition at line 290 of file scan.c.

int yyleng

Definition at line 288 of file scan.c.

FILE * yyout = (FILE *) 0

Definition at line 290 of file scan.c.

YY_CHAR * yytext

Definition at line 287 of file scan.c.