mod_lex.c

ngspice又一个电子CAD仿真软件代码.功能更全

       26,  151,  154,   26,  155,  153,  149,   26,  157,   26,
       26,  150,   26,   26,  159,  160,  152,  156,  158,   26,
      162,   26,  164,  163,   26,  161,   26,   26,   26,   26,

       26,   26,  168,   26,  171,   26,  167,  165,  166,   26,
      172,   26,  174,  173,  169,  170,   26,  176,   26,   26,
       26,  175,   26,  178,  179,   26,   26,  181,   26,  177,
       26,   26,  182,   26,   26,  184,  186,   26,  183,   26,
       26,   26,   26,   26,   26,  187,  180,  191,  192,  193,
       26,  188,  185,   26,   26,  189,   26,  190,  194,   26,
      195,  196,  198,   27,  199,   26,   26,  197,   26,   26,
       26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
       26,   26,   26,   26,   26,   26,   26,   26,   26,   26,
       26,   26,   26,   26,   25,  200,    3,  200,  200,  200,

      200,  200,  200,  200,  200,  200,  200,  200,  200,  200,
      200,  200,  200,  200,  200,  200,  200,  200,  200,  200,
      200,  200,  200,  200,  200,  200,  200,  200,  200,  200,
      200,  200
    } ;

static yyconst flex_int16_t yy_chk[433] =
    {   0,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
        1,    1,    1,    1,    1,   11,   13,   13,   11,   16,
       14,   15,   18,   17,   16,   19,   19,   11,   17,   20,
       20,   11,   14,   21,   15,   22,   28,   31,   19,   30,
       22,   18,   29,   29,   22,   32,   30,   31,   22,   33,
       33,   21,   34,   35,   32,   36,   37,   39,   52,   32,
       38,   39,   28,   40,   40,   43,   41,   42,   44,   34,
       45,   46,   37,   36,   35,   44,   38,   41,   42,   47,

       45,   48,   49,   43,   52,   51,   50,   56,   46,   47,
       50,   53,   54,   54,   55,   58,   57,   62,   59,   48,
       64,   49,   51,   59,   66,   53,   60,   60,   70,   58,
       54,   69,   55,   56,   57,   61,   61,   68,   68,   62,
       71,   72,   66,   73,   75,   78,   64,   70,   74,   69,
       72,   71,   76,   75,   74,   78,   79,   76,   80,   81,
       82,   83,   84,   85,   86,   79,   87,   87,   83,   73,
       88,   84,   89,   90,   92,   80,   90,   81,   91,   93,
       94,   85,   88,   95,   96,   98,   82,   88,   89,   94,
       86,   93,   97,   99,   91,  100,   98,   97,  101,  102,

       92,   96,   96,  105,  103,   95,  104,  100,  101,  106,
      106,  104,  100,  103,  107,  109,  110,  111,  102,   99,
      112,  114,  116,  120,  107,  117,  114,  122,  119,  105,
      110,  123,  109,  115,  117,  111,  115,  115,  119,  121,
      124,  116,  112,  126,  127,  127,  120,  122,  126,  123,
      115,  115,  128,  124,  121,  129,  130,  131,  132,  133,
      127,  134,  131,  135,  130,  136,  128,  137,  140,  129,
      143,  134,  137,  139,  139,  136,  132,  141,  141,  144,
      145,  133,  146,  148,  144,  145,  135,  140,  143,  147,
      147,  149,  149,  148,  150,  146,  151,  152,  155,  156,

      157,  159,  152,  161,  157,  158,  151,  149,  150,  162,
      158,  164,  161,  159,  155,  156,  163,  163,  165,  166,
      169,  162,  170,  165,  166,  173,  174,  170,  175,  164,
      176,  177,  173,  178,  180,  175,  177,  182,  174,  183,
      188,  187,  184,  192,  193,  178,  169,  184,  187,  188,
      189,  180,  176,  202,  196,  182,  191,  183,  189,  197,
      191,  192,  196,  201,  197,  199,  198,  193,  195,  194,
      190,  186,  185,  181,  179,  172,  171,  168,  167,  160,
      154,  153,  142,  138,  125,  118,  113,  108,   77,   67,
       65,   63,   27,   12,   10,    3,  200,  200,  200,  200,

      200,  200,  200,  200,  200,  200,  200,  200,  200,  200,
      200,  200,  200,  200,  200,  200,  200,  200,  200,  200,
      200,  200,  200,  200,  200,  200,  200,  200,  200,  200,
      200,  200
    } ;

/* Table of booleans, true if rule could match eol. */
static yyconst flex_int32_t yy_rule_can_match_eol[43] =
    {   0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    1, 0, 0,     };

static yy_state_type yy_last_accepting_state;
static char *yy_last_accepting_cpos;

extern int mod_yy_flex_debug;
int mod_yy_flex_debug = 0;

/* The intent behind this definition is that it'll catch
 * any uses of REJECT which flex missed.
 */
#define REJECT reject_used_but_not_detected
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
char *mod_yytext;
#line 1 "mod_lex.l"
#line 4 "mod_lex.l"

/*============================================================================
FILE  mod_lex.l

MEMBER OF process cmpp

Copyright 1991
Georgia Tech Research Corporation
Atlanta, Georgia 30332
All Rights Reserved

PROJECT A-8503

AUTHORS

    9/12/91  Steve Tynor

MODIFICATIONS

    <date> <person name> <nature of modifications>

SUMMARY

    This file defines tokens applicable to parsing the cfunc.mod
    file, and actions to be taken on encountering those tokens.

INTERFACES

    None.

REFERENCED FILES

    mod_yacc.y

NON-STANDARD FEATURES

    None.

============================================================================*/

#include "mod_yacc_y.h"
#include "mod_yacc.h"
extern void mod_yyerror(char*);

#line 671 "<stdout>"

#define INITIAL 0

#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
 * down here because we want the user's section 1 to have been scanned first.
 * The user has a chance to override it with an option.
 */
#include <unistd.h>
#endif

#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif

/* Macros after this point can all be overridden by user definitions in
 * section 1.
 */

#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int mod_yywrap (void );
#else
extern int mod_yywrap (void );
#endif
#endif

    static void yyunput (int c,char *buf_ptr  );
    
#ifndef yytext_ptr
static void yy_flex_strncpy (char *,yyconst char *,int );
#endif

#ifdef YY_NEED_STRLEN
static int yy_flex_strlen (yyconst char * );
#endif

#ifndef YY_NO_INPUT

#ifdef __cplusplus
static int yyinput (void );
#else
static int input (void );
#endif

#endif

/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE 8192
#endif

/* Copy whatever the last rule matched to the standard output. */
#ifndef ECHO
/* This used to be an fputs(), but since the string might contain NUL's,
 * we now use fwrite().
 */
#define ECHO (void) fwrite( mod_yytext, mod_yyleng, 1, mod_yyout )
#endif

/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 * is returned in "result".
 */
#ifndef YY_INPUT
#define YY_INPUT(buf,result,max_size) \
	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
		{ \
		int c = '*'; \
		size_t n; \
		for ( n = 0; n < max_size && \
			     (c = getc( mod_yyin )) != EOF && c != '\n'; ++n ) \
			buf[n] = (char) c; \
		if ( c == '\n' ) \
			buf[n++] = (char) c; \
		if ( c == EOF && ferror( mod_yyin ) ) \
			YY_FATAL_ERROR( "input in flex scanner failed" ); \
		result = n; \
		} \
	else \
		{ \
		errno=0; \
		while ( (result = fread(buf, 1, max_size, mod_yyin))==0 && ferror(mod_yyin)) \
			{ \
			if( errno != EINTR) \
				{ \
				YY_FATAL_ERROR( "input in flex scanner failed" ); \
				break; \
				} \
			errno=0; \
			clearerr(mod_yyin); \
			} \
		}\
