示例#1
0
token scanner_get_str_bracket()
{
    WCHAR in_char, c;

    clear_buffer();
    if (m_file_in_ptr == 0) return TOKEN_EOF;
    if (src_eof()) return TOKEN_EOF;

    while (((in_char=src_getc())!=0)) {
        if (isspace(in_char))
            continue;
        else if (in_char == 0x0d)
            continue;            
        else if (in_char == 0x0a)
            continue;            
        else if (in_char != ']') {
            buffer_char(in_char);
            for (c=src_getc(); 
                c!=',' && c!='\t' && c!='\n' && c != ']'; 
                c=src_getc()) {
                if (c==0) break;
                buffer_char(c);
            }
            src_ungetc(c);
            return TOKEN_STRING;
        }    
    }
    
    return TOKEN_EOF;
}
示例#2
0
char lexer::next(bool buffer_next)
{
  char const current = _current_char;
  char result;

  if (current == '\n') {
    ++_next_line;
    _next_column = 1;
  } else if (current != '\0') {
    ++_next_column;
  }

  if (_next_char_cached) {
    _current_char = result = _next_char;
  } else {
    _current_char = _next_char = result = _feed();
  }
  _next_char_cached = result == '\0';

  if (result != '\0' && buffer_next) {
    buffer_char(result);
  }

  return result;
}
示例#3
0
void asignar_valor(char * valor,FILE * archivo){
	//Almacena el valor de la variable definida por el #define
	memset(valor, '\0', sizeof(valor));
	int no =0;
	palabras palabras=escaner(archivo);
	while (palabras==ESPACIO){
		palabras=escaner(archivo);
	}
	while (palabras==ANYWORD || palabras == PUNTUACTION){

	if (palabras==PUNTUACTION){
		if (strlen(token_buffer)==0){
			buffer_char(c);
			strcat(valor,token_buffer);
		}
		else{
			strcat(valor,token_buffer);
			clear_buffer();
			buffer_char(c);
			strcat(valor,token_buffer);
		}
	}

	if (palabras==ANYWORD)
	{
		strcat(valor,token_buffer);
	}
	if (isspace(c)){
		palabras=ESPACIO;
	}
	else{

	palabras=escaner(archivo);
	}
}
}
示例#4
0
token scanner_get_line_no_modify()
{
    WCHAR in_char, c;

    clear_buffer();
    if (m_file_in_ptr == 0) return TOKEN_EOF;
    if (src_eof()) return TOKEN_EOF;

    while (((in_char=src_getc())!=0)) {
        if (in_char == 0x0d)
            break;            
        else if (in_char == 0x0a)
            break;            
        else {
            buffer_char(in_char);
        }    
    }
    
    return TOKEN_STRING;
}
示例#5
0
/*returns next token from source file*/
token scanner()
{
	char c;
	
	clear_buffer();
	
	while(TRUE)
	{
		c = getc(fin);
		
		if(c == EOF)
			return SCANEOF;
		
		else if(isspace(c))
		{
			if (c == '\n')
				line_num = line_num + 1;
		}
		
		else if (isalpha(c))
		{
			buffer_char (c);
			c = getc (fin);
			while (isalnum(c) || c == '_')
			{
				buffer_char(c);
				c = getc(fin);
			}
			ungetc(c, fin);
			return check_reserved();
		}
		
		else if (isdigit(c))
		{
			buffer_char(c);
			c = getc(fin);
			while(isdigit(c))
			{
				buffer_char(c);
				c = getc(fin);
			}
			ungetc(c,fin);
			return INTLITERAL;
		}
		
		else if (c == '(')
			return LPAREN;
		
		else if (c == ')')
			return RPAREN;
		else if (c == '{')
			return LCURL;
		
		else if (c == '}')
			return RCURL;
		else if (c == ',')
			return COMMA;
			
		else if (c == ';')
			return SEMICOLON;
			
		else if (c == '+')
			return PLUSOP;
		else if (c == '-')
			return MINUSOP;
		else if (c == '*')
			return MULTOP;	
		else if (c == '/')
			{
				c = getc(fin);
				if(c == '/')
				{
					do
						c = getc(fin);
					while (c != '\n');
					line_num = line_num + 1;
				}
				else
				{
					ungetc(c, fin);
					return DIVOP;
				}
			}
		else if (c == '=')
			{
				c = getc(fin);
				if(c == '=')
				{
					return EQUALS;
				}
				else
				{
					ungetc(c, fin);
					lexical_error();
				}
			}
		else if (c == '!')
			{
				c = getc(fin);
				if(c == '=')
				{
					return NOTEQ;
				}
				else
				{
					ungetc(c, fin);
					lexical_error();
				}
			}
		else if (c == '<')
			{
				c = getc(fin);
				if(c == '=')
				{
					return LESSEQ;
				}
				else
				{
					ungetc(c, fin);
					return LESS;
				}
			}
		else if (c == '>')
			{
				c = getc(fin);
				if(c == '=')
				{
					return GREATEQ;
				}
				else
				{
					ungetc(c, fin);
					return GREATER;
				}
			}
		else if (c == ':')
		{
			c = getc(fin);
			if(c == '=')
				return ASSIGNOP;
			else
			{
				ungetc(c, fin);
				lexical_error();
			}
		}
		
		else
			lexical_error();
	}
}
token scanner(void)
{
	int in_char,c;

	clear_buffer();
	if (feof(archivo))
		return SCANEOF;

	while (feof(archivo)==0){
		in_char=fgetc(archivo);
		if (isspace(in_char))
			continue; /*do nothing */
		else if (isalpha(in_char)){
			/*
				ID::=LETTER | ID LETTER
							| ID DIGIT
							| ID UNDERSCORE
			*/
			buffer_char(in_char);
			for (c= fgetc(archivo);isalnum(c)||c=='-';c=fgetc(archivo))
				buffer_char(c);
				//ungetc(c,stdin);
				return check_reserved();

		}else if (isdigit(in_char)){
			/*
				INTLITERAL :: = DIGIT |
								INTLITERAL DIGIT
			*/
			buffer_char(in_char);
			for (c=fgetc(archivo);isdigit(c);c=fgetc(archivo))
				buffer_char(c);
			//ungetc(c,stdin);
			return INTLITERAL;
		}else if (in_char== '(')
			return LPAREN;
		else if (in_char==')')
			return RPAREN;
		else if (in_char==';')
			return SEMICOLON ;
		else if (in_char==',')
			return COMMA ;
		else if (in_char=='+')
			return  PLUSOP;
		else if (in_char==':'){
			/*looking for ":="*/
			c=fgetc(archivo);
			if (c=='=')
				return ASSIGNOP ;
			else{
				//ungetc(c,stdin);
				lexical_error(in_char);
			}		
		}
	
		else if (in_char=='-'){
			/*is it --;comment start */
			c=fgetc(archivo);
			if (c=='-'){
				do 
					in_char=fgetc(archivo);
				while (in_char!='\n');

			} else{
				//ungetc(c,stdin);
				return MINUSOP;
			}
		}else 
			lexical_error(in_char);
		}
}
示例#7
0
token scanner()
{
    WCHAR in_char, c;

    clear_buffer();
    if (m_file_in_ptr == 0) return TOKEN_EOF;
    if (src_eof()) return TOKEN_EOF;

    while (((in_char=src_getc())!=0)) {
        if (isspace(in_char))
            continue;
        else if (in_char == 0x0d)
            continue;            
        else if (in_char == 0x0a)
            continue;            
            
/*            
        else if (in_char=='"') {
            buffer_char(in_char);
            for (c=src_getc(in); c!='"' ; c=src_getc(in)) {
                buffer_char(c);
            }
            buffer_char(in_char);
            return String;
        }
*/                    
         else if (isalpha(in_char)) {
            buffer_char(in_char);
            for (c=src_getc(); 
                c!=' ' && c!=',' && c!=';' && c!=':' && c!='=' && c!='\t' && c!='\n'; 
                c=src_getc()) {
                if (c==0) break;
                buffer_char(c);
            }
            src_ungetc(c);
            return TOKEN_STRING;
        } else if (isdigit(in_char) || in_char=='-') {
            buffer_char(in_char);
            if (in_char == '0')
            {
                c=src_getc();
                if (c == 'x' || c == 'X')
                {
                    buffer_char(c);
                    for (c=src_getc(); ishex(c); c=src_getc()) {
                        if (c==0) break;            
                        buffer_char(c);
                    }
                    src_ungetc(c);                    
                    return TOKEN_NUMBER_LITERAL_HEX_FORMAT;
                }
                src_ungetc(c);
            }
            for (c=src_getc(); isdigit(c) || c=='.'; c=src_getc()) {
                if (c==0) break;            
                buffer_char(c);
            }
            src_ungetc(c);
            return TOKEN_NUMBER_LITERAL;
        }    
        else if (in_char==',')
            return TOKEN_COMMA;
        else if (in_char==';')
            return TOKEN_SEMICOLON;
        else if (in_char==':')
            return TOKEN_COLON;            
        else if (in_char=='=')
            return TOKEN_EQUAL;            
        else if (in_char=='\\')
            return TOKEN_CAT;            
        else if (in_char=='[')
            return TOKEN_LB;            
    }
    
    return TOKEN_EOF;
}
示例#8
0
palabras escaner(FILE * archivo){
	//Obtiene los tokens del texto


	clear_buffer();
	if (feof(archivo))
		return FIN;

	while (feof(archivo)==0){
		//Leemos del archivo
		in_char=fgetc(archivo);

		//Si el token es espacio lo ignoro
		if (isspace(in_char)){
			c=in_char;
			return ESPACIO;
		}

		if (in_char==47){
			in_char = fgetc(archivo);
			if (in_char==47){


			return COMMENT;
		}
			if (in_char=='*'){
				c=in_char;
				return BIG_COMMENT;
			}
			else{
				c=in_char;
				return NOT_COMMENT;
			}
		}

		//Si el token es un digito,minuscula,mayuscula o de puntuacion se agregan al buffer_char para imprimirlos
		else if (in_char==35){
			buffer_char(in_char);
			c=fgetc(archivo);
			while (c==32){
				c=fgetc(archivo);
			}
			buffer_char(c);
			for (c=fgetc(archivo);isalnum(c)||isspace(c)||isgraph(c);c=fgetc(archivo)){

					if (isspace(c)){
						return reservado();
					}
					
					buffer_char(c);
			}

		}
		else if (isgraph(in_char)){
			
			if (in_char >= 33 && in_char <=47 || in_char >= 58 && in_char <=64 || in_char >= 91 && in_char <=96 || in_char >= 123 && in_char <=126 ){
				c = in_char;
				return PUNTUACTION;
			}
			else{
				buffer_char(in_char);
			}


			for (c= fgetc(archivo);isalnum(c)||isspace(c)||isgraph(c);c=fgetc(archivo)){
				if (isspace(c)){
					return reservado();
				}

				if (c >= 33 && c <=47 || c >= 58 && c <=64 || c >= 91 && c <=96 || c >= 123 && c <=126 ){
				   //buffer_char(c);
				   return PUNTUACTION;
			}
				buffer_char(c);

				}
				return reservado();
			}




		}

	}
示例#9
0
void reconocedor(FILE * archivo,FILE * tmp){
	//Se encarga de obtener los nombres y valores definidos por el #define
	rewind(archivo);
	int _estaDefinido=0;
	char guardar[33];
	char guardar2[33];
	char *nombre[_totalDefine];
	char *valor[_totalDefine];
	int pos; 
	palabras palabras = escaner(archivo);
	int esta=0;

	while (palabras!=FIN){
	
		switch(palabras){
			case NOT_COMMENT:
				clear_buffer();
				buffer_char(c);
				fprintf(tmp,"/%s",token_buffer);
				break;
						

			case DEFINE:
				//No se pasa con el & debido a que la estructura ya es *guardar
				if (raro==1){
				memset(guardar2, '\0', sizeof(guardar2));
				escaner(archivo);
				pos= posicion(nombre);
				asignar_nombre(guardar,archivo);
				nombre[pos]=strdup(guardar);
				
				asignar_valor(guardar2,archivo);
				valor[pos]=strdup(guardar2);

				if (pos==cont){
					cont ++;
				}
				raro=0;
			}
			break;
	case ANYWORD:
				esta =0;
				int i=0;
				for (i<cont;i++;){
					if (strcmp(nombre[i],token_buffer)==0){
						fprintf(tmp, "%s",valor [i]);
						esta=1;
					}
				}
				if (esta==0){
					fprintf(tmp, "%s", token_buffer);
				}
				break;
					
			case PUNTUACTION:
				//signo_puntuacion=0;
			
				if (strlen(token_buffer)==0){
					buffer_char(c);
					fprintf(tmp,"%s",token_buffer);
					break;
				}
				else{
					_estaDefinido = 0;
		
				//Si no esta definido solo imprimo
				if (_estaDefinido == 0){
					fprintf(tmp,"%s",token_buffer);
					
				
					clear_buffer();
					buffer_char(c);
					fprintf(tmp,"%s", token_buffer);
					break;

				}
				break;
			}
	

			case ESPACIO:
				imprimir_espacios();
				break;
				default:
					break;
			
		
	}

	palabras = escaner(archivo);
	
	//Llamamos a cambiador para reescribir el texto por su respectivo valorr
}}
示例#10
0
void incluir_include(FILE * archivo){
	//Se encarga de leer el archivo de nuevo y asignar los valores almacenados segun el #define

	char fichero[33];
	memset(fichero, '\0', sizeof(fichero));
	int not_define=0;
	palabras palabras = escaner(archivo);
	int _estaDefinido=0;
	int signo_puntuacion = 0;

	while (palabras!=FIN){
		memset(fichero, '\0', sizeof(fichero));
		switch(palabras){
			case BIG_COMMENT:
				continuar=0;
				eliminar_comentarios_grandes(archivo);
				break;
			case DEFINE:
				if (raro==1){
				asignar_valor(fichero,archivo);
				
				fprintf(tmp,"#define %s ",fichero);


				asignar_valor(fichero,archivo);
				
				fprintf(tmp,"  %s \n",fichero);
				raro=0;
			}
				break;
			case INCLUDE:
						
				palabras = escaner(archivo);
				int continuar =0;
				if (c==34){
					
					palabras=escaner(archivo);
					while (continuar==0){


						adjuntar(fichero);
						if (c==46){
							clear_buffer();
							buffer_char(c);
							adjuntar(fichero);
						}
						palabras=escaner(archivo);
						if (c==34){
							adjuntar(fichero);
							continuar=1;
						}
						
						
					}
					
					FILE * x = fopen(fichero,"r+");

					incluir_include (x);
					break;


				}
					if (c==60){
					while (continuar==0){
						adjuntar(fichero);
						if (c==46){
							clear_buffer();
							buffer_char(c);
							adjuntar(fichero);
						}
						palabras=escaner(archivo);
						if (c==62){
							adjuntar(fichero);
							continuar=1;
						}

						

						
					}
					//fprintf(tmp,"#include <%s> \n",fichero);
				}
				break;
				
			case ANYWORD:
					fprintf(tmp,"%s",token_buffer);
					imprimir_espacios();
					break;
					
				break;
			case PUNTUACTION:
				signo_puntuacion=0;
				if (strlen(token_buffer)==0){
					buffer_char(c);
					fprintf(tmp,"%s",token_buffer);
					break;
				}
				else{
					_estaDefinido = 0;
		
				//Si no esta definido solo imprimo
				if (_estaDefinido == 0){
					fprintf(tmp,"%s",token_buffer);
					
				
					clear_buffer();
					buffer_char(c);
					fprintf(tmp,"%s", token_buffer);
					break;

				}

			case ESPACIO:
				imprimir_espacios();

				default:
					break;

		}
			case COMMENT:
				eliminar_comentarios(archivo);
				break;
			case NOT_COMMENT:
				
				clear_buffer();
				buffer_char(c);
				fprintf(tmp,"%s","/");
				break;


		imprimir_espacios();
			
				
}
		
				
		palabras=escaner(archivo);
	
}


}