elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Usando Git para manipular el directorio de trabajo, el índice y commits (segunda parte)


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 [7] 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 ... 40
61  Programación / Java / analizador sintactico en: 9 Julio 2014, 04:52 am
Saludos

Tengo el siguiente codigo que es un analizador lexicografico al cual le pido al usuario que le ingrese un token, para despues imprimir si se trata de un identificador, palabra reservada, etc..
El codigo funciona bien, el problema es que ahora tengo que hacer el analizador sintactico para lo cual he estado investigando en varios sitios, pero no se si debo hacer un automata de pila o un arbol sintactico, no se bien cual seria el siguiente paso a seguir

Código
  1. import java.util.Scanner;
  2.  
  3. class AnalizadorLexico {
  4. 	Estados estadoActual;
  5.  
  6.     private enum Estados {
  7.     	 q00, q01, q02, q03, q04, q05, q06, q07, q08, q09, q10,
  8.          q11, q12, q13, q14, q15, q16, q17, q18, q19, q20, q21, q22
  9. 	}
  10.  
  11.     private boolean palabraReservada(String token) {
  12.     	int i;
  13.     	String reservadas[] = {"abstract","assert","boolean","break","byte","case","catch","char","class","const",
  14.         "continue","default","do","double","else","enum","extends","final","finally","float","for","goto","if",
  15.         "implements","import","instanceof","int","interface","long","native","new","package","private","protected",
  16.     	"public","return","short","static","super","switch","new","package","private","protected","synchronized","this",
  17.     	"throw","throws","transient","try","void","volatile","while"};
  18.  
  19.     	for(i = 0;i < reservadas.length;i++) {
  20.         	if(reservadas[i].equals(token)) 
  21.                return true;
  22.         }
  23.     	return false;
  24.     }
  25.  
  26.     private boolean esIdentificador(String token) {
  27.     	int estadoSiguiente;
  28.     	char arregloToken[] = token.toCharArray();
  29.     	estadoActual = Estados.q00;
  30.     	for(int i = 0;i < arregloToken.length;i++){
  31.     		if(esLetra(arregloToken[i]))
  32.     		   estadoSiguiente = 0;
  33.     		else if(esDigito(arregloToken[i]))
  34.     		   estadoSiguiente = 1;
  35.     		else
  36.     		   estadoSiguiente = 2;
  37.     		estadoActual = matrizTransicion(estadoActual,estadoSiguiente);
  38.     	}
  39.     	if(estadoActual.equals(Estados.q01))
  40.     	   return true;
  41.     	else
  42.     	   return false;
  43.     }
  44.  
  45.     private boolean esDecimalEntero(String token){
  46.     	int estadoSiguiente;
  47.     	char arregloToken[] = token.toCharArray();
  48.     	estadoActual = Estados.q00;
  49.     	for(int i = 0;i < arregloToken.length;i++){
  50.     		if(esDigito(arregloToken[i]))
  51.     		   estadoSiguiente = 0;
  52.     		else
  53.     		   estadoSiguiente = 1;
  54.     		estadoActual = matrizTransicion2(estadoActual,estadoSiguiente);
  55.     	}
  56.     	if(estadoActual.equals(Estados.q01))
  57.     	   return true;
  58.     	else
  59.     	   return false;
  60.     }
  61.  
  62.     private boolean esDecimalReal(String token){
  63.     	int estadoSiguiente;
  64.     	char arregloToken[] = token.toCharArray();
  65.     	estadoActual = Estados.q00;
  66.     	for(int i = 0;i < arregloToken.length;i++){
  67.     		if(esDigito(arregloToken[i]))
  68.     		   estadoSiguiente = 0;
  69.     		else if(arregloToken[i] == '.')
  70.     		   estadoSiguiente = 1;
  71.     		else
  72.     		   estadoSiguiente = 2;
  73.     		estadoActual = matrizTransicion3(estadoActual,estadoSiguiente);
  74.     	}
  75.     	if(estadoActual.equals(Estados.q03))
  76.     	   return true;
  77.     	else
  78.     	   return false;
  79.     }
  80.  
  81.     public Estados matrizTransicion(Estados estadoActual,int estadoSiguiente){
  82.     	int estado;
  83.     	Estados posicion,matriz[][] = {{Estados.q01,Estados.q02,Estados.q02},
  84.     			                       {Estados.q01,Estados.q01,Estados.q02},
  85.     			                       {Estados.q02,Estados.q02,Estados.q02}};
  86.     	estado = estadoActual.ordinal();
  87.     	posicion = matriz[estado][estadoSiguiente];
  88.     	return posicion;
  89.     }
  90.  
  91.     public Estados matrizTransicion2(Estados estadoActual,int estadoSiguiente){
  92.     	int estado;
  93.     	Estados posicion,matriz[][] = {{Estados.q01,Estados.q02},
  94.                                        {Estados.q01,Estados.q02},
  95.                                        {Estados.q02,Estados.q02}};
  96.     	estado = estadoActual.ordinal();
  97.     	posicion = matriz[estado][estadoSiguiente];
  98.     	return posicion;
  99.     }
  100.  
  101.     public Estados matrizTransicion3(Estados estadoActual,int estadoSiguiente){
  102.     	int estado;
  103.     	Estados posicion,matriz[][] = {{Estados.q01,Estados.q05,Estados.q04},
  104.     								   {Estados.q01,Estados.q02,Estados.q04},
  105.     								   {Estados.q03,Estados.q04,Estados.q04},
  106.     								   {Estados.q03,Estados.q04,Estados.q04},
  107.     								   {Estados.q04,Estados.q04,Estados.q04},
  108.     								   {Estados.q03,Estados.q04,Estados.q04}};
  109.     	estado = estadoActual.ordinal();
  110.     	posicion = matriz[estado][estadoSiguiente];
  111.     	return posicion;
  112.     }
  113.  
  114.     public boolean esLetra(char caracter) {
  115.     	if((caracter >= 'A' && caracter <= 'Z')||(caracter >= 'a' && caracter <= 'z'))
  116.     	   return true;
  117.     	else
  118.     	   return false;
  119.     }
  120.  
  121.     public boolean esDigito(char caracter) {
  122.     	if((caracter >= '0' && caracter <= '9'))
  123.     	   return true;
  124.     	else
  125.     	   return false;
  126.     }
  127.  
  128.     public void AutomataFinitoDeterminista(String token) {
  129.     	if(palabraReservada(token))
  130.     	   System.out.println("El token " + token + " es una palabra reservada");
  131.     	else if(esDecimalEntero(token))
  132.      	   System.out.println("El token " + token + " es un numero decimal entero");
  133.     	else if(esIdentificador(token))
  134.     	   System.out.println("El token " + token + " es un identificador");
  135.     	else if(esDecimalReal(token))
  136.     	   System.out.println("El token " + token + " es un numero decimal real");
  137.     }
  138. }
  139.  
  140. public class AutomataFinito {
  141.  
  142. 	public static void main(String[] args) {
  143. 		String token;
  144. 		char otroToken;
  145. 		AnalizadorLexico analizador = new AnalizadorLexico();
  146. 		Scanner teclado = new Scanner(System.in);
  147. 		do
  148. 		{
  149. 			System.out.print("Dame el token: ");
  150. 			token = teclado.nextLine();
  151. 			analizador.AutomataFinitoDeterminista(token);
  152. 			System.out.print("Desea ingresar otro token?(S/N) ");
  153. 			otroToken = teclado.nextLine().charAt(0);
  154. 		}while(otroToken == 'S' || otroToken == 's');
  155. 		teclado.close();
  156. 	}
  157. }

