lex.yy.cc

来自「由matlab开发的hybrid系统的描述语言」· CC 代码 · 共 2,050 行 · 第 1/4 页

      104,  105,   98,  106,   97,  100,  106,  107,  104,  108,

      107,  101,  108,    0,  109,  103,  102,  109,  110,  111,
      112,  110,  111,  112,  113,    0,  114,  113,  115,  114,
      117,  115,    0,  117,    0,  112,  110,  114,  116,  115,
      118,  116,  119,  118,    0,  119,  120,  118,    0,  120,
      121,  119,  117,  121,  109,  122,  123,  124,  122,  123,
      124,  125,  116,  126,  125,    0,  126,  127,  124,    0,
      127,  128,  125,  122,  128,  121,  129,  130,  131,  129,
      130,  131,  132,  129,  133,  132,  134,  133,  135,  134,
      136,  135,  137,  136,  138,  137,  130,  138,  134,  139,
      132,  140,  139,  141,  140,  138,  141,    0,  142,  143,

      135,  142,  143,    0,  144,  145,  137,  144,  145,  140,
      143,  144,  146,  147,    0,  146,  147,  141,  148,  149,
        0,  148,  149,  142,  150,    0,  149,  150,  151,  152,
      153,  151,  152,  153,    0,    0,  154,  147,  152,  154,
      155,  153,  156,  155,  150,  156,  157,  151,  158,  157,
      159,  158,  160,  159,    0,  160,    0,  157,  161,  160,
      162,  161,    0,  162,  163,  155,  156,  163,  164,  165,
      158,  164,  165,  159,  166,  168,  167,  166,  168,  167,
        0,    0,    0,    0,  165,    0,    0,    0,    0,    0,
        0,    0,  164,    0,  166,  167,  170,  170,  170,  172,

        0,  172,  173,  173,  173,  169,  169,  169,  169,  169,
      169,  169,  169,  169,  169,  169,  169,  169,  169,  169,
      169,  169,  169,  169,  169,  169,  169,  169,  169,  169,
      169,  169,  169,  169,  169,  169,  169,  169,  169,  169,
      169,  169,  169,  169,  169,  169,  169,  169,  169,  169,
      169,  169,  169,  169,  169,  169
    } ;

#define REJECT \
{ \
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
yy_cp = yy_full_match; /* restore poss. backed-over text */ \
++yy_lp; \
goto find_rule; \
}
#define yymore() yymore_used_but_not_detected
#define YY_MORE_ADJ 0
#define YY_RESTORE_YY_MORE_OFFSET
#line 1 "hys.l"
#define INITIAL 0
/*
	HYSDEL
	Copyright (C) 1999-2002  Fabio D. Torrisi

	This file is part of HYSDEL.
    
	HYSDEL is free software; you can redistribute it and/or
	modify it under the terms of the GNU General Public
	License as published by the Free Software Foundation; either
	version 2 of the License, or (at your option) any later version.

	HYSDEL is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
	General Public License for more details.

	You should have received a copy of the GNU General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

	CONTACT INFORMATION
	===================
	Fabio D. Torrisi
	ETH Zentrum
	Physikstrasse. 3 ETL,
	CH-8032 Zurich
	Switzerland
	mailto:[e-mail] (preferred)
*/
#define comment 1

#line 37 "hys.l"

#include <string>
#include <ctype.h>
#include <stdio.h>

#include "Implementation.h"
#include "MLD_representation.h"
#include "Cmd_options.h"
#include "Min_max_eps.h"
#include "Continuous_section.h"
#include "Automata_section.h"
#include "Linear_section.h"
#include "Logic_section.h"
#include "AD_section.h"
#include "DA_section.h"
#include "Output_section.h"
#include "Must_section.h"
#include "Continuous_item.h"
#include "Automata_item.h"
#include "Linear_item.h"
#include "Logic_item.h"
#include "AD_item.h"
#include "DA_item.h"
#include "Output_item.h"
#include "Cont_output_item.h"
#include "Logic_output_item.h"
#include "Constraint_item.h"
#include "Logic_must_item.h"
#include "Cont_must_item.h"
#include "Var_symbol.h"
#include "Param_symbol.h"
#include "Symbol_table.h"
#include "Symbol.h"
#include "Globals.h"
#include "Problem.h"
#include "Problem_handler.h"


//"hys.tab.h" is included in "Pure_lexer.h"
#include "Pure_lexer.h"

#define malloc(size) (new char[size]) 
#define free(ptr) 


#line 636 "lex.yy.cc"

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

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


#ifndef yytext_ptr
static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
#endif

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

#ifndef YY_NO_INPUT
#endif

#if YY_STACK_USED
static int yy_start_stack_ptr = 0;
static int yy_start_stack_depth = 0;
static int *yy_start_stack = 0;
#ifndef YY_NO_PUSH_STATE
static void yy_push_state YY_PROTO(( int new_state ));
#endif
#ifndef YY_NO_POP_STATE
static void yy_pop_state YY_PROTO(( void ));
#endif
#ifndef YY_NO_TOP_STATE
static int yy_top_state YY_PROTO(( void ));
#endif

#else
#define YY_NO_PUSH_STATE 1
#define YY_NO_POP_STATE 1
#define YY_NO_TOP_STATE 1
#endif

#ifdef YY_MALLOC_DECL
YY_MALLOC_DECL
#else
#if __STDC__
#ifndef __cplusplus
#include <stdlib.h>
#endif
#else
/* Just try to get by without declaring the routines.  This will fail
 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 * or sizeof(void*) != sizeof(int).
 */