\

#endif

/* No semi-colon after return; correct usage is to write "yyterminate();" -
 * we don't want an extra ';' after the "return" because that will cause
 * some compilers to complain about unreachable statements.
 */
#ifndef yyterminate
#define yyterminate() return YY_NULL
#endif

/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif

/* Report a fatal error. */
#ifndef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
#endif

/* end tables serialization structures and prototypes */

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1

extern int mod_yylex (void);

#define YY_DECL int mod_yylex (void)
#endif /* !YY_DECL */

/* Code executed at the beginning of each rule, after mod_yytext and mod_yyleng
 * have been set up.
 */
#ifndef YY_USER_ACTION
#define YY_USER_ACTION
#endif

/* Code executed at the end of each rule. */
#ifndef YY_BREAK
#define YY_BREAK break;
#endif

#define YY_RULE_SETUP \
	YY_USER_ACTION

/** The main scanner function which does all the work.
 */
YY_DECL
{
	register yy_state_type yy_current_state;
	register char *yy_cp, *yy_bp;
	register int yy_act;
    
#line 53 "mod_lex.l"


#line 825 "<stdout>"

	if ( (yy_init) )
		{
		(yy_init) = 0;

#ifdef YY_USER_INIT
		YY_USER_INIT;
#endif

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

		if ( ! mod_yyin )
			mod_yyin = stdin;

		if ( ! mod_yyout )
			mod_yyout = stdout;

		if ( ! YY_CURRENT_BUFFER ) {
			mod_yyensure_buffer_stack ();
			YY_CURRENT_BUFFER_LVALUE =
				mod_yy_create_buffer(mod_yyin,YY_BUF_SIZE );
		}

		mod_yy_load_buffer_state( );
		}

	while ( 1 )		/* loops until end-of-file is reached */
		{
		yy_cp = (yy_c_buf_p);

		/* Support of mod_yytext. */
		*yy_cp = (yy_hold_char);

		/* yy_bp points to the position in yy_ch_buf of the start of
		 * the current run.
		 */
		yy_bp = yy_cp;

		yy_current_state = (yy_start);
yy_match:
		do
			{
			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
			if ( yy_accept[yy_current_state] )
				{
				(yy_last_accepting_state) = yy_current_state;
				(yy_last_accepting_cpos) = yy_cp;
				}
			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
				{
				yy_current_state = (int) yy_def[yy_current_state];
				if ( yy_current_state >= 201 )
					yy_c = yy_meta[(unsigned int) yy_c];
				}
			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
			++yy_cp;
			}
		while ( yy_base[yy_current_state] != 397 );

yy_find_action:
		yy_act = yy_accept[yy_current_state];
		if ( yy_act == 0 )
			{ /* have to back up */
			yy_cp = (yy_last_accepting_cpos);
			yy_current_state = (yy_last_accepting_state);
			yy_act = yy_accept[yy_current_state];
			}

		YY_DO_BEFORE_ACTION;

		if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
			{
			int yyl;
			for ( yyl = 0; yyl < mod_yyleng; ++yyl )
				if ( mod_yytext[yyl] == '\n' )
					   
    mod_yylineno++;
;
			}

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

		switch ( yy_act )
	{ /* beginning of action switch */
			case 0: /* must back up */
			/* undo the effects of YY_DO_BEFORE_ACTION */
			*yy_cp = (yy_hold_char);
			yy_cp = (yy_last_accepting_cpos);
			yy_current_state = (yy_last_accepting_state);
			goto yy_find_action;

case 1:
YY_RULE_SETUP
#line 55 "mod_lex.l"
{char ch, last_ch;
			 ECHO; /* a comment - repeat it */
			 ch = '\0';
			 do {
			    last_ch = ch;
			    ch = input();
			    fputc(ch,mod_yyout);
			 } while (ch && !((last_ch == '*') && (ch == '/')));
		         if (!ch) {mod_yyerror ("Unterminated comment");}}
	YY_BREAK
case 2:
YY_RULE_SETUP
#line 65 "mod_lex.l"
{return TOK_ARGS;}
	YY_BREAK
case 3:
YY_RULE_SETUP
#line 66 "mod_lex.l"
{return TOK_INIT;}
	YY_BREAK
case 4:
YY_RULE_SETUP
#line 67 "mod_lex.l"
{return TOK_ANALYSIS;}
	YY_BREAK
case 5:
YY_RULE_SETUP
#line 68 "mod_lex.l"
{return TOK_NEW_TIMEPOINT;}
	YY_BREAK
case 6:
YY_RULE_SETUP
#line 69 "mod_lex.l"
{return TOK_CALL_TYPE;}
	YY_BREAK
case 7:
YY_RULE_SETUP
#line 70 "mod_lex.l"
{return TOK_TIME;}
	YY_BREAK
case 8:
YY_RULE_SETUP
#line 71 "mod_lex.l"
{return TOK_RAD_FREQ;}
	YY_BREAK
case 9:
YY_RULE_SETUP
#line 72 "mod_lex.l"
{return TOK_TEMPERATURE;}
	YY_BREAK
case 10:
YY_RULE_SETUP
#line 73 "mod_lex.l"
{return TOK_T;}
	YY_BREAK
case 11:
YY_RULE_SETUP
#line 74 "mod_lex.l"
{return TOK_LOAD;}
	YY_BREAK
case 12:
YY_RULE_SETUP
#line 75 "mod_lex.l"
{return TOK_TOTAL_LOAD;}
	YY_BREAK
case 13:
YY_RULE_SETUP
#line 76 "mod_lex.l"
{return TOK_MESSAGE;}
	YY_BREAK
case 14:
YY_RULE_SETUP
#line 77 "mod_lex.l"
{return TOK_PARAM;}
	YY_BREAK
case 15:
YY_RULE_SETUP
#line 78 "mod_lex.l"
{return TOK_PARAM_SIZE;}
	YY_BREAK
case 16:
YY_RULE_SETUP
#line 79 "mod_lex.l"
{return TOK_PARAM_NULL;}
	YY_BREAK
case 17:
YY_RULE_SETUP
#line 80 "mod_lex.l"
{return TOK_PORT_SIZE;}
	YY_BREAK
case 18:
YY_RULE_SETUP
#line 81 "mod_lex.l"
{return TOK_PORT_NULL;}
	YY_BREAK
case 19:
YY_RULE_SETUP
#line 82 "mod_lex.l"
{return TOK_PARTIAL;}
	YY_BREAK
case 20:
YY_RULE_SETUP
#line 83 "mod_lex.l"
{return TOK_AC_GAIN;}
	YY_BREAK
case 21:
YY_RULE_SETUP
#line 84 "mod_lex.l"
{return TOK_OUTPUT_DELAY;}
	YY_BREAK
case 22:
YY_RULE_SETUP
#line 85 "mod_lex.l"
{return TOK_STATIC_VAR;}
	YY_BREAK
case 23:
YY_RULE_SETUP
#line 86 "mod_lex.l"
{return TOK_STATIC_VAR_SIZE;}
	YY_BREAK
case 24:
YY_RULE_SETUP
#line 87 "mod_lex.l"
{return TOK_INPUT;}
	YY_BREAK
case 25:
YY_RULE_SETUP
#line 88 "mod_lex.l"
{return TOK_INPUT_STATE;}
	YY_BREAK
case 26:
YY_RULE_SETUP
#line 89 "mod_lex.l"
{return TOK_INPUT_TYPE;}
	YY_BREAK
case 27:
YY_RULE_SETUP
#line 90 "mod_lex.l"
{return TOK_INPUT_STRENGTH;}