gracias
62  Programación / Java / Exceptions en: 27 Junio 2014, 19:57 pm
Saludos

tengo el siguiente codigo :

Código
  1. import java.io.File;
  2. import java.io.IOException;
  3. import java.util.Scanner;
  4. import java.io.RandomAccessFile;
  5.  
  6. public class Token {
  7.  
  8. 	public static void main(String[] args) {
  9. 		int car;
  10. 		String nombre,componenteLexico;
  11. 		Scanner teclado = new Scanner(System.in);
  12. 		System.out.print("Dame el nombre del archivo: ");
  13. 		nombre = teclado.nextLine();
  14. 		teclado.close();
  15. 		try
  16. 		{
  17. 			File archivo = new File(nombre);
  18. 			RandomAccessFile r = new RandomAccessFile(archivo,"r");
  19. 			while((car = r.read()) != -1)
  20. 			{
  21. 				componenteLexico = Token.leerArchivo(nombre,r);
  22. 				System.out.print(" "+componenteLexico);
  23. 			}
  24. 			r.close();
  25. 		}
  26. 		catch(IOException ex)
  27. 		{
  28. 			System.out.println("No se pudo abrir archivo");
  29. 		}
  30.  
  31. 	}
  32.  
  33. 	public static String leerArchivo(String nombre,RandomAccessFile r)
  34. 	{
  35. 		int car;
  36. 		char c;
  37. 		long posicion;
  38. 		String cadena = null;
  39. 		StringBuilder sb = new StringBuilder();
  40. 		try
  41. 		{
  42. 			posicion = r.getFilePointer();
  43. 			r.seek(posicion-1);
  44. 		    while((car = r.read()) != ' ')
  45. 		    {
  46. 		    	c = (char)car;
  47. 		        sb.append(c);
  48. 		    }
  49. 		    cadena = sb.toString();
  50. 		}
  51. 		catch(IOException ex)
  52. 		{
  53. 			System.out.println("No se pudo abrir archivo");
  54. 		}
  55. 		return cadena;
  56. 	}
  57. }
  58.  