#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
#define ECHO LexerOutput( yytext, yyleng )
#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 ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \
		YY_FATAL_ERROR( "input in flex scanner failed" );
#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) LexerError( msg )
#endif

/* Default declaration of generated scanner - a define so the user can
 * easily add parameters.
 */
#ifndef YY_DECL
#define YY_DECL int yyFlexLexer::yylex()
#endif

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

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

#define YY_RULE_SETUP \
	YY_USER_ACTION

YY_DECL
	{
	register yy_state_type yy_current_state;
	register char *yy_cp, *yy_bp;
	register int yy_act;

#line 83 "hys.l"


	
#line 767 "lex.yy.cc"

	if ( yy_init )
		{
		yy_init = 0;

#ifdef YY_USER_INIT
		YY_USER_INIT;
#endif

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

		if ( ! yyin )
			yyin = &cin;

		if ( ! yyout )
			yyout = &cout;

		if ( ! yy_current_buffer )
			yy_current_buffer =
				yy_create_buffer( yyin, YY_BUF_SIZE );

		yy_load_buffer_state();
		}

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

		/* Support of yytext. */
		*yy_cp = yy_hold_char;

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

		yy_current_state = yy_start;
		yy_state_ptr = yy_state_buf;
		*yy_state_ptr++ = yy_current_state;
yy_match:
		do
			{
			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*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 >= 170 )
					yy_c = yy_meta[(unsigned int) yy_c];
				}
			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
			*yy_state_ptr++ = yy_current_state;
			++yy_cp;
			}
		while ( yy_base[yy_current_state] != 506 );

yy_find_action:
		yy_current_state = *--yy_state_ptr;
		yy_lp = yy_accept[yy_current_state];
find_rule: /* we branch to this label when backing up */
		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];
					{
					yy_full_match = yy_cp;
					break;
					}
				}
			--yy_cp;
			yy_current_state = *--yy_state_ptr;
			yy_lp = yy_accept[yy_current_state];
			}

		YY_DO_BEFORE_ACTION;

		if ( yy_act != YY_END_OF_BUFFER )
			{
			int yyl;
			for ( yyl = 0; yyl < yyleng; ++yyl )
				if ( yytext[yyl] == '\n' )
					++yylineno;
			}

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


		switch ( yy_act )
	{ /* beginning of action switch */
case 1:
YY_RULE_SETUP
#line 86 "hys.l"
{
	/* empty */;
}
	YY_BREAK
case 2:
YY_RULE_SETUP
#line 89 "hys.l"
{

}
	YY_BREAK
case 3:
YY_RULE_SETUP
#line 92 "hys.l"
{
	BEGIN(comment);
}
	YY_BREAK
case 4:
YY_RULE_SETUP
#line 95 "hys.l"
{
	/* eat anything that is not a star */
}
	YY_BREAK
case 5:
YY_RULE_SETUP
#line 98 "hys.l"
{
	/* eat '*' not followed by '/'s */
}
	YY_BREAK
case 6:
YY_RULE_SETUP
#line 101 "hys.l"
{

}
	YY_BREAK
case 7:
YY_RULE_SETUP
#line 104 "hys.l"
{
	BEGIN(INITIAL);
}
	YY_BREAK
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(comment):
#line 107 "hys.l"
{
	return 0;
}
	YY_BREAK
case 8:
YY_RULE_SETUP
#line 110 "hys.l"
{
	sscanf(YYText(), "%lf", & (lvalp->val));
	return NUM;	/* NUM is defined in bison */
}
	YY_BREAK
case 9:
YY_RULE_SETUP
#line 115 "hys.l"
{
	return GE;
}
	YY_BREAK
case 10:
YY_RULE_SETUP
#line 119 "hys.l"
{
	return LE;
}
	YY_BREAK
case 11:
YY_RULE_SETUP
#line 123 "hys.l"
{
	return AR_FI;
}
	YY_BREAK
case 12:
YY_RULE_SETUP
#line 127 "hys.l"
{
	return AR_IF;
}
	YY_BREAK
case 13:
YY_RULE_SETUP
#line 131 "hys.l"
{
	return AR_IFF;
}
	YY_BREAK
case 14:
YY_RULE_SETUP
#line 135 "hys.l"
{
	return OR;
}
	YY_BREAK
case 15:
YY_RULE_SETUP
#line 139 "hys.l"
{
	return AND;
}
	YY_BREAK
case 16:
YY_RULE_SETUP
#line 143 "hys.l"
{
	llocp->first_line=yylineno;
	return SYSTEM;
}
	YY_BREAK
case 17:
YY_RULE_SETUP
#line 147 "hys.l"
{
	llocp->first_line=yylineno;
	return INTERFACE;
}
	YY_BREAK
case 18:
YY_RULE_SETUP
#line 151 "hys.l"
{
	llocp->first_line=yylineno;
	return IMPLEMENTATION;
}
	YY_BREAK
case 19:
YY_RULE_SETUP
#line 155 "hys.l"
{
	llocp->first_line=yylineno;
	return IF;
}
	YY_BREAK
case 20:
YY_RULE_SETUP
#line 159 "hys.l"
{
	llocp->first_line=yylineno;
	return ELSE;
}
	YY_BREAK
case 21:
YY_RULE_SETUP
#line 163 "hys.l"
{
	llocp->first_line=yylineno;
	return STATE;
}
	YY_BREAK
case 22:
YY_RULE_SETUP
#line 167 "hys.l"
{
	llocp->first_line=yylineno;
	return INPUT;
}
	YY_BREAK
case 23: