自学教程：C++ yy_switch_to_buffer函数代码示例

ULONG fstk_RunInclude(char *s){	FILE *f;	char tzFileName[_MAX_PATH + 1];	//printf( "INCLUDE: %s/n", s );	strcpy(tzFileName, s);	fstk_FindFile(tzFileName);	//printf( "INCLUDING: %s/n", tzFileName );	if ((f = fopen(tzFileName, "rt")) != NULL) {		pushcontext();		nLineNo = 1;		nCurrentStatus = STAT_isInclude;		strcpy(tzCurrentFileName, tzFileName);		pCurrentFile = f;		CurrentFlexHandle = yy_create_buffer(pCurrentFile);		yy_switch_to_buffer(CurrentFlexHandle);		//      Dirty hack to give the INCLUDE directive a linefeed		yyunput('/n');		nLineNo -= 1;		return (1);	} else		return (0);}

/** Setup the input buffer state to scan directly from a user-specified character buffer. * @param base the character buffer * @param size the size in bytes of the character buffer *  * @return the newly allocated buffer state object.  */YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size ){	YY_BUFFER_STATE b;    	if ( size < 2 ||	     base[size-2] != YY_END_OF_BUFFER_CHAR ||	     base[size-1] != YY_END_OF_BUFFER_CHAR )		/* They forgot to leave room for the EOB's. */		return 0;	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );	if ( ! b )		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */	b->yy_buf_pos = b->yy_ch_buf = base;	b->yy_is_our_buffer = 0;	b->yy_input_file = 0;	b->yy_n_chars = b->yy_buf_size;	b->yy_is_interactive = 0;	b->yy_at_bol = 1;	b->yy_fill_buffer = 0;	b->yy_buffer_status = YY_BUFFER_NEW;	yy_switch_to_buffer(b  );	return b;}

pt_node *buildAST(const char *expr) {	extern int yyparse(pt_node **, yyscan_t);	FILE *file;	yyscan_t scanner;	pt_node *node = NULL;	YY_BUFFER_STATE state;	if(yylex_init(&scanner)) {		fprintf(stderr, "Failed to initialize parser./n");		exit(-1);	}	file = fopen(expr, "r");	if(file == NULL) {		perror("fopen");		exit(-1);	}	state = yy_create_buffer(file, 1024, scanner);	yy_switch_to_buffer(state, scanner);	if(yyparse(&node, scanner)) {		fprintf(stderr, "Error parsing input./n");		exit(-1);	}	yy_delete_buffer(state, scanner);	yylex_destroy(scanner);	return node;}

int	yywrap() {		if (!include_app) {	/* all input files and strings get a newline appended to them */		include_app = 1;		yy_scan_string("/n");		return 0;	} else {		include_app = 0;		if (inpfile) {	/* (this is just an informal input text for printing-out...) */			FREE(inpfile);  inpfile = NULL;		}			/* delete the input buffer, and possibly close the input file */		yy_delete_buffer(YY_CURRENT_BUFFER);#if CLOSE_AFTER_FLEX>0		if (include_stack_file[include_stack_ptr])			fclose(include_stack_file[include_stack_ptr]);#endif			/* pop the previous saved state from the stack */		if (--include_stack_ptr>=0) {			yy_switch_to_buffer(include_stack[include_stack_ptr]);			inpfile = include_stack_fn[include_stack_ptr];			inpline = include_stack_ln[include_stack_ptr];			yy_pop_state();			return 0;		} /*** else  yyterminate();	does not work ??? ***/	}	return 1;	/* (means the end of current input) */}

int source_parse_file(source *src, const char *filename, const char *modname){  YY_BUFFER_STATE bufstate;  int r;  if (NULL == (yyin = fopen(filename,"r"))) {    perror(filename);    return -1;  }  yyfilename = filename;  yyfileno = add_parsedfile(src,filename);    ////yyfileno is the index in the src->parsedfiles  yylloc.first_line = 1;  bufstate = yy_create_buffer(yyin,YY_BUF_SIZE);  yy_switch_to_buffer(bufstate);  parse_src = src;  parse_modname = modname ? modname : "";  r = yyparse();  yy_delete_buffer(bufstate);#if HAVE_YYLEX_DESTROY  yylex_destroy();#endif  if (yyin)    fclose(yyin);  return r;}

int popFile(void){		bufferStack * buffStack = curbs;	bufferStack * previousBuffStack = 0;	if(!buffStack)	{		return -1;	}	//Switch back to previous	previousBuffStack = buffStack->previous;	free(buffStack);	if(!previousBuffStack)	{		return 0;	}	yy_switch_to_buffer(previousBuffStack->bufferState);	curbs = previousBuffStack;	yylineno = curbs->lineno;	currentFileName = curbs->fileName;		return 1;}

/* * Set up an include file for parsing */voidfstk_RunInclude(char *tzFileName){	FILE *f;	f = fstk_FindFile(tzFileName);	if (f == NULL) {		err(1, "Unable to open included file '%s'",		    tzFileName);	}	pushcontext();	nLineNo = 1;	nCurrentStatus = STAT_isInclude;	strcpy(tzCurrentFileName, tzFileName);	pCurrentFile = f;	CurrentFlexHandle = yy_create_buffer(pCurrentFile);	yy_switch_to_buffer(CurrentFlexHandle);	//Dirty hack to give the INCLUDE directive a linefeed	yyunput('/n');	nLineNo -= 1;}

char *PCCloseentity(void) {    char * pc;    PEntRec per;#ifdef DEBUGGING    FILESTATUS(stdout,"stdout");    MsgKwS(msgTRACE,"Closing the current entity ...",NULL);    MsgKwS(msgTRACE,"PCCloseentity() called ...",NULL);    FILESTATUS(stdout,"stdout");    FILESTATUS(stdin,"stdin");    FILESTATUS(stderr,"stderr");    FILESTATUS(yyin,"yyin");#endif    if (cEntCur > 0) {         per = rgEntities[cEntCur];         pc = per->pcEntname;         if (per->fExtern)              fclose(yyin);         /* close yyin.  We don't need to reset it,            that happens in yy_switch_to_buffer, below */         yy_delete_buffer(YY_CURRENT_BUFFER);         yy_switch_to_buffer(rgBuffers[--cEntCur]);         /* reset pcEntpos and fRdexternal */         if (cEntCur > 0) {              per = rgEntities[cEntCur];              if (per->fExtern) {                   fRdexternal = 1;                   pcEntpos = "";              } else {                   fRdexternal = 0;                   pcEntpos = rgPCPos[cEntCur];              }         } else { /* back to stdin */              fRdexternal = 1;              pcEntpos = "";         }         cLinecount = rgILine[cEntCur];         fnCurrent  = rgPCFn[cEntCur];#ifdef DEBUGGING    FILESTATUS(stdout,"stdout");    FILESTATUS(stdin,"stdin");    FILESTATUS(stderr,"stderr");    FILESTATUS(yyin,"yyin");#endif         return pc;    } else {#ifdef DEBUGGING    FILESTATUS(stdout,"stdout");    FILESTATUS(stdin,"stdin");    FILESTATUS(stderr,"stderr");    FILESTATUS(yyin,"yyin");#endif         return NULL;    }}

voidlexer_set_buffer(RemarkFile *rf){	yyin = rf->file;	file = rf;	yy_switch_to_buffer(yy_create_buffer(rf->file,YY_BUF_SIZE));	rf->lex_buffer = YY_CURRENT_BUFFER;}

voidlexer_restore_buffer(RemarkFile *rf){	file = rf;	yy_delete_buffer(YY_CURRENT_BUFFER);	if (rf != NULL)		yy_switch_to_buffer(rf->lex_buffer);}

Ast* Interpreter::parse(const std::string& input) const{    YY_BUFFER_STATE buffer = yy_scan_string(input.c_str());    yy_switch_to_buffer(buffer);    yyparse();    yylex_destroy();    return m_ast;}

TEST(BisonFlexTest, Test0009){    FileHolder holder("./Resources/Example0009.titan");    GTEST_ASSERT_NE((void*)0, holder.f);    BufferStateHolder bp(yy_create_buffer(holder.f, YY_BUF_SIZE));    yy_switch_to_buffer(bp.bp);    int ans = yyparse();    yy_flush_buffer(bp.bp);    GTEST_ASSERT_EQ(0, ans);}

void parseFile(FILE* in){  YY_BUFFER_STATE* tmp =  new YY_BUFFER_STATE;  *tmp = yy_create_buffer(in, YY_BUF_SIZE);  yy_switch_to_buffer(*tmp);  if(buffer)    yy_delete_buffer(*buffer);    delete buffer;  buffer = tmp;}

static VALUEparse_string(VALUE self, VALUE code) {  VALUE lineno = rb_funcall(self, rb_intern("lineno"), 0);  char *str = StringValueCStr(code);  YY_BUFFER_STATE buffstate = yy_scan_string(str);  yy_switch_to_buffer(buffstate);  yylineno = NUM2INT(lineno);  yyparse(self);  yy_delete_buffer(buffstate);  return self;}

void fstk_RunString(char *s){	struct sSymbol *pSym;	if ((pSym = sym_FindSymbol(s)) != NULL) {		pushcontext();		nCurrentStatus = STAT_isMacroArg;		strcpy(tzCurrentFileName, s);		CurrentFlexHandle =		    yy_scan_bytes(pSym->pMacro, strlen(pSym->pMacro));		yy_switch_to_buffer(CurrentFlexHandle);	} else		yyerror("No such string symbol");}

/********************************************** * SEMANTIC ANALYSIS **********************************************/semantic_analysis::error_id execute_test(std::string program){	semantic_analysis v;	YY_BUFFER_STATE program_buffer = yy_scan_string(program.c_str());	yy_switch_to_buffer(program_buffer);	yyparse();	ast->accept(v);	yy_delete_buffer(program_buffer);	return v.get_last_error();}

int	yyincl(char *fn, int fil) {	char		*s;	DEBUG(CURDLEV+1,"Going to include (ptr=%d) %s /'%s/'./n",include_stack_ptr,fil?"file":"string",fn);	if (include_stack_ptr>=MAX_INCLUDE_DEPTH || include_stack_ptr<-MAX_INCLUDE_DEPTH) {		PROGERROR("Includes are nested too deeply! %d",include_stack_ptr);		exit(-1);	}	if (include_stack_ptr<0) {		include_stack_ptr = -1;	 include_app = 0;		inpfile = NULL;  include_stack_file[0] = NULL;	}			/* opens the given include file for reading */	if (fil) {		if (include_stack_ptr>0)	/* (tries also the subdir of the previous include) */			s = fdir_extract(include_stack_fn[include_stack_ptr-1]);		else  s = NULL;		yyin = fopen_path(fn,"r",frame_path_read,s,frame_extension);		//********* add stdin as an input "-" (interactive input) ........		if (!yyin) {			LERROR("Cannot open include file /'%s/'!",fn);			return -1;		}		if (!FRNAME(curframe)) {			frame_setname(curframe,s=fname_extract(fn));			FREE(s);	/* (this s is a private copy of the string) */		}	}	if (include_stack_ptr>=0) {	/* stores the current buffer, and opens a new buffer */		include_stack[include_stack_ptr] = YY_CURRENT_BUFFER;	}	if (fil) {		yy_switch_to_buffer(yy_create_buffer(yyin,YY_BUF_SIZE));		if (include_stack_ptr+1>=0)  include_stack_file[include_stack_ptr+1] = yyin;	} else {		yy_scan_string(fn);		if (include_stack_ptr+1>=0)  include_stack_file[include_stack_ptr+1] = NULL;	}	if (include_stack_ptr>=0) {	/* stores the whole current state on the stack */		yy_push_state(INITIAL);		include_stack_fn[include_stack_ptr] = inpfile;		include_stack_ln[include_stack_ptr] = inpline;	}	inpfile = MSTRDUP(fn);	/* (freed in yywrap()) */	inpline = 1;	include_stack_ptr++;	inpspecial = !fil;	/* whether special-lines should apply to this include - see SPECMATRIXLINE */	return 0;}

void fstk_RunRept(ULONG count){	if (count) {		pushcontext();		sym_UseCurrentMacroArgs();		sym_SetMacroArgID(nMacroCount++);		sym_UseNewMacroArgs();		nCurrentREPTBlockCount = count;		nCurrentStatus = STAT_isREPTBlock;		nCurrentREPTBlockSize = ulNewMacroSize;		pCurrentREPTBlock = tzNewMacro;		CurrentFlexHandle =		    yy_scan_bytes(pCurrentREPTBlock, nCurrentREPTBlockSize);		yy_switch_to_buffer(CurrentFlexHandle);	}}

static VALUEparse_file(VALUE self) {  VALUE filename = rb_funcall(self, rb_intern("filename"), 0);  VALUE lineno = rb_funcall(self, rb_intern("lineno"), 0);  char *str = StringValueCStr(filename);  FILE *f = fopen(str, "r");  if(!f) {    rb_funcall(self, rb_intern("file_error"), 2, rb_str_new2("Could not open file"), rb_str_new2(str));    return Qnil;  }  YY_BUFFER_STATE buffstate = yy_create_buffer(f, YY_BUF_SIZE);  yy_switch_to_buffer(buffstate);  yylineno = NUM2INT(lineno);  yyparse(self);  yy_delete_buffer(buffstate);  fclose(f);  return self;}

void fstk_RunMacroArg(SLONG s){	char *sym;	if (s == '@')		s = -1;	else		s -= '0';	if ((sym = sym_FindMacroArg(s)) != NULL) {		pushcontext();		nCurrentStatus = STAT_isMacroArg;		sprintf(tzCurrentFileName, "%c", (UBYTE) s);		CurrentFlexHandle = yy_scan_bytes(sym, strlen(sym));		yy_switch_to_buffer(CurrentFlexHandle);	} else		fatalerror("No such macroargument");}

void test_parser_2(){	std::string full_test_program =			"class Program {int x;}/n"			"class main {void main() {}}/0/0"; // Double NULL termination (needed for flex)	YY_BUFFER_STATE program_buffer = yy_scan_string(full_test_program.c_str());	yy_switch_to_buffer(program_buffer);	yyparse();	std::cout << "7) Declaration of multiple classes: ";	assert(ast->classes.size() == 2);	std::cout << "OK" << std::endl;	yy_delete_buffer(program_buffer);	ast.reset();}

/* * Set up a macroargument for parsing */void fstk_RunMacroArg(int32_t s){	char *sym;	if (s == '@')		s = -1;	else		s -= '0';	sym = sym_FindMacroArg(s);	if (sym == NULL)		fatalerror("No such macroargument");	pushcontext();	nCurrentStatus = STAT_isMacroArg;	snprintf(tzCurrentFileName, _MAX_PATH + 1, "%c", (uint8_t)s);	CurrentFlexHandle = yy_scan_bytes(sym, strlen(sym));	yy_switch_to_buffer(CurrentFlexHandle);}

time_t parseDateTimeString(const char *str){    yy_switch_to_buffer(yy_scan_string(str));    yyparse();    time_t tempTime = mktime(str_time);    str_time= localtime(&tempTime);            setFinalTime(&set_time, finalSpecAmount, fromChangeAmount);        tempTime = mktime(str_time);    str_time= localtime(&tempTime);    if(fromModifier.specValue[1])    {        setDayOfWeek(fromModifier.specValue[1], fromModifier.specAmount);    }        return mktime(str_time);    }

ULONG fstk_RunMacro(char *s){	struct sSymbol *sym;	if ((sym = sym_FindMacro(s)) != NULL) {		pushcontext();		sym_SetMacroArgID(nMacroCount++);		nLineNo = -1;		sym_UseNewMacroArgs();		nCurrentStatus = STAT_isMacro;		strcpy(tzCurrentFileName, s);		pCurrentMacro = sym;		CurrentFlexHandle =		    yy_scan_bytes(pCurrentMacro->pMacro,				  pCurrentMacro->ulMacroSize);		yy_switch_to_buffer(CurrentFlexHandle);		return (1);	} else		return (0);}

ULONG fstk_Init(char *s){	char tzFileName[_MAX_PATH + 1];	sym_AddString("__FILE__", s);	strcpy(tzFileName, s);	fstk_FindFile(tzFileName);	pFileStack = NULL;	if ((pCurrentFile = fopen(tzFileName, "rt")) != NULL) {		nMacroCount = 0;		nCurrentStatus = STAT_isInclude;		strcpy(tzCurrentFileName, tzFileName);		CurrentFlexHandle = yy_create_buffer(pCurrentFile);		yy_switch_to_buffer(CurrentFlexHandle);		nLineNo = 1;		return (1);	} else		return (0);}

/* * Initialize the filestack routines */voidfstk_Init(char *s){	char tzFileName[_MAX_PATH + 1];	sym_AddString("__FILE__", s);	strcpy(tzFileName, s);	pFileStack = NULL;	pCurrentFile = fopen(tzFileName, "rb");	if (pCurrentFile == NULL) {		err(1, "Unable to open file '%s'", tzFileName);	}	nMacroCount = 0;	nCurrentStatus = STAT_isInclude;	strcpy(tzCurrentFileName, tzFileName);	CurrentFlexHandle = yy_create_buffer(pCurrentFile);	yy_switch_to_buffer(CurrentFlexHandle);	nLineNo = 1;}

/* Compile a file */void compile_file(compiler_type *comp_void, char *file_name, bool include_baselib) {  compiler_core_type *compiler = (compiler_core_type *)comp_void;  ins_stream_type *baselib = 0; /* TODO: should be gc root */  FILE *in = 0;  char path[PATH_MAX];  /* Actually parse the input stream. */  yylex_init_extra(compiler, &(compiler->scanner));  in = fopen(file_name, "r");  if (!in) {    (void)fprintf(stderr, "Error %i while attempting to open '%s'/n",      errno, file_name);      assert(0);  }  //yyset_in(in, compiler->scanner);  yy_switch_to_buffer(    yy_create_buffer(in, YY_BUF_SIZE, compiler->scanner), compiler->scanner);  push_include_path(compiler, file_name);  /* TODO: Need a better way to handle GC than leaking */  gc_protect(compiler->gc);  /* Inject include for base library */  if (include_baselib) {    strcpy(path, compiler->home);    strcat(path, "/lib/baselib.scm");    STREAM_NEW(baselib, string, path);    setup_include(compiler, baselib);   }    parse_internal(compiler, compiler->scanner);    gc_unprotect(compiler->gc);  yylex_destroy(compiler->scanner);}

/* * Set up an include file for parsing */void fstk_RunInclude(char *tzFileName){	char *incPathUsed = "";	FILE *f = fstk_FindFile(tzFileName, &incPathUsed);	if (f == NULL)		err(1, "Unable to open included file '%s'", tzFileName);	pushcontext();	nLineNo = 1;	nCurrentStatus = STAT_isInclude;	snprintf(tzCurrentFileName, sizeof(tzCurrentFileName), "%s%s",		 incPathUsed, tzFileName);	pCurrentFile = f;	CurrentFlexHandle = yy_create_buffer(pCurrentFile);	yy_switch_to_buffer(CurrentFlexHandle);	/* Dirty hack to give the INCLUDE directive a linefeed */	yyunput('/n');	nLineNo -= 1;}

int source_parse_string(source *src, const char *str, const char *filename, const char *modname){  YY_BUFFER_STATE bufstate;  int r;  yyfilename = filename;  yyfileno = add_parsedfile(src,filename);  yylloc.first_line = 1;  bufstate = yy_scan_string(str);  yy_switch_to_buffer(bufstate);  parse_src = src;  parse_modname = modname ? modname : "";  r = yyparse();  yy_delete_buffer(bufstate);#if HAVE_YYLEX_DESTROY  yylex_destroy();#endif  return r;}

/* nested input files */int newFile(char * _fileName){	FILE * file = fopen(_fileName, "r");	bufferStack * buffStack = 0;	if(!file)	{		perror(_fileName);		return -1;	}	buffStack = malloc(sizeof(bufferStack));	if(!buffStack)	{		perror("malloc");		exit(1);	}	// remember state	if(curbs)	{		curbs->lineno = yylineno;	}	buffStack->previous = curbs;	buffStack->currentFile = file;	buffStack->fileName = _fileName;	// set up current entry	buffStack->bufferState = yy_create_buffer(file, YY_BUF_SIZE);	yy_switch_to_buffer(buffStack->bufferState);	curbs = buffStack;	yylineno = 1;	currentFileName = _fileName;	return 1;}