lo que hace es leer un archivo e ir guardando e imprimiendo cada una de las palabras que contiene este archivo, el problema es que me arroja una excepcion que dice:

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

creo que tiene que ver con que estoy usando mal la clase StringBuilder, pero soy principiante y todavia no se manejar bien las excepciones.

gracias
63  Programación / Java / analizador lexicografico en: 24 Junio 2014, 19:47 pm
Saludos

Quiero empezar a codificar un analizador lexicografico, pero no me queda claro algunos de los pasos que tengo que seguir, lo primero que se hace es leer un archivo de caracteres y dividirlos en tokens o palabras reservadas. por ejemplo si tengo c = 4+2; pues c es un identificador,= es un signo de asignación y así sucesivamente. Pero  en las páginas donde estaba buscando información me dice que tengo que hacer un automata finito deterministico, y hacer las expresiones regulares, pero esto ultimo me tiene confundido,¿Cómo se programan las expresiones regulares? el automata que es lo que hace? identifica si es identificador,operando??

gracias
64  Programación / Java / Re: leer archivo en: 23 Junio 2014, 20:36 pm
muchas gracias por sus respuestas, ahora el codigo funciona bien. Una última duda. cómo puedo verificar que la versión de compilación que uso es igual o mayor a 5??? estoy usando eclipse
65  Programación / Java / leer archivo en: 23 Junio 2014, 00:10 am
Saludos

Estoy aprendiendo los conceptos básicos de java, y he estado haciendo pequeños codigos como este que lo que hace es que le pide al usuario el nombre de un archivo que debe abrir y que una vez que este abierto debe leer caracter por caracter e imprimirlo

Código
  1. import java.io.File;
  2. import java.io.FileReader;
  3. import java.io.FileNotFoundException;
  4. import java.util.Scanner;
  5.  
  6. public class Token {
  7.  
  8. 	public static void main(String[] args) {
  9. 		String nombre;
  10. 		Scanner teclado = new Scanner(System.in);
  11. 		System.out.print("Dame el nombre del archivo: ");
  12. 		nombre = teclado.nextLine();
  13. 		teclado.close();
  14. 		leerArchivo(nombre);
  15. 	}
  16.  
  17. 	public static void leerArchivo(String nombre)
  18. 	{
  19. 		try
  20. 		{
  21. 			int car;
  22. 		    File archivo = new File(nombre);
  23. 		    FileReader fr = new FileReader(archivo);
  24. 		    while((car = fr.read()) != -1)
  25. 		       System.out.printf("%d",car);
  26. 		}
  27. 		catch(FileNotFoundException fileNotFoundException)
  28. 		{
  29. 			System.out.println("No se pudo abrir archivo");
  30. 		}
  31. 	}
  32.  
  33. }
  34.  
el problema es que me aparece un error en la linea que me tiene que imprimir los caracteres del archivo y no se por qué, me dice:

The method printf(String,Object[])in the type printStream is not applicable for the arguments (String, int),como puedo resolverlo??

gracias
66  Foros Generales / Dudas Generales / expresiones regulares en: 22 Junio 2014, 18:34 pm
Saludos

tengo la siguiente expresión regular que dice:  (a/b)*abb y me dice que las cadenas que me genera son {abb,aabb,babb,ababb,baabb,aaabb,...}, entiendo que todas las cadenas van a contener la subcadena abb, pero no entiendo como se obtiene la operación (a/b)*

gracias
67  Programación / Programación C/C++ / Re: problema con cadena en: 12 Junio 2014, 22:16 pm
gracias eferion, voy a tratar de quitarme todos esos vicios de programación que tengo. El codigo_datos no siempre va a ser de tamaño 33, sino que su máximo tamaño es 33(o 16 bytes). Y si por ejemplo declaro char cadena_datos[33], para asignarle una cadena como "2300", le pongo cadena_datos = "2300"???? y cuando tenga que inicializar el arreglo a 0(o sea que no contenga nada dentro) como le hago si quiero pasar el codigo_datos a la función inicializarVariables??

Código
  1. // codigo_datos esta declarado como char codigo_datos[33];
  2. void inicializarVariables(int *longitud_del_codigo,int *bytesDisponibles,char *codigo_datos)
  3. {
  4.     *longitud_del_codigo = 0;
  5.     *bytesDisponibles = 16;
  6.     *codigo_datos = 0; asii seria???
  7. }

y con un arreglo cadena_datos[33] también puedo usar el strcat??? para ir concatenando los códigos máquina que se me generen.
68  Programación / Programación C/C++ / Re: problema con cadena en: 12 Junio 2014, 01:19 am
muchas gracias eferion por tu respuesta, ahora ya hice 2 nuevas funciones, una que me calcule la nuevaDireccion que me va a imprimir en el archivo, las nuevas direcciones se calculan en caso de que la haya alcanzado la maxima longitud de la variable codigo_datos(que es 16 bytes, osea 32 caracteres).

No se si disminuí mucho el tamaño de la función, pero fue lo maximo que lo pude reducir.

Código
  1. void leerTEMPORAL(COD *cabeza,TABSIM **t,char *archivo)
  2. {
  3.     int car,indice,longitud_del_codigo = 0,longitud = 3,bytesDisponibles = 16,disponibles = 16;
  4.     FILE *tmp;
  5.     DIV division,*codMaquina;
  6.     COD *seEncontro = NULL;
  7.     char *TIPO,*VALOR,*ETIQUETA,*CODOP,*OPERANDO,*COD_MAQUINA;
  8.     char *tipo = "S1",*Longitud,*direccion,*codigo_datos,*checksum;
  9.     codigo_datos = (char*)calloc(33,sizeof(char));
  10.     if((tmp = fopen("TEMPORAL.txt","r")) != NULL)
  11.     {
  12.         while((car = fgetc(tmp)) != EOF)
  13.         {
  14.             TIPO = Etiqueta_Codop_Operando(tmp,TIPO_);
  15.             ignorarEspacios(tmp);
  16.             VALOR = Etiqueta_Codop_Operando(tmp,VALOR_);
  17.             ignorarEspacios(tmp);
  18.             ETIQUETA = Etiqueta_Codop_Operando(tmp,ETIQUETA_);
  19.             ignorarEspacios(tmp);
  20.             CODOP = Etiqueta_Codop_Operando(tmp,CODOP_);
  21.             ignorarEspacios(tmp);
  22.             OPERANDO = Etiqueta_Codop_Operando(tmp,OPERANDO_);
  23.             if((seEncontro = buscarCodop(cabeza,CODOP)) != NULL)
  24.             {
  25.                 if(!verificarOperando(seEncontro,OPERANDO))
  26.                 {
  27.                     indice = obtenerIndiceDireccionamiento(seEncontro,OPERANDO);
  28.                     COD_MAQUINA = calcularCodigo_Maquina(seEncontro,indice,VALOR,ETIQUETA,CODOP,OPERANDO,t);
  29.                     longitudValida(COD_MAQUINA,&longitud_del_codigo);
  30.                     if(agregarCodigo_Maquina(longitud_del_codigo))
  31.                     {
  32.                         if(disponibles == 16)
  33.                            direccion = VALOR;
  34.                         strcat(codigo_datos,COD_MAQUINA);
  35.                         disponibles = bytesDisponibles-longitud_del_codigo;
  36.                     }
  37.                     else
  38.                     {
  39.                         if(disponibles != 0)
  40.                         {
  41.                             codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
  42.                             strcat(codigo_datos,codMaquina->bytesRequeridos);
  43.                             disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
  44.                             Longitud = calcularLongitudS1(longitud,codigo_datos);
  45.                             checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  46.                             crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  47.                             direccion = nuevaDireccion(codMaquina,VALOR);
  48.                             inicializarVariables(&longitud_del_codigo,&bytesDisponibles);
  49.                             longitudValida(COD_MAQUINA,&longitud_del_codigo);
  50.                             if(agregarCodigo_Maquina(longitud_del_codigo))
  51.                             {
  52.                                 *codigo_datos = 0;
  53.                                 strcpy(codigo_datos,codMaquina->bytesPendientes);
  54.                                 disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
  55.                             }
  56.                         }
  57.                         else
  58.                         {
  59.                             Longitud = calcularLongitudS1(longitud,codigo_datos);
  60.                             checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  61.                             crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  62.                             inicializarVariables(&longitud_del_codigo,&disponibles);
  63.                             direccion = VALOR;
  64.                             *codigo_datos = 0;
  65.                             longitudValida(COD_MAQUINA,&longitud_del_codigo);
  66.                             if(agregarCodigo_Maquina(longitud_del_codigo))
  67.                             {
  68.                                 strcpy(codigo_datos,COD_MAQUINA);
  69.                                 disponibles = bytesDisponibles-longitud_del_codigo;
  70.                             }
  71.                         }
  72.                     }
  73.                 }
  74.             }
  75.             else if(esDirectivaCONSTANTES_1byte(CODOP)||esDirectivaCONSTANTES_2byte(CODOP)||esDirectivaCARACTERES(CODOP))
  76.             {
  77.                 COD_MAQUINA = codigoMaquina_Directivas(VALOR,ETIQUETA,CODOP,OPERANDO);
  78.                 longitudValida(COD_MAQUINA,&longitud_del_codigo);
  79.                 if(agregarCodigo_Maquina(longitud_del_codigo))
  80.                 {
  81.                     if(disponibles == 16)
  82.                        direccion = VALOR;
  83.                     strcat(codigo_datos,COD_MAQUINA);
  84.                     disponibles = bytesDisponibles-longitud_del_codigo;
  85.                 }
  86.                 else
  87.                 {
  88.                     if(disponibles != 0)
  89.                     {
  90.                         codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
  91.                         strcat(codigo_datos,codMaquina->bytesRequeridos);
  92.                         disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
  93.                         Longitud = calcularLongitudS1(longitud,codigo_datos);
  94.                         checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  95.                         crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  96.                         direccion = nuevaDireccion(codMaquina,VALOR);
  97.                         inicializarVariables(&longitud_del_codigo,&bytesDisponibles);
  98.                         *codigo_datos = 0;
  99.                         longitudValida(COD_MAQUINA,&longitud_del_codigo);
  100.                         if(agregarCodigo_Maquina(longitud_del_codigo))
  101.                         {
  102.                             strcpy(codigo_datos,codMaquina->bytesPendientes);
  103.                             disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
  104.                         }
  105.                     }
  106.                     else
  107.                     {
  108.                         Longitud = calcularLongitudS1(longitud,codigo_datos);
  109.                         checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  110.                         crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  111.                         inicializarVariables(&longitud_del_codigo,&bytesDisponibles);
  112.                         direccion = VALOR;
  113.                         longitudValida(COD_MAQUINA,&longitud_del_codigo);
  114.                         if(agregarCodigo_Maquina(longitud_del_codigo))
  115.                         {
  116.                             strcpy(codigo_datos,COD_MAQUINA);
  117.                             disponibles = bytesDisponibles-longitud_del_codigo;
  118.                         }
  119.                     }
  120.                 }
  121.             }
  122.             else if(esDirectivaRESERVA_MEMORIA1byte(CODOP)||esDirectivaRESERVA_MEMORIA2byte(CODOP))
  123.             {
  124.                 printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  125.                 if(codigo_datos[CERO] != '\0')
  126.                 {
  127.                     Longitud = calcularLongitudS1(longitud,codigo_datos);
  128.                     checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  129.                     crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  130.                     inicializarVariables(&longitud_del_codigo,&disponibles);
  131.                     *codigo_datos = 0;
  132.                 }
  133.             }
  134.             else
  135.             {
  136.                 if((strcmp(CODOP,"ORG")) == 0)
  137.                 {
  138.                     printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  139.                     calcularS0(archivo);
  140.                 }
  141.                 else if((strcmp(CODOP,"END")) == 0)
  142.                 {
  143.                     if(codigo_datos[CERO] != '\0')
  144.                     {
  145.                         Longitud = calcularLongitudS1(longitud,codigo_datos);
  146.                         checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  147.                         crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  148.                     }
  149.                     printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  150.                     crearArchivoS9();
  151.                 }
  152.                 else if((strcmp(CODOP,"EQU")) == 0)
  153.                    printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  154.                 else
  155.                 {
  156.                     printf("%s   %s   %s   %s\t",VALOR,ETIQUETA,CODOP,OPERANDO);
  157.                     printf("NO SE ENCONTRO EL CODOP DE OPERANDO\n");
  158.                 }
  159.             }
  160.         }
  161.     }
  162.     else
  163.        printf("No se pudo abrir archivo\n");
  164. }

y las funciones que recien hice son estas:

Código
  1. void inicializarVariables(int *longitud_del_codigo,int *bytesDisponibles)
  2. {
  3.     *longitud_del_codigo = 0;
  4.     *bytesDisponibles = 16;
  5. }
  6.  
  7. char *nuevaDireccion(DIV *codMaquina,char *VALOR)
  8. {
  9.     int suma,bytesAgregados,direccionActual,x = 0,base = 16;
  10.     char *direccion;
  11.     direccion = (char*)calloc(5,sizeof(char));
  12.     bytesAgregados = strlen(codMaquina->bytesRequeridos)/2;
  13.     direccionActual = obtenerNumero(VALOR,x,base);
  14.     suma = direccionActual+bytesAgregados;
  15.     sprintf(direccion,"%04X",suma);
  16.     return direccion;
  17. }

el codigo sigue teniendo ese pequeño error en la linea donde esta Dc.b que su codigo máquina no me lo concatena al registroS1, ahorita ya no me truena pero quiero quitarle todas las fallas posibles para asi cuando me lo revisen no tenga errores ni nada.

gracias
69  Programación / Programación C/C++ / problema con cadena en: 11 Junio 2014, 21:58 pm
Saludos tengo el siguiente archivo:

Citar
    0001.....Pri........equ.....1
    0002.....Seg......equ.....2
    0003.....Ter......equ.....3
    0004.....Cua.....equ.....4
    00FF.....null.....ORG.....255
    00FF......Et.......Ds.b.....5
    0000......Otra...equ......0
    0104......null....Swi......null......3F
    0105......null....Ds.W....5
    0005......Qui....equ.......5
    010F......null....Swi.......null......3F
    0006.......Sex...equ.......6
    0110......Sep...Swi.......null.......3F
    0008......Oct....equ......8
    0111......null....Ldaa....3...........9603
    0113......null....Ldaa....Sep.......B60110
    0116......null....Ds.b....3
    0119......null....Ldaa....3..........9603
    0009......Nov....equ.....9
    011B.....null....Swi.....Null.......3F
    011C......null....Dc.b....2.........02
    000B......Dec....Equ.....11
    null....End.....null

Aqui 3F,9603,B60110 son códigos máquina, pero las directivas Equ,End, Org y Ds.b(directiva de reserva de memoria) no van a generar codigo. Con este archivo yo tengo que generar un archivo en el que se impriman unos registros así:

S0....
S1+04+0104+3F-> aqui se agrega la direccion (0104) y despues el codigo maquina 3F, y ahi paramos porque despues de 3F hay un Ds.W, y este nos indica que se tiene que concluir e imprimir en el archivo como está..

la segunda linea seria:

S1+0A+010F+[3F][3F][9603][B60110] y como despues esta Ds.b también ahi paramos

la ultima linea seria :

S1+07+0119+[9603][3F][02]  y como despues tenemos puros equ's que no generan codigo máquina y al ultimo el END, entonces ahi paramos

esta es la linea donde tengo problemas porque me la imprime asi:

S1+06+0119+[9603][3F] y ya!! le falta el 02 y no entiendo por que no concatena este ultimo, el codigo es el siguiente:

Código
  1. void leerTEMPORAL(COD *cabeza,TABSIM **t,char *archivo)
  2. {
  3.     int car,indice,longitud_del_codigo = 0,longitud = 3,bytesDisponibles = 16,disponibles = 16,x = 0,base = 16;
  4.     int direccionActual,bytesSumados;
  5.     FILE *tmp;
  6.     DIV division,*codMaquina;
  7.     COD *seEncontro = NULL;
  8.     char *TIPO,*VALOR,*ETIQUETA,*CODOP,*OPERANDO,*COD_MAQUINA;
  9.     char *tipo = "S1",*Longitud,*direccion,*codigo_datos,*checksum,*nuevaDireccion;
  10.     codigo_datos = (char*)calloc(33,sizeof(char));
  11.     if((tmp = fopen("TEMPORAL.txt","r")) != NULL)
  12.     {
  13.         while((car = fgetc(tmp)) != EOF)
  14.         {
  15.             TIPO = Etiqueta_Codop_Operando(tmp,TIPO_);
  16.             ignorarEspacios(tmp);
  17.             VALOR = Etiqueta_Codop_Operando(tmp,VALOR_);
  18.             ignorarEspacios(tmp);
  19.             ETIQUETA = Etiqueta_Codop_Operando(tmp,ETIQUETA_);
  20.             ignorarEspacios(tmp);
  21.             CODOP = Etiqueta_Codop_Operando(tmp,CODOP_);
  22.             ignorarEspacios(tmp);
  23.             OPERANDO = Etiqueta_Codop_Operando(tmp,OPERANDO_);
  24.             if((seEncontro = buscarCodop(cabeza,CODOP)) != NULL)
  25.             {
  26.                 if(!verificarOperando(seEncontro,OPERANDO))
  27.                 {
  28.                     indice = obtenerIndiceDireccionamiento(seEncontro,OPERANDO);
  29.                     COD_MAQUINA = calcularCodigo_Maquina(seEncontro,indice,VALOR,ETIQUETA,CODOP,OPERANDO,t);
  30.                     longitudValida(COD_MAQUINA,&longitud_del_codigo);
  31.                     if(agregarCodigo_Maquina(longitud_del_codigo))
  32.                     {
  33.                         if(disponibles == 16)
  34.                            direccion = VALOR;
  35.                         strcat(codigo_datos,COD_MAQUINA);
  36.                         disponibles = bytesDisponibles-longitud_del_codigo;
  37.                     }
  38.                     else
  39.                     {
  40.                         if(disponibles != 0)
  41.                         {
  42.                             if(disponibles == 16)
  43.                                direccion = VALOR;
  44.                             codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
  45.                             strcat(codigo_datos,codMaquina->bytesRequeridos);
  46.                             disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
  47.                             Longitud = calcularLongitudS1(longitud,codigo_datos);
  48.                             //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  49.                             crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  50.                             direccionActual = obtenerNumero(VALOR,x,base);
  51.                             bytesSumados = obtenerNumero(codMaquina->bytesPendientes,x,base);
  52.                             longitud_del_codigo = 0;
  53.                             bytesDisponibles = 16;
  54.                             longitudValida(COD_MAQUINA,&longitud_del_codigo);
  55.                             if(agregarCodigo_Maquina(longitud_del_codigo))
  56.                             {
  57.                                 strcpy(codigo_datos,codMaquina->bytesPendientes);
  58.                                 disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
  59.                             }
  60.                         }
  61.                         else
  62.                         {
  63.                             Longitud = calcularLongitudS1(longitud,codigo_datos);
  64.                             //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  65.                             crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  66.                             longitud_del_codigo = 0;
  67.                             disponibles = 16;
  68.                             direccion = VALOR;
  69.                             *codigo_datos = 0;
  70.                             longitudValida(COD_MAQUINA,&longitud_del_codigo);
  71.                             if(agregarCodigo_Maquina(longitud_del_codigo))
  72.                             {
  73.                                 strcpy(codigo_datos,COD_MAQUINA);
  74.                                 disponibles = bytesDisponibles-longitud_del_codigo;
  75.                             }
  76.                         }
  77.                     }
  78.                 }
  79.             }
  80.             else if(esDirectivaCONSTANTES_1byte(CODOP)||esDirectivaCONSTANTES_2byte(CODOP)||esDirectivaCARACTERES(CODOP))
  81.             {
  82.                 COD_MAQUINA = codigoMaquina_Directivas(VALOR,ETIQUETA,CODOP,OPERANDO);
  83.                 longitudValida(COD_MAQUINA,&longitud_del_codigo);
  84.                 if(agregarCodigo_Maquina(longitud_del_codigo))
  85.                 {
  86.                     if(disponibles == 16)
  87.                        direccion = VALOR;
  88.                     strcat(codigo_datos,COD_MAQUINA);
  89.                     disponibles = bytesDisponibles-longitud_del_codigo;
  90.                 }
  91.                 else
  92.                 {
  93.                     if(disponibles != 0)
  94.                     {
  95.                         if(disponibles == 16)
  96.                            direccion = VALOR;
  97.                         codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
  98.                         strcat(codigo_datos,codMaquina->bytesRequeridos);
  99.                         disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
  100.                         Longitud = calcularLongitudS1(longitud,codigo_datos);
  101.                         //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  102.                         crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  103.                         direccionActual = obtenerNumero(VALOR,x,base);
  104.                         bytesSumados = strlen(codMaquina->bytesRequeridos)/2;
  105.                         nuevaDireccion = calcularDireccion(direccionActual,bytesSumados);
  106.                         direccion = nuevaDireccion;
  107.                         longitud_del_codigo = 0;
  108.                         bytesDisponibles = 16;
  109.                         *codigo_datos = 0;
  110.                         longitudValida(COD_MAQUINA,&longitud_del_codigo);
  111.                         if(agregarCodigo_Maquina(longitud_del_codigo))
  112.                         {
  113.                             strcpy(codigo_datos,codMaquina->bytesPendientes);
  114.                             disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
  115.                         }
  116.                     }
  117.                     else
  118.                     {
  119.                         Longitud = calcularLongitudS1(longitud,codigo_datos);
  120.                         //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  121.                         crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  122.                         longitud_del_codigo = 0;
  123.                         direccion = VALOR;
  124.                         longitudValida(COD_MAQUINA,&longitud_del_codigo);
  125.                         if(agregarCodigo_Maquina(longitud_del_codigo))
  126.                         {
  127.                             strcpy(codigo_datos,COD_MAQUINA);
  128.                             disponibles = bytesDisponibles-longitud_del_codigo;
  129.                         }
  130.                     }
  131.                 }
  132.             }
  133.             else if(esDirectivaRESERVA_MEMORIA1byte(CODOP)||esDirectivaRESERVA_MEMORIA2byte(CODOP))
  134.             {
  135.                 printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  136.                 if(codigo_datos[CERO] != '\0')
  137.                 {
  138.                     Longitud = calcularLongitudS1(longitud,codigo_datos);
  139.                     //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  140.                     crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  141.                     longitud_del_codigo = 0;
  142.                     disponibles = 16;
  143.                     *codigo_datos = 0;
  144.                 }
  145.             }
  146.             else
  147.             {
  148.                 if((strcmp(CODOP,"ORG")) == 0)
  149.                 {
  150.                     printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  151.                     calcularS0(archivo);
  152.                 }
  153.                 else if((strcmp(CODOP,"END")) == 0)
  154.                 {
  155.                     if(codigo_datos[CERO] != '\0')
  156.                     {
  157.                         Longitud = calcularLongitudS1(longitud,codigo_datos);
  158.                         //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
  159.                         crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
  160.                     }
  161.                     printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  162.                     crearArchivoS9();
  163.                 }
  164.                 else if((strcmp(CODOP,"EQU")) == 0)
  165.                    printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
  166.                 else
  167.                 {
  168.                     printf("%s   %s   %s   %s\t",VALOR,ETIQUETA,CODOP,OPERANDO);
  169.                     printf("NO SE ENCONTRO EL CODOP DE OPERANDO\n");
  170.                 }
  171.             }
  172.         }
  173.     }
  174.     else
  175.        printf("No se pudo abrir archivo\n");
  176. }

la longitud del campo donde se concatenan los codigos maquinas debe ser maximo 32, por eso tengo la función que me dice si el codigo se puede agregar o no, y en caso de que no se pueda hago un nuevo registro. El codigo si funciona lo probe varias veces pero en la ultima me trono y creo que puede ser por la manera en la que le estoy asignando memoria a cadena_datos(donde concateno los codigos)

gracias de antemano
70  Programación / Programación C/C++ / Re: bug en mi codigo en: 11 Junio 2014, 19:19 pm
muchas gracias por sus respuestas, si el  número de caracteres de la cadena tiene que ser a fuerzas par, porque los voy leyendo de dos en dos
Páginas: 1 2 3 4 5 6 [7] 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 ... 40
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines