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

 

 


Tema destacado: Guía rápida para descarga de herramientas gratuitas de seguridad y desinfección


  Mostrar Temas
Páginas: 1 2 3 4 5 [6] 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
51  Foros Generales / Dudas Generales / gramaticas LL en: 17 Julio 2014, 03:25 am
Saludos

Tengo la siguiente gramatica de tipo LL(o sea que no tiene recursiones por la izquierda) y a esta gramatica que esta compuesta por elementos Terminales y No Terminales, le tengo que calcular el conjunto de elementos Primero() y Siguiente().

Se define Primero(X) es el conjunto de simbolos terminales que pueden aparecer al principio de las cadenas derivadas X.

Se define Siguiente(X), para el no terminal X como el conjunto de simbolos terminales que pueden aparecer inmediatamente a la derecha de X en alguna forma sentencial. Si tenemos por ejemplo Siguiente(E) y E esta al final de alguna forma de sentencia como en el ejemplo. Siguiente de E va a ser Siguiente(B), o sea cdaf$g por que E se deriva de B (B->bcdE).

                           Primero      Siguiente
A->BCc|gDB        gbcda         $f
B->bCDE|$           b$             cdaf$g
C->ca|DaB           cda            cdg
D->dD|$               d$             bgca$f
E->gAf|c               gc             cdaf$g

y tengo la duda en Siguiente(D)  existe una B despues de la D en la letra A, y esa me daria el no terminal b, despues en la regla B hay una E despues de D lo que me daria los no terminales g y c. En la regla C tengo el simbolo no terminal a despues de la D, lo que me daria:

b,g,c,a   pero no se de donde sale la f??? si alguien me pudiera decir por que de esto se lo agradeceria mucho
52  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
53  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
54  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
55  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
56  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
57  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
58  Programación / Programación C/C++ / bug en mi codigo en: 9 Junio 2014, 22:52 pm
Saludos

tengo la siguiente función que se llama checkSumS1() que creo que me esta ocasionando que me truene un programa, no quiero publicar el código completo porque son 3,500 y tantas líneas de código. Lo que hace es que le paso 3 cadenas(Longitud, direccion y codigo_datos) y dentro de la función las concatena en una variable llamada registroS1, después va leyendo registroS1 de dos caracteres en dos. Por ejemplo si tengo ABE31000 primero va a obtener AB, que se supone es un "numero hexadecimal" y lo voy a convertir a su equivalente en decimal, y lo mismo con los demas caracteres. los decimales se van sumando, a la suma se le saca complemento a 1 y se obtienen sus 2 ultimos caracteres

Código
  1. char *CheckSumS1(char *Longitud,char *direccion,char *codigo_datos)
  2. {
  3.     int i,j,k,numero,x = 0,base = 16,suma = 0,complemento;
  4.     char *registroS1,*byte,digito[2],*checksum;
  5.     registroS1 = (char*)malloc(39*sizeof(char));
  6.     checksum = (char*)malloc(3*sizeof(char));
  7.     sprintf(registroS1,"%s%s%s",Longitud,direccion,codigo_datos);
  8.     for(i = 0;registroS1[i];i+=2)
  9.     {
  10.         byte = (char*)calloc(3,sizeof(char));
  11.         for(j = 1,k = i;j <= 2;j++,k++)
  12.         {
  13.             sprintf(digito,"%c",registroS1[k]);
  14.             strcat(byte,digito);
  15.         }
  16.         numero = obtenerNumero(byte,x,base);
  17.         suma+=numero;
  18.         free(byte);
  19.     }
  20.     complemento = ~suma;
  21.     sprintf(checksum,"%02X",complemento);
  22.     checksum = ultimos2bits(checksum);
  23.     return checksum;
  24. }

no se bien cual podria ser la causa de que cada vez que cuando el  codigo llega a esta función para ejecutarla a veces me truena y otras no. no se si  el sprintf y el strcat sean la mejor opcion para usarlos en la función, pero fue lo único que se me ocurrió para que me fuera leyendo de 2 en dos. si alguien me dijera cual es el bug que tiene me codigo se lo agradeceria mucho

gracias
59  Programación / Bases de Datos / backup en postgres en: 5 Junio 2014, 22:58 pm
Saludos

tengo una tabla creada en postgres que tengo que exportar a un archivo.txt, para esto pense que podria usar pg_dump, el problema es que cuando le pongo:

pg_dump act16 > archivo.txt

me aparece un error que dice error de sintaxis en o cerca de pg_dump, no se en que me equivoque

gracias
60  Programación / Programación C/C++ / asignación dinámica de memoria y strcpy en: 5 Junio 2014, 18:53 pm
Saludos

Tengo un pequeño código en el cual le asigno memoria a un puntero dinamicamente, despues le asigno unos valores y los imprimo, el problema lo tengo en el strcpy que se supone que le tiene que asignar la cadena "hola" al puntero, pero el programa truena y no entiendo por qué??

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. int main()
  6. {
  7.     char *x;
  8.     x= (char*)calloc(10,sizeof(char));
  9.     x = "101010101";
  10.     printf("[%s]\n",x);
  11.     strcpy(x,"hola");
  12.     printf("[%s]\n",x);
  13.     return 0;
  14. }

gracias
Páginas: 1 2 3 4 5 [6] 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines