fbas.i

c编译器实现

				if ( yywrap() )
					{
					 








					yy_c_buf_p = yytext  + 0 ;

					yy_act = (26  +  ((yy_start - 1) / 2)   + 1) ;
					goto do_action;
					}

				else
					{
					if ( ! yy_did_buffer_switch_on_eof )
						yyrestart( yyin ) ;
					}
				break;
				}

			case 0 :
				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  + 0 ;
				goto yy_match;

			case 2 :
				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  + 0 ;
				goto yy_find_action;
			}
		break;
		}

	default:
		yy_fatal_error(  
			"fatal flex scanner internal error--no action found"   ) ;
	}  
		}  
	}  


 







static int yy_get_next_buffer()
	{
	register char *dest = yy_current_buffer->yy_ch_buf;
	register char *source = yytext ;
	register int number_to_move, i;
	int ret_val;

	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
		yy_fatal_error(  
		"fatal flex scanner internal error--end of buffer missed"   ) ;

	if ( yy_current_buffer->yy_fill_buffer == 0 )
		{  
		if ( yy_c_buf_p - yytext  - 0  == 1 )
			{
			 


			return 1 ;
			}

		else
			{
			 


			return 2 ;
			}
		}

	 

	 
	number_to_move = (int) (yy_c_buf_p - yytext ) - 1;

	for ( i = 0; i < number_to_move; ++i )
		*(dest++) = *(source++);

	if ( yy_current_buffer->yy_buffer_status == 2  )
		 


		yy_n_chars = 0;

	else
		{
		int num_to_read =
			yy_current_buffer->yy_buf_size - number_to_move - 1;

		while ( num_to_read <= 0 )
			{  





			 
			YY_BUFFER_STATE b = yy_current_buffer;

			int yy_c_buf_p_offset =
				(int) (yy_c_buf_p - b->yy_ch_buf);

			if ( b->yy_is_our_buffer )
				{
				int new_size = b->yy_buf_size * 2;

				if ( new_size <= 0 )
					b->yy_buf_size += b->yy_buf_size / 8;
				else
					b->yy_buf_size *= 2;

				b->yy_ch_buf = (char *)
					 
					yy_flex_realloc( (void *) b->yy_ch_buf,
							 b->yy_buf_size + 2 );
				}
			else
				 
				b->yy_ch_buf = 0;

			if ( ! b->yy_ch_buf )
				yy_fatal_error(  
				"fatal error - scanner input buffer overflow"   ) ;

			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];

			num_to_read = yy_current_buffer->yy_buf_size -
						number_to_move - 1;

			}

		if ( num_to_read > 8192  )
			num_to_read = 8192 ;

		 
		if ( yy_current_buffer->yy_is_interactive ) { int c = '*', n; for ( n = 0; n <   num_to_read   && (c = fgetc(  yyin  ) ) != (-1)  && c != '\n'; ++n )   (&yy_current_buffer->yy_ch_buf[number_to_move]) [n] = (char) c; if ( c == '\n' )   (&yy_current_buffer->yy_ch_buf[number_to_move]) [n++] = (char) c; if ( c == (-1)  && ferror( yyin ) ) yy_fatal_error(   "input in flex scanner failed"   ) ;  
			yy_n_chars  = n; } else if ( ((  			yy_n_chars  = fread(   (&yy_current_buffer->yy_ch_buf[number_to_move]) , 1,   num_to_read  , yyin )) == 0) && ferror( yyin ) ) yy_fatal_error(   "input in flex scanner failed"   ) ; ;
		}

	if ( yy_n_chars == 0 )
		{
		if ( number_to_move == 0  )
			{
			ret_val = 1 ;
			yyrestart( yyin );
			}

		else
			{
			ret_val = 2 ;
			yy_current_buffer->yy_buffer_status =
				2 ;
			}
		}

	else
		ret_val = 0 ;

	yy_n_chars += number_to_move;
	yy_current_buffer->yy_ch_buf[yy_n_chars] = 0 ;
	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = 0 ;

	yytext  = &yy_current_buffer->yy_ch_buf[0];

	return ret_val;
	}


 

static yy_state_type yy_get_previous_state()
	{
	register yy_state_type yy_current_state;
	register char *yy_cp;

	yy_current_state = yy_start;

	for ( yy_cp = yytext  + 0 ; yy_cp < yy_c_buf_p; ++yy_cp )
		{
		register YY_CHAR yy_c = (*yy_cp ? yy_ec[((unsigned int) (unsigned char)  *yy_cp ) ] : 1);
		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 >= 71 )
				yy_c = yy_meta[(unsigned int) yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
		}

	return yy_current_state;
	}


 






static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )




	{
	register int yy_is_jam;
	register char *yy_cp = yy_c_buf_p;

	register YY_CHAR yy_c = 1;
	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 >= 71 )
			yy_c = yy_meta[(unsigned int) yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
	yy_is_jam = (yy_current_state == 70);

	return yy_is_jam ? 0 : yy_current_state;
	}




static void yyunput( int c, register char *yy_bp )





	{
	register char *yy_cp = yy_c_buf_p;

	 
	*yy_cp = yy_hold_char;

	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
		{  
		 
		register int number_to_move = yy_n_chars + 2;
		register char *dest = &yy_current_buffer->yy_ch_buf[
					yy_current_buffer->yy_buf_size + 2];
		register char *source =
				&yy_current_buffer->yy_ch_buf[number_to_move];

		while ( source > yy_current_buffer->yy_ch_buf )
			*--dest = *--source;

		yy_cp += (int) (dest - source);
		yy_bp += (int) (dest - source);
		yy_n_chars = yy_current_buffer->yy_buf_size;

		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
			yy_fatal_error(   "flex scanner push-back overflow"   ) ;
		}

	*--yy_cp = (char) c;


	yytext  = yy_bp;
	yy_hold_char = *yy_cp;
	yy_c_buf_p = yy_cp;
	}






static int input()

	{
	int c;

	*yy_c_buf_p = yy_hold_char;

	if ( *yy_c_buf_p == 0  )
		{
		 



		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
			 
			*yy_c_buf_p = '\0';

		else
			{  
			yytext  = yy_c_buf_p;
			++yy_c_buf_p;

			switch ( yy_get_next_buffer() )
				{
				case 1 :
					{
					if ( yywrap() )
						{
						yy_c_buf_p =
						yytext  + 0 ;
						return (-1) ;
						}

					if ( ! yy_did_buffer_switch_on_eof )
						yyrestart( yyin ) ;



					return input();

					}

				case 0 :
					yy_c_buf_p = yytext  + 0 ;
					break;

				case 2 :




					yy_fatal_error(  
					"unexpected last match in input()"   ) ;

				}
			}
		}

	c = *(unsigned char *) yy_c_buf_p;	 
	*yy_c_buf_p = '\0';	 
	yy_hold_char = *++yy_c_buf_p;


	return c;
	}



void yyrestart( FILE *input_file )




	{
	if ( ! yy_current_buffer )
		yy_current_buffer = yy_create_buffer( yyin, 16384  );

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



void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )




	{
	if ( yy_current_buffer == new_buffer )
		return;

	if ( yy_current_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();

	 




	yy_did_buffer_switch_on_eof = 1;
	}



void yy_load_buffer_state( void )



	{
	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;
	}



YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )





	{
	YY_BUFFER_STATE b;

	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
	if ( ! b )
		yy_fatal_error(   "out of dynamic memory in yy_create_buffer()"   ) ;

	b->yy_buf_size = size;

	 


	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
	if ( ! b->yy_ch_buf )
		yy_fatal_error(   "out of dynamic memory in yy_create_buffer()"   ) ;

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file );

	return b;
	}



void yy_delete_buffer( YY_BUFFER_STATE b )




	{
	if ( ! b )
		return;

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

	if ( b->yy_is_our_buffer )
		yy_flex_free( (void *) b->yy_ch_buf );

	yy_flex_free( (void *) b );
	}









void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )







	{
	yy_flush_buffer( b );

	b->yy_input_file = file;
	b->yy_fill_buffer = 1;


	b->yy_is_interactive = 1;







	}



void yy_flush_buffer( YY_BUFFER_STATE b )





	{
	b->yy_n_chars = 0;

	 



	b->yy_ch_buf[0] = 0 ;
	b->yy_ch_buf[1] = 0 ;

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

	b->yy_at_bol = 1;
	b->yy_buffer_status = 0 ;

	if ( b == yy_current_buffer )
		yy_load_buffer_state();
	}




YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )





	{
	YY_BUFFER_STATE b;

	if ( size < 2 ||
	     base[size-2] != 0  ||
	     base[size-1] != 0  )
		 
		return 0;

	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
	if ( ! b )
		yy_fatal_error(   "out of dynamic memory in yy_scan_buffer()"   ) ;

	b->yy_buf_size = size - 2;	 
	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 = 0 ;

	yy_switch_to_buffer( b );

	return b;
	}





YY_BUFFER_STATE yy_scan_string( const  char *str )




	{
	int len;
	for ( len = 0; str[len]; ++len )
		;

	return yy_scan_bytes( str, len );
	}





YY_BUFFER_STATE yy_scan_bytes( const  char *bytes, int len )





	{
	YY_BUFFER_STATE b;
	char *buf;
	yy_size_t n;
	int i;

	 
	n = len + 2;
	buf = (char *) yy_flex_alloc( n );
	if ( ! buf )
		yy_fatal_error(   "out of dynamic memory in yy_scan_bytes()"   ) ;

	for ( i = 0; i < len; ++i )
		buf[i] = bytes[i];

	buf[len] = buf[len+1] = 0 ;

	b = yy_scan_buffer( buf, n );
	if ( ! b )
		yy_fatal_error(   "bad buffer in yy_scan_bytes()"   ) ;

	 


	b->yy_is_our_buffer = 1;

	return b;
	}



# 1562 "lex.yy.c"



# 1573 "lex.yy.c"















static void yy_fatal_error( const  char msg[] )




	{
	(void) fprintf( stderr, "%s\n", msg );
	exit( 2  );
	}



 



# 1614 "lex.yy.c"


 

# 1632 "lex.yy.c"




static void *yy_flex_alloc( yy_size_t size )




	{
	return (void *) malloc( size );
	}


static void *yy_flex_realloc( void *ptr, yy_size_t size )





	{
	 






	return (void *) realloc( (char *) ptr, size );
	}


static void yy_flex_free( void *ptr )




	{
	free( ptr );
	}








# 93 "fbas_lex.l"


	
int yywrap(void)
{
	 return 1;
}
	
# 215 "fbas.y" 2



 



void Hash_Init(void)
{
	 int i;
	 
	 for(i=0;i< 1001 ;i++) hash_tab[i]= ((void *)0) ;
}

int Hash_Func(char *name)
{
	 unsigned int h;
	 unsigned char *p;
	 
	 h=0;
	 p=(unsigned char *)name;
	 while (*p != 0) {
			h=((h<<8)+(*p)) % 1001 ;
			p++;
	 }
	 return h;
}

	 
SYM_ENT *Hash_New(char *name,int sym_type)
{
	 int h;
	 SYM_ENT *a;

	 a=malloc(sizeof(SYM_ENT));
	 strcpy(a->name,name);
	 a->reloc_first= ((void *)0) ;
	 a->sym_type=sym_type;
	 a->reloc_nb=0;
	 
	 h=Hash_Func(a->name);
	 a->hash_next=hash_tab[h];
	 hash_tab[h]=a;
	 return a;
}


SYM_ENT *Hash_Search(char *name)
{
	 int h;
	 SYM_ENT *p;

	 h=Hash_Func(name);
	 p=hash_tab[h];
	 while (p!= ((void *)0) ) {
			if (strcmp(p->name,name)==0) return p;
			p=p->hash_next;
	 }
	 return ((void *)0) ;
}

void Reloc_New(SYM_ENT *s,int seg,int offset)
{
	 RELOC_ENT *e;
	 
	 s->reloc_nb++;
	 e=malloc(sizeof(RELOC_ENT));
	 e->next=s->reloc_first;
	 s->reloc_first=e;
	 e->seg=seg;
	 e->offset=offset;
}
	 
void Sym_Declare(char *name,int seg,int val)
{
	 SYM_ENT *s;
	 s=Hash_Search(name);
	 if (s!= ((void *)0) ) {
			if (s->sym_type!= 0 ) yyerror("Red閒inition de '%s'",name);
			s->sym_type= 2 ;
	 } else {
			s=Hash_New(name,2 );
	 }
	 s->value=val;
	 s->seg=seg;
}

void Sym_NewPrivate(void)
{
	 int i;
	 SYM_ENT *s;
	 
	 for(i=0;i< 1001 ;i++) {
			s=hash_tab[i];
			while (s!= ((void *)0) ) {
				 if (s->sym_type== 2 ) {
						strcpy(s->name,".");
				 }
				 s=s->hash_next;
			}
	 }
}

			
 

void Seg_PutByte(int c)
{
	 if (seg_offset[seg_cur] == seg_maxsize[seg_cur]) {
			seg_maxsize[seg_cur]+= 4096 ;
			if (seg_data[seg_cur] == ((void *)0) ) {
				 seg_data[seg_cur]=malloc(seg_maxsize[seg_cur]);
			} else {
				 seg_data[seg_cur]=realloc(seg_data[seg_cur],seg_maxsize[seg_cur]);
			}
	 }
	 seg_data[seg_cur][seg_offset[seg_cur]]=c;
	 seg_offset[seg_cur]++;
}

void Seg_PutSym(int data,char *sym_str)
{
	 SYM_ENT *s;
	 
	 if (sym_str!= ((void *)0) ) {
			s=Hash_Search(sym_str);
			if (s== ((void *)0) ) {
				 s=Hash_New(sym_str,0 );
			}
			Reloc_New(s,seg_cur,seg_offset[seg_cur]);
	 }







	 Seg_PutByte((data      ) & 0xFF);
	 Seg_PutByte((data >> 8 ) & 0xFF);
	 Seg_PutByte((data >> 16) & 0xFF);
	 Seg_PutByte((data >> 24) & 0xFF);

}
	 
void Seg_Init(void)
{
	 int i;
	 
	 for(i=0;i< 2 ;i++) {
			seg_offset[i]=0;
			seg_maxsize[i]=0;
			seg_data[i]= ((void *)0) ;
	 }
}

void fput_i(FILE *f,unsigned int a)
{
	 fputc((a >>24) & 0xFF,f);
	 fputc((a >>16) & 0xFF,f);
	 fputc((a >> 8) & 0xFF,f);
	 fputc((a     ) & 0xFF,f);
}

# 394 "fbas.y"


static void mput_i(unsigned char *p,unsigned int a)
{
	 p[3]=a >> 24;
	 p[2]=a >> 16;
	 p[1]=a >> 8;
	 p[0]=a;
}

static int mget_i(unsigned char *p)
{
	 return (p[3]<<24) + (p[2]<<16) + (p[1]<<8) + (p[0]);
}


	 
 



void Seg_ExecWrite(char *filename,int stack_size)
{
	 FILE *f;
	 int i,adr;
	 SYM_ENT *s;
	 RELOC_ENT *ent;
	 unsigned char *buf;
	 int code_size,data_size;
	 int reloc_nb;
	 
	  
	 for(i=0;i<2;i++) {
			seg_cur=i;
			while ((seg_offset[seg_cur] % 16 ) != 0) Seg_PutByte(0);
	 }
	 
	 code_size=seg_offset[0];
	 data_size=seg_offset[1];
	 reloc_nb=0;
	 
	  
	 for(i=0;i< 1001 ;i++) {
			s=hash_tab[i];
			while (s!= ((void *)0) ) {
				 if (s->sym_type == 0 ) 
					 yyerror("Symbole '%s' non r閟olu",s->name);
				 ent=s->reloc_first;
				 while (ent!= ((void *)0) ) {
						if (s->seg!= -1 ) reloc_nb++;
						buf=&seg_data[ent->seg][ent->offset];
						adr=mget_i(buf);
 
						if (s->seg== 1 ) adr+=code_size+s->value;
						else adr+=s->value;
						mput_i(buf,adr);
						
						ent=ent->next;
				 }
				 s=s->hash_next;
			}
	 }
	 
	 f=fopen(filename,"w");
	 fput_i(f,(('f' << 24)|('b' << 16)|('v' << 8)|'m') );
	 fput_i(f,reloc_nb);

	 fput_i(f,code_size+data_size);
	 fput_i(f,stack_size);
	 
	 for(i=0;i< 2 ;i++) {
			fwrite(seg_data[i],1,seg_offset[i],f);
	 }

	  


	 for(i=0;i< 1001 ;i++) {
			s=hash_tab[i];
			while (s!= ((void *)0) ) {
				 if (s->seg != -1 ) {
						ent=s->reloc_first;
						while (ent!= ((void *)0) ) {
							 if (ent->seg== 1 ) 
								 fput_i(f,code_size+ent->offset);
							 else
								 fput_i(f,ent->offset);
							 ent=ent->next;
						}
				 }
				 s=s->hash_next;
			}
	 }
	 
	 fclose(f);
}


void Sym_Print(int type)
{
	 int i;
	 SYM_ENT *s;
	 RELOC_ENT *ent;
	 
	 for(i=0;i< 1001 ;i++) {
			s=hash_tab[i];
			while (s!= ((void *)0) ) {
				 if (s->sym_type==type) {
						if (type!= 0 )
							printf("%s: %d:0x%X @ ",s->name,s->seg,s->value);
						else
							printf("%s @ ",s->name);
						
						ent=s->reloc_first;
						while (ent!= ((void *)0) ) {
							 printf("%d:0x%X ",ent->seg,ent->offset);
							 ent=ent->next;
						}
						printf("\n");
				 }
				 s=s->hash_next;
			}
	 }
}

void Seg_Verbose(void)
{
	 int i;
	 
	 for(i=0;i< 2 ;i++) {
			printf("Segment %d: size=%d\n",i,seg_offset[i]);
	 }
	 printf("\nPrivate Symbols:\n");
	 Sym_Print(2 );
	 printf("\nExported Symbols:\n");
	 Sym_Print(1 );
	 printf("\nImported Symbols:\n");
	 Sym_Print(0 );
}


 	 
	 
void yyerror(char *format,...)
{
	 va_list ap;
	 
	 fprintf(stderr,"fbas: Error Line %d: ",lex_linenum);
	 
	  ap =(char *)&( format ); ;
	 vfprintf(stderr,format,ap);
	  ;
	 
	 fprintf(stderr,"\n");
	 exit(1);
}

void print_help(void)
{
	 printf("usage: fbas [-h] [-?] [-v] [-s stack_size] [-o exec_name]\n"
					"Assembler (version 1.00) (c) 1996 Fabrice Bellard\n"
					"(compiled for %s)\n"
					"\n","i386" 
					);
}

int main(int argc,char *argv[])
{
	 int c;
	 char obj_filename[256 ];
	 int verbose,stack_size;
	 
	 strcpy(obj_filename,"fba.out");
	 verbose=0;
	 stack_size=64 * 1024;
	 
	 while (1) {
			c=getopt(argc,argv,"h?vo:s:");
			if (c==-1) break;
			switch (c) {
			 case 'h':
			 case '?':
				 print_help();
				 exit(0);
				 break;
			 case 'o':
				 strcpy(obj_filename,optarg);
				 break;
			 case 'v':
				 verbose=1;
				 break;
			 case 's':
				 stack_size=atoi(optarg);
				 break;
			}
	 }

	 Seg_Init();
	 Hash_Init();
	 
	 lex_linenum=1;
	 yyparse();
	 
	 if (verbose) Seg_Verbose();
	 
	 Seg_ExecWrite(obj_filename,stack_size);

	 return 0;
}