Temas

Saludos

He estado buscando en diferentes partes información acerca de que es el la verificacion de ocurrencias en prolog y como activarla en mi version de prolog, que es la 6.6.1, solamente encontre cosas como la definicion y asi, pero no encontre nada de como realizar la activacion.

de antemano gracias

Saludos

Tengo las siguientes expresiones regulares:

M -> (M)
M -> n

estas dos me pueden generar cadenas como: ((((n)))) ó n

Tengo que diseñar una clase que se llame class Analizador Sintactico, para poder generar cualquier cadena que estas dos expresiones me permitan, ahorita ya hice una especie de pseudocodigo y creo que esta bien. Pero el problema es que yo sé que el analizador sintactico se asegura de que se tenga el mismo número de parentesis de abertura que de cierre, pero no estoy seguro de como lo hace

Código (java) [Seleccionar] Expandir

class Sintactico{
Lexico lexico = new Lexico();
int parentesis = 0;
void M(){
   if(lexicoSimbolo == 'n')
   {
       if(parentesis != 0)
          checarParentesis();
       else
  comprobar();
   }
   else if(lexicoSimbolo == '(')
   {
       parentesis++;
       M();
   }
   else
      error();
}

void checarParentesis(){
   int i = 1;
   while(i <= parentesis)
   {
       if(lexico.siguienteSimbolo() == ')' )
          i++;
       else
          error();
   }
}
}

que modificaciones le harian a este pseudocodigo para que sea más eficiente???

de antemano gracias

Saludos

Estoy repasando algunos conceptos de Automatas, tengo que escribir la expresion regular que le corresponderia a un tipo entero, de cualquier lenguaje, en este caso C.

La duda que tengo es sobre si una gramatica tipo BNF es lo mismo que una expresion regular??, ambas son muy parecidas pero no se si sean lo mismo

BNF

<entero>:=<signo><decimal>|<decimal>
<decimal>:= <decimal><digito>|<digito>
<digito>:=0|1|2|3|4|5|6|7|8|9
<signo>:=+|-

expresion regular

entero:=[+/-][0...9]+|[0...9]+

gracias

Saludos

Tengo que diseñar un algoritmo para ir recuperando unas cadenas de caracteres de un archivo pedido por el usuario. Un ejemplo del archivo sería:

char nombreVariable;

el codigo que yo tengo lo que hace es que va recorriendo el archivo caracter por caracter y si se encuentra un espacio en blanco o un signo de coma ', ' o de punto y coma ';',quiere decir que ha encontrado una cadena. En el ejemplo que puse las cadenas serian

char, nombreVariable y tambien el ;

Pero para el algoritmo que tengo solo obtiene las cadenas char y nombreVariable. El punto y coma no lo puede imprimir, y no se como cambiar el algoritmo que tengo:

este es el primer ciclo que me tiene que leer caracter por caracter hasta el final de archivo:

Código (java) [Seleccionar] Expandir

while((car = af.read()) != -1)
{
componenteLexico = Clase.leerArchivo(nombreArchivo,af);
System.out.print("[" + componenteLexico + "]");
}

y este es en el que me concatena los caracteres hasta que se encuentra con el caracter ' ' o ';'.

Código (java) [Seleccionar] Expandir

public static String leerArchivo(String nombre,RandomAccessFile r)
{
int car;
char c;
long posicion;
String cadena = null;
StringBuilder sb = new StringBuilder();
try
{
posicion = r.getFilePointer();
r.seek(posicion-1);
    while((car = r.read()) != -1 && car != ' ')
    {
    if(!esSignoPuntuacion(car))
    {
    c = (char)car;
            sb.append(c);
    }
    }
    cadena = sb.toString();
}
catch(IOException ex)
{
System.out.println("No se pudo abrir archivo");
}
return cadena;
}

public static boolean esSignoPuntuacion(int car)
{
if(car == ',' || car == ';' || car == '.')
   return true;
else
   return false;
}

gracias

Saludos

Tengo el siguiente programa que usa RandomAccessFile para abrir un archivo, y que en caso de que no pueda hacerlo me lance una excepcion. El problema es que aun cuando el archivo se encuentra en la ruta que le indico con el String ruta, me sigue lanzando esa excepcion FileNotFoundException cuando no deberia

Código (java) [Seleccionar] Expandir

import java.util.Scanner;
import java.io.File;
import java.io.RandomAccessFile;
import java.io.FileNotFoundException;

public class AutomataFinito {

public static void main(String[] args) {
String nombreArchivo,nombre,ruta = "C:/Usuarios/MiNombre/workspace/Proyecto/";
Scanner teclado = new Scanner(System.in);
System.out.print("Dame nombre del archivo: ");
nombre = teclado.nextLine();
nombreArchivo = ruta + nombre;
teclado.close();
try
{
File archivo = new File(nombreArchivo);
RandomAccessFile r = new RandomAccessFile(archivo,"r");

}
catch(FileNotFoundException fileNotFoundException)
{
System.out.println("No se pudo abrir archivo");
}
}

}

alguien me puede decir a qué se debe esto??

de antemano gracias

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

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 (c) [Seleccionar] Expandir

import java.util.Scanner;

class AnalizadorLexico {
Estados estadoActual;

    private enum Estados {
    q00, q01, q02, q03, q04, q05, q06, q07, q08, q09, q10,
         q11, q12, q13, q14, q15, q16, q17, q18, q19, q20, q21, q22
}
   
    private boolean palabraReservada(String token) {
    int i;
    String reservadas[] = {"abstract","assert","boolean","break","byte","case","catch","char","class","const",
        "continue","default","do","double","else","enum","extends","final","finally","float","for","goto","if",
        "implements","import","instanceof","int","interface","long","native","new","package","private","protected",
    "public","return","short","static","super","switch","new","package","private","protected","synchronized","this",
    "throw","throws","transient","try","void","volatile","while"};
   
    for(i = 0;i < reservadas.length;i++) {
        if(reservadas[i].equals(token))
               return true;
        }
    return false;
    }
   
    private boolean esIdentificador(String token) {
    int estadoSiguiente;
    char arregloToken[] = token.toCharArray();
    estadoActual = Estados.q00;
    for(int i = 0;i < arregloToken.length;i++){
    if(esLetra(arregloToken[i]))
       estadoSiguiente = 0;
    else if(esDigito(arregloToken[i]))
       estadoSiguiente = 1;
    else
       estadoSiguiente = 2;
    estadoActual = matrizTransicion(estadoActual,estadoSiguiente);
    }
    if(estadoActual.equals(Estados.q01))
       return true;
    else
       return false;
    }
   
    private boolean esDecimalEntero(String token){
    int estadoSiguiente;
    char arregloToken[] = token.toCharArray();
    estadoActual = Estados.q00;
    for(int i = 0;i < arregloToken.length;i++){
    if(esDigito(arregloToken[i]))
       estadoSiguiente = 0;
    else
       estadoSiguiente = 1;
    estadoActual = matrizTransicion2(estadoActual,estadoSiguiente);
    }
    if(estadoActual.equals(Estados.q01))
       return true;
    else
       return false;
    }
   
    private boolean esDecimalReal(String token){
    int estadoSiguiente;
    char arregloToken[] = token.toCharArray();
    estadoActual = Estados.q00;
    for(int i = 0;i < arregloToken.length;i++){
    if(esDigito(arregloToken[i]))
       estadoSiguiente = 0;
    else if(arregloToken[i] == '.')
       estadoSiguiente = 1;
    else
       estadoSiguiente = 2;
    estadoActual = matrizTransicion3(estadoActual,estadoSiguiente);
    }
    if(estadoActual.equals(Estados.q03))
       return true;
    else
       return false;
    }
   
    public Estados matrizTransicion(Estados estadoActual,int estadoSiguiente){
    int estado;
    Estados posicion,matriz[][] = {{Estados.q01,Estados.q02,Estados.q02},
                           {Estados.q01,Estados.q01,Estados.q02},
                           {Estados.q02,Estados.q02,Estados.q02}};
    estado = estadoActual.ordinal();
    posicion = matriz[estado][estadoSiguiente];
    return posicion;
    }
   
    public Estados matrizTransicion2(Estados estadoActual,int estadoSiguiente){
    int estado;
    Estados posicion,matriz[][] = {{Estados.q01,Estados.q02},
                                       {Estados.q01,Estados.q02},
                                       {Estados.q02,Estados.q02}};
    estado = estadoActual.ordinal();
    posicion = matriz[estado][estadoSiguiente];
    return posicion;
    }
   
    public Estados matrizTransicion3(Estados estadoActual,int estadoSiguiente){
    int estado;
    Estados posicion,matriz[][] = {{Estados.q01,Estados.q05,Estados.q04},
       {Estados.q01,Estados.q02,Estados.q04},
       {Estados.q03,Estados.q04,Estados.q04},
       {Estados.q03,Estados.q04,Estados.q04},
       {Estados.q04,Estados.q04,Estados.q04},
       {Estados.q03,Estados.q04,Estados.q04}};
    estado = estadoActual.ordinal();
    posicion = matriz[estado][estadoSiguiente];
    return posicion;
    }
   
    public boolean esLetra(char caracter) {
    if((caracter >= 'A' && caracter <= 'Z')||(caracter >= 'a' && caracter <= 'z'))
       return true;
    else
       return false;
    }
   
    public boolean esDigito(char caracter) {
    if((caracter >= '0' && caracter <= '9'))
       return true;
    else
       return false;
    }

    public void AutomataFinitoDeterminista(String token) {
    if(palabraReservada(token))
       System.out.println("El token " + token + " es una palabra reservada");
    else if(esDecimalEntero(token))
         System.out.println("El token " + token + " es un numero decimal entero");
    else if(esIdentificador(token))
       System.out.println("El token " + token + " es un identificador");
    else if(esDecimalReal(token))
       System.out.println("El token " + token + " es un numero decimal real");
    }
}

public class AutomataFinito {

public static void main(String[] args) {
String token;
char otroToken;
AnalizadorLexico analizador = new AnalizadorLexico();
Scanner teclado = new Scanner(System.in);
do
{
System.out.print("Dame el token: ");
token = teclado.nextLine();
analizador.AutomataFinitoDeterminista(token);
System.out.print("Desea ingresar otro token?(S/N) ");
otroToken = teclado.nextLine().charAt(0);
}while(otroToken == 'S' || otroToken == 's');
teclado.close();
}
}

gracias

Saludos

tengo el siguiente codigo :

Código (java) [Seleccionar] Expandir

import java.io.File;
import java.io.IOException;
import java.util.Scanner;
import java.io.RandomAccessFile;

public class Token {

public static void main(String[] args) {
int car;
String nombre,componenteLexico;
Scanner teclado = new Scanner(System.in);
System.out.print("Dame el nombre del archivo: ");
nombre = teclado.nextLine();
teclado.close();
try
{
File archivo = new File(nombre);
RandomAccessFile r = new RandomAccessFile(archivo,"r");
while((car = r.read()) != -1)
{
componenteLexico = Token.leerArchivo(nombre,r);
System.out.print(" "+componenteLexico);
}
r.close();
}
catch(IOException ex)
{
System.out.println("No se pudo abrir archivo");
}

}

public static String leerArchivo(String nombre,RandomAccessFile r)
{
int car;
char c;
long posicion;
String cadena = null;
StringBuilder sb = new StringBuilder();
try
{
posicion = r.getFilePointer();
r.seek(posicion-1);
    while((car = r.read()) != ' ')
    {
    c = (char)car;
        sb.append(c);
    }
    cadena = sb.toString();
}
catch(IOException ex)
{
System.out.println("No se pudo abrir archivo");
}
return cadena;
}
}


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

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

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 (java) [Seleccionar] Expandir

import java.io.File;
import java.io.FileReader;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Token {

public static void main(String[] args) {
String nombre;
Scanner teclado = new Scanner(System.in);
System.out.print("Dame el nombre del archivo: ");
nombre = teclado.nextLine();
teclado.close();
leerArchivo(nombre);
}

public static void leerArchivo(String nombre)
{
try
{
int car;
    File archivo = new File(nombre);
    FileReader fr = new FileReader(archivo);
    while((car = fr.read()) != -1)
       System.out.printf("%d",car);
}
catch(FileNotFoundException fileNotFoundException)
{
System.out.println("No se pudo abrir archivo");
}
}

}
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

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

Saludos tengo el siguiente archivo:

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 (c) [Seleccionar] Expandir

void leerTEMPORAL(COD *cabeza,TABSIM **t,char *archivo)
{
   int car,indice,longitud_del_codigo = 0,longitud = 3,bytesDisponibles = 16,disponibles = 16,x = 0,base = 16;
   int direccionActual,bytesSumados;
   FILE *tmp;
   DIV division,*codMaquina;
   COD *seEncontro = NULL;
   char *TIPO,*VALOR,*ETIQUETA,*CODOP,*OPERANDO,*COD_MAQUINA;
   char *tipo = "S1",*Longitud,*direccion,*codigo_datos,*checksum,*nuevaDireccion;
   codigo_datos = (char*)calloc(33,sizeof(char));
   if((tmp = fopen("TEMPORAL.txt","r")) != NULL)
   {
       while((car = fgetc(tmp)) != EOF)
       {
           TIPO = Etiqueta_Codop_Operando(tmp,TIPO_);
           ignorarEspacios(tmp);
           VALOR = Etiqueta_Codop_Operando(tmp,VALOR_);
           ignorarEspacios(tmp);
           ETIQUETA = Etiqueta_Codop_Operando(tmp,ETIQUETA_);
           ignorarEspacios(tmp);
           CODOP = Etiqueta_Codop_Operando(tmp,CODOP_);
           ignorarEspacios(tmp);
           OPERANDO = Etiqueta_Codop_Operando(tmp,OPERANDO_);
           if((seEncontro = buscarCodop(cabeza,CODOP)) != NULL)
           {
               if(!verificarOperando(seEncontro,OPERANDO))
               {
                   indice = obtenerIndiceDireccionamiento(seEncontro,OPERANDO);
                   COD_MAQUINA = calcularCodigo_Maquina(seEncontro,indice,VALOR,ETIQUETA,CODOP,OPERANDO,t);
                   longitudValida(COD_MAQUINA,&longitud_del_codigo);
                   if(agregarCodigo_Maquina(longitud_del_codigo))
                   {
                       if(disponibles == 16)
                          direccion = VALOR;
                       strcat(codigo_datos,COD_MAQUINA);
                       disponibles = bytesDisponibles-longitud_del_codigo;
                   }
                   else
                   {
                       if(disponibles != 0)
                       {
                           if(disponibles == 16)
                              direccion = VALOR;
                           codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
                           strcat(codigo_datos,codMaquina->bytesRequeridos);
                           disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
                           Longitud = calcularLongitudS1(longitud,codigo_datos);
                           //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                           crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                           direccionActual = obtenerNumero(VALOR,x,base);
                           bytesSumados = obtenerNumero(codMaquina->bytesPendientes,x,base);
                           longitud_del_codigo = 0;
                           bytesDisponibles = 16;
                           longitudValida(COD_MAQUINA,&longitud_del_codigo);
                           if(agregarCodigo_Maquina(longitud_del_codigo))
                           {
                               strcpy(codigo_datos,codMaquina->bytesPendientes);
                               disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
                           }
                       }
                       else
                       {
                           Longitud = calcularLongitudS1(longitud,codigo_datos);
                           //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                           crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                           longitud_del_codigo = 0;
                           disponibles = 16;
                           direccion = VALOR;
                           *codigo_datos = 0;
                           longitudValida(COD_MAQUINA,&longitud_del_codigo);
                           if(agregarCodigo_Maquina(longitud_del_codigo))
                           {
                               strcpy(codigo_datos,COD_MAQUINA);
                               disponibles = bytesDisponibles-longitud_del_codigo;
                           }
                       }
                   }
               }
           }
           else if(esDirectivaCONSTANTES_1byte(CODOP)||esDirectivaCONSTANTES_2byte(CODOP)||esDirectivaCARACTERES(CODOP))
           {
               COD_MAQUINA = codigoMaquina_Directivas(VALOR,ETIQUETA,CODOP,OPERANDO);
               longitudValida(COD_MAQUINA,&longitud_del_codigo);
               if(agregarCodigo_Maquina(longitud_del_codigo))
               {
                   if(disponibles == 16)
                      direccion = VALOR;
                   strcat(codigo_datos,COD_MAQUINA);
                   disponibles = bytesDisponibles-longitud_del_codigo;
               }
               else
               {
                   if(disponibles != 0)
                   {
                       if(disponibles == 16)
                          direccion = VALOR;
                       codMaquina = dividir_CodigoMaquina(&division,COD_MAQUINA,disponibles);
                       strcat(codigo_datos,codMaquina->bytesRequeridos);
                       disponibles = bytesDisponibles-(strlen(codMaquina->bytesRequeridos)/2);
                       Longitud = calcularLongitudS1(longitud,codigo_datos);
                       //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                       crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                       direccionActual = obtenerNumero(VALOR,x,base);
                       bytesSumados = strlen(codMaquina->bytesRequeridos)/2;
                       nuevaDireccion = calcularDireccion(direccionActual,bytesSumados);
                       direccion = nuevaDireccion;
                       longitud_del_codigo = 0;
                       bytesDisponibles = 16;
                       *codigo_datos = 0;
                       longitudValida(COD_MAQUINA,&longitud_del_codigo);
                       if(agregarCodigo_Maquina(longitud_del_codigo))
                       {
                           strcpy(codigo_datos,codMaquina->bytesPendientes);
                           disponibles = bytesDisponibles-(strlen(codMaquina->bytesPendientes)/2);
                       }
                   }
                   else
                   {
                       Longitud = calcularLongitudS1(longitud,codigo_datos);
                       //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                       crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                       longitud_del_codigo = 0;
                       direccion = VALOR;
                       longitudValida(COD_MAQUINA,&longitud_del_codigo);
                       if(agregarCodigo_Maquina(longitud_del_codigo))
                       {
                           strcpy(codigo_datos,COD_MAQUINA);
                           disponibles = bytesDisponibles-longitud_del_codigo;
                       }
                   }
               }
           }
           else if(esDirectivaRESERVA_MEMORIA1byte(CODOP)||esDirectivaRESERVA_MEMORIA2byte(CODOP))
           {
               printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
               if(codigo_datos[CERO] != '\0')
               {
                   Longitud = calcularLongitudS1(longitud,codigo_datos);
                   //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                   crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                   longitud_del_codigo = 0;
                   disponibles = 16;
                   *codigo_datos = 0;
               }
           }
           else
           {
               if((strcmp(CODOP,"ORG")) == 0)
               {
                   printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
                   calcularS0(archivo);
               }
               else if((strcmp(CODOP,"END")) == 0)
               {
                   if(codigo_datos[CERO] != '\0')
                   {
                       Longitud = calcularLongitudS1(longitud,codigo_datos);
                       //checksum = CheckSumS1(Longitud,direccion,codigo_datos);
                       crearRegistroS1(tipo,Longitud,direccion,codigo_datos,checksum);
                   }
                   printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
                   crearArchivoS9();
               }
               else if((strcmp(CODOP,"EQU")) == 0)
                  printf("%s   %s   %s   %s\n",VALOR,ETIQUETA,CODOP,OPERANDO);
               else
               {
                   printf("%s   %s   %s   %s\t",VALOR,ETIQUETA,CODOP,OPERANDO);
                   printf("NO SE ENCONTRO EL CODOP DE OPERANDO\n");
               }
           }
       }
   }
   else
      printf("No se pudo abrir archivo\n");
}

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

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 (c) [Seleccionar] Expandir

char *CheckSumS1(char *Longitud,char *direccion,char *codigo_datos)
{
   int i,j,k,numero,x = 0,base = 16,suma = 0,complemento;
   char *registroS1,*byte,digito[2],*checksum;
   registroS1 = (char*)malloc(39*sizeof(char));
   checksum = (char*)malloc(3*sizeof(char));
   sprintf(registroS1,"%s%s%s",Longitud,direccion,codigo_datos);
   for(i = 0;registroS1[i];i+=2)
   {
       byte = (char*)calloc(3,sizeof(char));
       for(j = 1,k = i;j <= 2;j++,k++)
       {
           sprintf(digito,"%c",registroS1[k]);
           strcat(byte,digito);
       }
       numero = obtenerNumero(byte,x,base);
       suma+=numero;
       free(byte);
   }
   complemento = ~suma;
   sprintf(checksum,"%02X",complemento);
   checksum = ultimos2bits(checksum);
   return checksum;
}

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

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

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 (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
   char *x;
   x= (char*)calloc(10,sizeof(char));
   x = "101010101";
   printf("[%s]\n",x);
   strcpy(x,"hola");
   printf("[%s]\n",x);
   return 0;
}

gracias

Saludos tengo las siguientes tablas

BAR(id,nombre)
CERVEZA(id,nombre)
CLIENTE(id,nombre)
SIRVE(idBAR,idCERVEZA)
ASISTE(idCLIENTE,idBAR)
GUSTA(idCLIENTE,idCERVEZA)

y tengo la consulta que dice nombrar los nombres de las cervezas que no se sirven en el bar 'TARROS'

lo que llevo es esto:

SELECT c.nombre FROM BAR AS b, CERVEZA AS c, SIRVE AS s
WHERE c.id=s.idCERVEZA AND b.id=s.idBAR AND b.nombre='TARROS'

pero a partir de ahi ya no se como seguir

gracias

Saludos

tengo la siguientes tablas
CENTROS (Numero, Nombre, Direccion)
DEPARTAMENTOS (Numero, Centro, Director, Tipo_director, Presupesto, Depto_jefe, Nombre)
EMPLEADOS (Cod, Departamento, Telefono, Fecha_nacimiento, Fecha_ingreso, Salario, Comision,Num_hijos, Nombre)

y me pide que haga las siguientes consultas:

20. Obtener, por orden alfabético, los nombres y los salarios de los empleados cuyo salario coincide con la comisión de cualquier otro o la suya propia.

yo pense que seria algo como esto:

SELECT Nombre, Salario
FROM EMPLEADOS
WHERE Salario=Comision;

pero en el problema me dice que el salario puede coincidir con la comision de cualquier otro y esa es la parte que no se como hacerla.

otra es: 22. Para los departamentos cuyo salario medio supera al promedio de la empresa, hallar cuántas extensiones telefónicas tienen.

SELECT COUNT(Telefono)
FROM EMPLEADOS AS e, DEPARTAMENTOS AS d
WHERE AVG(e.salario) > AVG(salario);

pero no se como calcular el promedio del salario de toda la empresa

gracias

Saludos

Tengo la siguiente función que se llama crearArchivoTABSIM() la cual se encuentra dentro de un ciclo en el main, y cada vez que entra al ciclo se le asigna a la funcion una cadena que se llama etiqueta(char *etiqueta).

Código (c) [Seleccionar] Expandir

void crearArchivoTABSIM(char *etiqueta)
{
   FILE *tb;
   ETIQ *p = NULL;
   if((strcmp(etiqueta,"null")) != 0)
   {
       crearListaEtiquetas(&p,etiqueta);
       imprimirEtiquetas(p);
       if((tb = fopen("TABSIM.txt","a+")) != NULL)
       {
           fwrite(etiqueta,strlen(etiqueta),1,tb);
           fwrite("\n",1,1,tb);
       }
   }
}

y dentro de la función crearArchivoTABSIM() se encuentra la función crearListaEtiquetas() que me va a crear una lista simplemente ligada que tiene un campo char *etiqueta,y que cada vez que le envie una etiqueta me la va a insertar al principio, y después de esta esta la función imprimirEtiquetas() que me va a ir imprimiendo las etiquetas

Código (c) [Seleccionar] Expandir

void crearListaEtiquetas(ETIQ **p,char *etiqueta)
{
   ETIQ *nuevo;
   nuevo = crearEtiqueta(etiqueta);
   nuevo->sig = *p;
   *p = nuevo;
}

ETIQ *crearEtiqueta(char *etiqueta)
{
   ETIQ *x;
   int lon;
   lon = strlen(etiqueta);
   x = malloc(sizeof(ETIQ));
   x->Etiqueta = malloc((lon+1)*sizeof(char));
   strcpy(x->Etiqueta,etiqueta);
   return x;
}

void imprimirEtiquetas(ETIQ *p)
{
   ETIQ *ptr;
   for(ptr = p;ptr!=NULL;ptr = ptr->sig)
      printf("[%s]\n",ptr->Etiqueta);
}
como  por ejemplo:

Si le mando las etiquetas ET1, ET2,ET3,ET4

deberia imprimir

1) ET1
2)ET1    ET2
3)ET1   ET2    ET3
4)ET1   ET2    ET3     ET4

pero el problema que tengo es que solo me esta imprimiendo el primer nodo, o sea a donde apunte la cabeza de lista y no se que estoy haciendo mal, previamente ya habia hecho listas ligadas y no me habian dado ningun problema

de antemano gracias

Saludos

tengo una duda de como hacer un procedimiento de conversión de un número decimal negativo a su hexadecimal, se que si el número fuera positivo con tan solo hacer divisiones sucesivas obtendría el resultado, pero cuál es el procedimiento para los negativos??

gracias

Saludos

tengo una duda a acerca de si el operador  ~ que se usa para obtener el complemento a 1 de un numero, puede usarse solo con números decimales o si tambien los puede usar con numeros binarios??

saludos, tengo una duda de como funciona el contador de localidades de un ensamblador cuando se tienen errores en una directiva por ejemplo si yo tengo

DB         300

aqui hay un error en el rango porque la directiva solo puede tener un valor del 0 al 255

DB         %11A

aqui hay otro error porque las bases binarias solo aceptan los digitos 1 y 0.

entonces en estos casos aumenta el contloc??? o se queda con el valor anterior??
gracias

Saludos

tengo un codigo que convierte un numero decimal en hexadecimal(siempre tiene que ser decimal-hexadecimal), el programa funciona bien el problema es que una vez que tengo el número hexa tengo que hacer que sea de dos bytes, o sea vendrían siendo 4 digitos como por ejemplo

numero decimal       hexadecimal      hexadecimal 2 bytes
33                               21                        0021

y no se como concatenarle los dos ceros al principio, pense en usar un strcat pero no funciono, creaba otra variable *cadena, y despues de asignarle memoria la inicializaba con: "0", y después le concatenaba la cadena "21" para que me quedara "021".

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char convertirHexadecimal(int residuo);

int main()
{
    char num_hex,*cadena,c[2],*hexadecimal;
    int numero = 33,cociente,residuo,i;
    cadena = calloc(12,sizeof(char));
    for(cociente = numero;cociente > 0;cociente/=16)
    {
        residuo = cociente % 16;
        num_hex = convertirHexadecimal(residuo);
        sprintf(c,"%c",num_hex);
        strcat(cadena,c);
    }
    strrev(cadena);
    printf("[%s]\n",cadena);
    return 0;
}

char convertirHexadecimal(int residuo)
{
    char letra;
    switch(residuo)
    {
        case 10:
           letra = 'A';
           break;
        case 11:
           letra = 'B';
           break;
        case 12:
           letra = 'C';
           break;
        case 13:
           letra = 'D';
           break;
        case 14:
           letra = 'E';
           break;
        case 15:
           letra = 'F';
           break;
        default:
           letra = '0' + residuo;
    }
    return letra;
}


Saludos

Alguien conoce de algun metodo que no sea el de divisiones sucesivas el cual convierta un numero decimal a cualquiera de las otras 3 potencias,(binaria,octal,hexadecimal)????

gracias

[numeros decimales]

Saludos, tengo el siguiente segmento de codigo dentro de un CASE '[' o
CASE INDEXADO_INDIRECTO, donde tengo que validar una cadena esta cadena que inicia con [, debe de tener o bien una D despues del corchete o un numero en base DECIMAL (tiene un rango especifico de valores para que sea valido)seguido por una , despues un registro que puede ser x,y,sp,pc  y por ultimo un corchete de cierre ]

por ejemplo si tengo:

[5,Sp -> error: le falta el ultimo corchete
[,x] -> no puede haber una instruccion vacia antes de la coma
[100,] ->no puede haber una instruccion vacia despues de la coma
[ ->despues del primer [ debe haber dos registros separados por una , y despues ]
[AD,sp]-> el primer registro tiene que ser la letra D

PERO cuando le pongo algo como:

[5A9,x] -> aqui me aparece que es un numero valido, pero para este caso en especial solo puede aceptar numeros decimales, y no se como corregir esto

Código (c) [Seleccionar] Expandir

case INDEXADO_INDIRECTO:
           i = 1;
           tam = strlen(operando);
           car = operando[i++];
           if(car == '\0')
              printf("Despues del primer [ debe haber dos registros separados por , y un corchete de cierre\n");
           else
           {
               if(operando[tam-1] != ']')
                  printf("Error: No se encontro corchete de cierre\n");
               else
               {
                   switch(car)
                   {
                       case ']':
                          printf("No pueden estar los corchetes vacios\n");
                          break;
                       case ',':
                          printf("No puede haber una instruccion vacia antes de la coma\n");
                          registro = obtenerRegistro(operando);
                          if((strcmp(registro,"\0")) == 0)
                             printf("No puede haber una instruccion vacia despues de la coma\n");
                             break;
                       case '0':
                       case '1':
                       case '2':
                       case '3':
                       case '4':
                       case '5':
                       case '6':
                       case '7':
                       case '8':
                       case '9':
                          if((ptr = strchr(operando,',')) == 0)
                             printf("Despues del primer corchete debe haber dos registros separados por una ,\n");
                          else
                          {
                              base = 10;
                              x = 1;
                              k = 0;
                              esIndexadoIndirecto16bits = 1;
                              instruccion = obtenerInstruccion(operando,x);
                              numero = obtenerNumero(instruccion,k,base);
                              registro = obtenerRegistro(operando);
                              registro = convertirMayusculas(registro);
                              if((strcmp(registro,"\0")) == 0)
                                 printf("No puede haber una instruccion vacia despues de la coma\n");
                              else
                              {
                                  if(!verificarRegistro(registro))
                                  {
                                      esIndexadoIndirecto16bits = 0;
                                      printf("Los registros validos de un direccionamiento Indexado indirecto de 16 bits son X,Y,SP,PC\n");
                                  }
                                  if(!verificarRangoIndexadoIndirecto(numero))
                                  {
                                      esIndexadoIndirecto16bits = 0;
                                      printf("El rango valido de un direccionamiento Indexado Indirecto de 16 bits es de 0 a 65535\n");
                                  }
                                  if(esIndexadoIndirecto16bits)
                                  {
                                      if((indice = buscarDireccionamiento(encontrado,direccionamiento[7]))!= -1)
                                         printf("Indexado Indirecto de 16 bits([IDX2]), de %s bytes\n",encontrado->total_bytes[indice]);
                                      else
                                         printf("el codop %s no acepta el direccionamiento indexado indirecto de 16 bits\n",encontrado->instruccion);
                                  }
                              }
                          }
                         break;
                      case '-':
                         if((ptr = strchr(operando,',')) == 0)
                            printf("Despues del primer corchete debe haber dos registros separados por una ,\n");
                         else
                         {
                             base = 10;
                             x = 0;
                             k = 1;
                             esIndexadoIndirecto16bits = 1;
                             instruccion = obtenerInstruccion(operando,x);
                             numero = obtenerNumero(instruccion,k,base);
                             registro = obtenerRegistro(operando);
                             registro = convertirMayusculas(registro);
                             if((strcmp(registro,"\0")) == 0)
                                printf("No puede haber una instruccion vacia despues de la coma\n");
                             else
                             {
                                 if(!verificarRegistro(registro))
                                 {
                                     esIndexadoIndirecto16bits = 0;
                                     printf("Los registros validos de un direccionamiento Indexado indirecto de 16 bits son X,Y,SP,PC\n");
                                 }
                                 if(!verificarRangoIndexadoIndirecto(numero))
                                 {
                                     esIndexadoIndirecto16bits = 0;
                                     printf("El rango valido de un direccionamiento Indexado Indirecto de 16 bits es de 0 a 65535\n");
                                 }
                                 if(esIndexadoIndirecto16bits)
                                 {
                                     if((indice = buscarDireccionamiento(encontrado,direccionamiento[7]))!= -1)
                                        printf("Indexado Indirecto de 16 bits([IDX2]), de %s bytes\n",encontrado->total_bytes[indice]);
                                     else
                                        printf("el codop %s no acepta el direccionamiento indexado indirecto de 16 bits\n",encontrado->instruccion);
                                 }
                             }
                         }
                         break;
                      default:
                         x = 1;
                         esIndexadoIndirecto_Acumulador = 1;
                         instruccion = obtenerInstruccion(operando,x);
                         registro = obtenerRegistro(operando);
                         registro = convertirMayusculas(registro);
                         if(!indirectoAcumulador_D(instruccion))
                         {
                             printf("Error: El Acumulador valido de un Indexdo Indirecto de acumulador es D\n");
                             esIndexadoIndirecto_Acumulador = 0;
                         }
                         if(!verificarRegistro(registro))
                         {
                             printf("Los registros validos de un Indexado Indirecto de Acumulador son X,Y,SP,PC\n");
                             esIndexadoIndirecto_Acumulador = 0;
                         }
                         if(esIndexadoIndirecto_Acumulador)
                         {
                             if((indice = buscarDireccionamiento(encontrado,direccionamiento[6]))!= -1)
                                printf("Indexado Indirecto de Acumulador D,([D,IDX]), de %s bytes\n",encontrado->total_bytes[indice]);
                             else
                                printf("el codop %s no acepta el direccionamiento indexado indirecto de acumulador D\n",encontrado->instruccion);
                         }
                     }
               }
           }
           break;


y las demas funciones son estas, no puse todo el codigo porque son como 1700 lineas de codigo,se que tengo algunas malas practicas de programacion pero ahora lo importante es corregir ese bug.

Código (c) [Seleccionar] Expandir

char *obtenerRegistro(char *operando)
{
   int j,i = 0;
   char *cadena = NULL,c[2];
   cadena = calloc(2,sizeof(char));
   while(operando[i] != ',')
      i++;
   for(j = i+1;operando[j] != ']';j++)
   {
       sprintf(c,"%c",operando[j]);
       strcat(cadena,c);
   }
   return cadena;
}
char *obtenerInstruccion(char *operando,int x)
{
   int i;
   char *cadena = NULL,c[2],signo[] = {'\0',','};
   cadena = calloc(7,sizeof(char));
   for(i = x;operando[i] != ',';i++)
   {
       sprintf(c,"%c",operando[i]);
       strcat(cadena,c);
   }
   return cadena;
}

int obtenerNumero(char *operando,int x,int base)
{
   int i,potencia,num_decimal = 0,lon,entero = 0;
   lon = strlen(operando);
   for(i = lon-1,potencia = 1;i >= x;i--,potencia*=base)
   {
       if(esLetraBase16(operando[i]))
          entero = hexadecimal(operando[i]);
       else
          entero = operando[i]-'0';
       num_decimal+= potencia*entero;
   }
   if(operando[CERO] == '-')
      num_decimal*= -1;
   return num_decimal;
}

int hexadecimal(char caracter)
{
   int decimal;
   switch(caracter)
   {
       case 'A':case 'a':
          decimal = 10;
          break;
       case 'B':case 'b':
          decimal = 11;
          break;
       case 'C':case 'c':
          decimal = 12;
          break;
       case 'D':case 'd':
          decimal = 13;
          break;
       case 'E':case 'e':
          decimal = 14;
          break;
       case 'F':case 'f':
          decimal = 15;
          break;
       default:
          printf("!Error!\n");
   }
   return decimal;
}

char *convertirMayusculas(char *cadena)
{
   int i;
   for(i = 0;cadena[i];i++)
      cadena[i] = toupper(cadena[i]);
   return cadena;
}

int verificarRegistro(char *cadena)
{
   int i;
   char *registro[] = {"X","Y","SP","PC"};
   for(i = 0;i < 4;i++)
   {
       if((strcmp(cadena,registro[i])) == 0)
          return 1;
   }
   return 0;
}

int verificarRangoIndexadoIndirecto(int numero)
{
   if(numero >= CERO && numero <= MAX_IDX_INDIRECTO)
      return 1;
   else
      return 0;
}


de antemano gracias

Saludos, tengo dos tablas en postgres que son la siguientes:

partidas_pedidos con sus campos: id_pedido(Pk),fecha_pedido,cantidad,producto(fK),cliente(Fk)

y info_clientes: nombre,apellido,id_cliente(Pk)

y me piden que haga una consulta:

Mostrar IDs de los clientes, sin repetirse, que en algun pedido hayan comprado mas de dos ejemplares de un mismo producto(cantidad) durante 1999

SELECT DISTINCT id_cliente
FROM info_clientes
WHERE id_cliente=(SELECT cliente FROM partidas_pedidos WHERE cantidad > 2 AND fecha_pedido LIKE '1999%');

pero me aparece un error que dice: subconsulta utilizada como expresion retorno mas de un registro y no entiendo por qué me sale esto

Saludos

si yo quiero declarar un arreglo de 2 caracteres que sean:

char arreglo[] = {'\0',','};

uno que es una coma, y el otro que es el simbolo de fin de cadena, pero me dicen que al declarar un arreglo de caracteres al final se le tiene que poner precisamente el simbolo '\0', entonces tendria yo que poner a fuerzas otro signo de fin de linea??

char arreglo[] = {'\0',',','\0'};

Saludos

Tengo la siguiente tabla que se llama partidas_pedidos que cuenta con los siguientes campos:

id_pedido,cliente,fecha_pedido,producto,cantidad

y luego me hace una consulta que dice :

Listar los valores de id_pedido, cliente y producto de la tabla partidas_pedidos, cuya compra se haya efectuado en un mes de abril. Suponga que el campo fecha_pedido sea de tipo char(10).

SELECT id_pedido,cliente,producto FROM partidas_pedidos WHERE fecha_pedido LIKE '';

el problema es que no se que ponerle en las comillas del LIKE'', si la fecha es algo como:  2000-04-01  como ponerle que la fecha tiene que ser en el mes de abril??

y luego si tengo una tabla que se llama info_clientes con los campos: id_cliente,nombre,apellido,ciudad y estado. La consulta dice:

Desplegar la información de los clientes cuyo apellido empiece con 'H' y termine con 'A' y viva en un estado cuyo nombre lo formen 7 letras.

SELECT *FROM info_clientes
WHERE apellido LIKE 'H%' AND apellido LIKE '%A' AND estado='';

pero aqui no se como verificar que el estado este conformado por solo 7 letras, tedria que usar el COUT(*)???

gracias

Saludos, ya puede instalar bien el postgres y ahora estoy creando dos tablas, una con datos de un empleado y otra del departamento al que pertence

CREATE TABLE compania.empleado (
    codigo       INT,
    nombrep      VARCHAR(15)    NOT NULL,
    apellido     VARCHAR(15)    NOT NULL,
    sexo         CHAR           DEFAULT 'M',
    salario      DECIMAL(10,2),
    nd           INT            NOT NULL,

   CONSTRAINT pk_empleado PRIMARY KEY (codigo)
);

esta es la primer tabla, y la segunda es:

CREATE TABLE compania.departamento (
    numerod      INT            NOT NULL,
    nombred      VARCHAR(25)    NOT NULL,
    gerente      CHAR(9)        NOT NULL,

   CONSTRAINT pk_departamento PRIMARY KEY(numerod)
);

despues el ejercicio me dice que tengo que definir una llave foranea que apunte al departamento al que pertenece el empleado (nd) y hago lo siguiente:

ALTER TABLE compania.empleado ADD CONSTRAINT restriccion FOREIGN KEY(nd) REFERENCES compania.departamento(numerod);

no me marca error, pero no se si he hecho la llave correctamente, y antes de seguir agregandole cosas a las tablas quiero saber si esta mal

gracias

Saludos

estoy empezando a utilizar postgres, el problema que tengo es que después de instalarlo cuando quiero ir a donde esta la carpeta pgsql que tengo en el escritorio y escribo esto:

C:Users>Invitado>cd Escritorio

me aparece el mensaje

El sistema no puede encontrar la ruta especificada

y no entiendo por qué me aparece esto, me dijeron que lo hiciera en una cuenta diferente a la de Administrador y eso hice pero aun asi no funciona

gracias

Saludos tengo el siguiente archivo de texto que dice:

;ejemplo con errores
Et12_xyz123     ADCA      1,PC
%ET3        LDAA      #$90
Netq%23        RMB      556
etv1
XYZ        Ldaaxyz   4
        %XYZ
        a.c.      %1111000
Abc        SWI%

y el codigo me tiene que imprimir esto

COMENTARIO

ETIQUETA = Et12_xyz123
CODOP =ADCA
OPERANDO = 1,PC
.....
....
....

y asi con todas las lineas, pero me imprime

COMENTARIO

NO SE ENCONTRO CODOP

y no entiendo por que imprime esto ultimo si solo en las lineas que no son comentarios me tiene que verificar si se encontro el codop o no

el codigo es este:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#define LONG_ETIQUETA 8
#define LONG_CODOP 5
#define COMENTARIO ';'
#define TABULADOR '\t'
#define ESPACIOS_ ' '
#define MAX 8
#define MAXIMO 40

typedef enum {FALSO,VERDADERO} booleano;
typedef enum {ETIQUETA,CODOP,OPERANDO} linea;
typedef enum {INS,OP,DIR,MAQ,CALCULADO,CALCULAR,TOTAL} tabla;

typedef struct nodo
{
   char *instruccion;
   char *operando;
   char **modo_direccionamiento;
   char **codigo_maquina;
   char **bytes_calculados;
   char **bytes_x_calcular;
   char **suma_bytes;
   int tipo_linea;
   struct nodo *sig;
}COD;

void imprimirInfo(COD *p);
int verificarCombinacion(FILE *fd);
booleano esComentario(FILE *fd);
char *Etiqueta_Codop_Operando(FILE *fd,int linea);
char *_Codop_Operando(FILE *fd,int linea);
void ultimaLinea(char *codop);
void erroresEtiqueta(char *etiqueta);
void erroresCodop(char *codop);
void buscarFinLinea(FILE *fd);
void ignorarEspacios(FILE *fd);
void listaTABOP(COD **cabeza);
COD *ultimoElemento(COD **cabeza);
COD *crearNodo(char *ins,char *op,char **dir,char **maq,char **cal,char **x_cal,char **sum,int n);
void insertarFinal(char *ins,char *op,char **dir,char **maq,char **cal,char **x_cal,char **sum,COD *ultimo,int n);
char *Tabla_Operandos(FILE *hc12,int tabla);
COD *buscarCodop(COD *cabeza,char *codop);
void quitarSaltosLinea(char *cadena);
booleano esNumero(char caracter);
booleano esLetra(char caracter);
void verificarOperando(COD *encontrado,char *operando);

int main()
{
   FILE *fd;
   int car,combinacion;
   COD *cabeza = NULL,*encontrado = NULL;
   char nombre[MAXIMO],archivo[MAXIMO],respuesta,*etiqueta,*codop,*operando;
   listaTABOP(&cabeza);
   do
   {
       printf("\nQue archivo quieres abrir: ");
       fgets(nombre,sizeof(nombre),stdin);
       quitarSaltosLinea(nombre);
       sprintf(archivo,"%s.txt",nombre);
       if((fd = fopen(archivo,"r"))!= NULL)
       {
           while((car = fgetc(fd))!= EOF)
           {
               switch(car)
               {
                   case COMENTARIO:
                      if(esComentario(fd))
                         printf("COMENTARIO\n\n");
                      else
                         buscarFinLinea(fd);
                      break;
                   case ESPACIOS_:
                   case TABULADOR:
                      etiqueta = "null";
                      printf("ETIQUETA = %s\n",etiqueta);
                      ignorarEspacios(fd);
                      codop = Etiqueta_Codop_Operando(fd,CODOP);
                      printf("CODOP = %s\n",codop);
                      erroresCodop(codop);
                      combinacion = verificarCombinacion(fd);
                      if(combinacion == 2)
                      {
                          operando = "null";
                          printf("OPERANDO = %s\n\n",operando);
                      }
                      else
                      {
                          ignorarEspacios(fd);
                          operando = Etiqueta_Codop_Operando(fd,OPERANDO);
                          printf("OPERANDO = %s\n\n",operando);
                      }
                      break;
                   default:
                      etiqueta = Etiqueta_Codop_Operando(fd,ETIQUETA);
                      printf("ETIQUETA = %s\n",etiqueta);
                      erroresEtiqueta(etiqueta);
                      combinacion = verificarCombinacion(fd);
                      if(combinacion == 2)
                      {
                          codop = "null";
                          printf("CODOP = %s\n",codop);
                          erroresCodop(codop);
                          operando = "null";
                          printf("OPERANDO = %s\n\n",operando);
                      }
                      else
                      {
                          ignorarEspacios(fd);
                          codop = Etiqueta_Codop_Operando(fd,CODOP);
                          printf("CODOP = %s\n",codop);
                          erroresCodop(codop);
                          combinacion = verificarCombinacion(fd);
                          if(combinacion == 2)
                          {
                              operando = "null";
                              printf("OPERANDO = %s\n\n",operando);
                          }
                          else
                          {
                              ignorarEspacios(fd);
                              operando = Etiqueta_Codop_Operando(fd,OPERANDO);
                              printf("OPERANDO = %s\n\n",operando);
                          }
                      }
                      break;
               }
               if((strcmp(codop,"null"))!= 0)
               {
                   if((encontrado = buscarCodop(cabeza,codop)) == NULL)
                      printf("NO SE ENCONTRO EL CODOP DE OPERACION\n\n");
                   else
                   {
                       verificarOperando(encontrado,operando);
                       imprimirInfo(encontrado);
                   }
               }

           }
           ultimaLinea(codop);
       }
       else
          printf("No se pudo abrir el archivo");
       printf("Quieres abrir otro archivo S/N: ");
       fgets(nombre,MAX,stdin);
       sscanf(nombre,"%c",&respuesta);
       system("cls");
   }while(respuesta == 'S' || respuesta == 's');
   return 0;
}

booleano esComentario(FILE *fd)
{
   int car;
   while((car = fgetc(fd))!= '\n')
   {
       if(car == ';')
          return 0;
   }
   return 1;
}

void buscarFinLinea(FILE *fd)
{
   int car;
   while((car = fgetc(fd))!= '\n')
       ;
}

void ignorarEspacios(FILE *fd)
{
   int car;
   do
   {
       car = fgetc(fd);
   }while(car == '\t' || car == ' ');
}

int verificarCombinacion(FILE *fd)
{
   int car,combinacion;
   fseek(fd,-1,SEEK_CUR);
   if((car = fgetc(fd))== '\n')
      combinacion = 2;
   else
      combinacion = 1;
   return combinacion;
}

booleano esLetra(char caracter)
{
   if((caracter >= 'A' && caracter <= 'Z')||(caracter >= 'a' && caracter <= 'z'))
      return 1;
   else
      return 0;
}

booleano esNumero(char caracter)
{
   if(caracter >= '0' && caracter <= '9')
      return 1;
   else
      return 0;
}

char *Etiqueta_Codop_Operando(FILE *fd,int linea)
{
   int car,lon = 0,pos;
   char *cadena;
   fseek(fd,-1,SEEK_CUR);
   pos = ftell(fd);
   if((linea == ETIQUETA)||(linea == CODOP))
   {
       do
       {
           car = fgetc(fd);
           lon++;
       }while(car != '\t' && car != ' ' && car != '\n');
   }
   else
   {
       do
       {
           car = fgetc(fd);
           lon++;
       }while(car != '\n');
   }
   cadena = (char*)calloc((lon+1),sizeof(char));
   fseek(fd,pos,SEEK_SET);
   fgets(cadena,lon+1,fd);
   quitarSaltosLinea(cadena);
   return cadena;
}

void erroresEtiqueta(char *etiqueta)
{
   int tam,i = 0,esEtiqueta = 1;
   tam = strlen(etiqueta);
   if(tam > LONG_ETIQUETA)
      printf("\tError:la longitud maxima de una etiqueta es de 8 caracteres\n");
   if(!esLetra(etiqueta[i]))
      printf("\tError:la etiqueta debe iniciar con letra\n");
   else
   {
       for(i = 0;(i < tam)&&(esEtiqueta);i++)
       {
          if((!esLetra(etiqueta[i]))&&(!esNumero(etiqueta[i]))&&(etiqueta[i] != '_'))
             esEtiqueta = 0;
       }
       if(!esEtiqueta)
          printf("\tError:los caracteres validos en las etiquetas son letras, digitos(0..9) y el guion bajo\n");
   }
}

void erroresCodop(char *codop)
{
   int tam,i = 0,esCodop = 1,punto = 0;
   tam = strlen(codop);
   if(tam > LONG_CODOP)
      printf("\tError:la longitud maxima de un codigo de operacion es de 5 caracteres\n");
   if((strcmp(codop,"null"))== 0)
      printf("\tError:siempre debe de haber un codigo de operacion\n");
   else
   {
       if(!esLetra(codop[i]))
       printf("\tError:los codigos de operacion deben iniciar con letra\n");
       else
       {
           for(i = 1;(i < tam)&&(esCodop)&&(punto>=0&&punto<=1);i++)
           {
               if((!esLetra(codop[i]))&&(codop[i] != '.'))
                  esCodop = 0;
               else if(codop[i] == '.')
                  punto++;
           }
           if(!esCodop)
              printf("\tError:los caracteres validos en un codigo de operacion son letras y el caracter punto\n");
           if(punto > 1)
              printf("\tError:los codigos de operacion no pueden tener mas de un punto\n");
       }
   }
}

void ultimaLinea(char *codop)
{
   int lon1,lon2,i;
   lon1 = strlen(codop);
   lon2 = strlen("end");
   if(lon1 != lon2)
      printf("Error: No se encontro el END.\n");
   else
   {
       for(i = 0;codop[i];i++)
          codop[i] = tolower(codop[i]);
       if((strcmp(codop,"end")) != 0)
          printf("Error: No se encontro el END.\n");
   }
}

void quitarSaltosLinea(char *cadena)
{
   char *ptr;
   if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
      *ptr = '\0';
}

void listaTABOP(COD **cabeza)
{
   int car,i,pos,n;
   FILE *hc12;
   COD *ultimo = NULL;
   char *ins,*op,**dir,**maq,**cal,**x_cal,**sum;
   if((hc12 = fopen("TABOP.txt","r"))!= NULL)
   {
       while((car = fgetc(hc12))!= EOF)
       {
           i = 0;
           ins = Tabla_Operandos(hc12,INS);
           ignorarEspacios(hc12);
           op = Tabla_Operandos(hc12,OP);
           pos = ftell(hc12);
           buscarFinLinea(hc12);
           if((car = fgetc(hc12)) != '\t')
           {
               n = 0;
               fseek(hc12,pos,SEEK_SET);
               ignorarEspacios(hc12);
               dir = (char**)malloc(sizeof(char*));
               dir[i] = Tabla_Operandos(hc12,DIR);
               ignorarEspacios(hc12);
               maq = (char**)malloc(sizeof(char*));
               maq[i] = Tabla_Operandos(hc12,MAQ);
               ignorarEspacios(hc12);
               cal = (char**)malloc(sizeof(char*));
               cal[i] = Tabla_Operandos(hc12,CALCULADO);
               ignorarEspacios(hc12);
               x_cal = (char**)malloc(sizeof(char*));
               x_cal[i] = Tabla_Operandos(hc12,CALCULAR);
               ignorarEspacios(hc12);
               sum = (char**)malloc(sizeof(char*));
               sum[i] = Tabla_Operandos(hc12,TOTAL);
               buscarFinLinea(hc12);
           }
           else
           {
               n = 1;
               fseek(hc12,pos,SEEK_SET);
               dir = (char**)malloc(MAX*sizeof(char*));
               maq = (char**)malloc(MAX*sizeof(char*));
               cal = (char**)malloc(MAX*sizeof(char*));
               x_cal = (char**)malloc(MAX*sizeof(char*));
               sum = (char**)malloc(MAX*sizeof(char*));
               do
               {
                   ignorarEspacios(hc12);
                   dir[i] = Tabla_Operandos(hc12,DIR);
                   ignorarEspacios(hc12);
                   maq[i] = Tabla_Operandos(hc12,MAQ);
                   ignorarEspacios(hc12);
                   cal[i] = Tabla_Operandos(hc12,CALCULADO);
                   ignorarEspacios(hc12);
                   x_cal[i] = Tabla_Operandos(hc12,CALCULAR);
                   ignorarEspacios(hc12);
                   sum[i] = Tabla_Operandos(hc12,TOTAL);
                   buscarFinLinea(hc12);
                   i++;
               }while((car = fgetc(hc12)) == '\t');
               fseek(hc12,-1,SEEK_CUR);
           }
           if(*cabeza == NULL)
              *cabeza = crearNodo(ins,op,dir,maq,cal,x_cal,sum,n);
           else
           {
               ultimo = ultimoElemento(cabeza);
               insertarFinal(ins,op,dir,maq,cal,x_cal,sum,ultimo,n);
           }
       }
   }
   else
      printf("No se pudo abrir el archivo");
}

COD *ultimoElemento(COD **cabeza)
{
   COD *ptr;
   ptr = *cabeza;
   while(ptr->sig != NULL)
      ptr = ptr->sig;
   return ptr;
}

char *Tabla_Operandos(FILE *hc12,int tabla)
{
   int car,lon = 0,pos;
   char *cadena;
   fseek(hc12,-1,SEEK_CUR);
   pos = ftell(hc12);
   if((tabla==INS)||(tabla==OP)||(tabla==DIR)||(tabla==MAQ)||(tabla==CALCULADO)||(tabla==CALCULAR))
   {
       do
       {
           car = fgetc(hc12);
           lon++;
       }while(car != '\t' && car != EOF);
   }
   else
   {
       do
       {
           car = fgetc(hc12);
           lon++;
       }while(car != '\n' && car != EOF);
       lon--;
   }
   fseek(hc12,pos,SEEK_SET);
   cadena = (char*)calloc((lon+1),sizeof(char));
   fgets(cadena,lon+1,hc12);
   quitarSaltosLinea(cadena);
   return cadena;
}

COD *buscarCodop(COD *cabeza,char *codop)
{
   int i;
   COD *ptr;
   for(i = 0;codop[i];i++)
      codop[i] = toupper(codop[i]);
   for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
   {
       if((strcmp(ptr->instruccion,codop)) == 0)
          return ptr;
   }
   return NULL;
}

void insertarFinal(char *ins,char *op,char **dir,char **maq,char **cal,char **x_cal,char **sum,COD *ultimo,int n)
{
   ultimo->sig = crearNodo(ins,op,dir,maq,cal,x_cal,sum,n);
   ultimo->sig->sig = NULL;
   ultimo = ultimo->sig;
}

COD *crearNodo(char *ins,char *op,char **dir,char **maq,char **cal,char **x_cal,char **sum,int n)
{
   int tam,tam1,tam2,tam3,i;
   COD *x;
   x = (COD*)malloc(sizeof(COD));
   tam = strlen(ins);
   tam1 = strlen(op);
   x->instruccion = (char*)malloc((tam+1)*sizeof(char));
   x->operando = (char*)malloc((tam1+1)*sizeof(char));
   strcpy(x->instruccion,ins);
   strcpy(x->operando,op);
   x->tipo_linea = n;
   if(n == 1)
   {
       x->modo_direccionamiento = (char**)malloc(MAX*sizeof(char*));
       x->codigo_maquina = (char**)malloc(MAX*sizeof(char*));
       x->bytes_calculados = (char**)malloc(MAX*sizeof(char*));
       x->bytes_x_calcular = (char**)malloc(MAX*sizeof(char*));
       x->suma_bytes = (char**)malloc(MAX*sizeof(char*));
       for(i = 0;i < MAX;i++)
       {
           tam2 = strlen(dir[i]);
           x->modo_direccionamiento[i] = (char*)malloc((tam2+1)*sizeof(char));
           strcpy(x->modo_direccionamiento[i],dir[i]);
           tam3 = strlen(maq[i]);
           x->codigo_maquina[i] = (char*)malloc((tam3+1)*sizeof(char));
           strcpy(x->codigo_maquina[i],maq[i]);
           x->bytes_calculados[i] = (char*)malloc(sizeof(char));
           strcpy(x->bytes_calculados[i],cal[i]);
           x->bytes_x_calcular[i] = (char*)malloc(sizeof(char));
           strcpy(x->bytes_x_calcular[i],x_cal[i]);
           x->suma_bytes[i] = (char*)malloc(sizeof(char));
           strcpy(x->suma_bytes[i],sum[i]);
       }
   }
   else
   {
       x->modo_direccionamiento = (char**)malloc(sizeof(char*));
       x->codigo_maquina = (char**)malloc(sizeof(char*));
       x->bytes_calculados = (char**)malloc(sizeof(char*));
       x->bytes_x_calcular = (char**)malloc(sizeof(char*));
       x->suma_bytes = (char**)malloc(sizeof(char*));
       tam2 = strlen(dir[0]);
       x->modo_direccionamiento[0] = (char*)malloc((tam2+1)*sizeof(char));
       strcpy(x->modo_direccionamiento[0],dir[0]);
       tam3 = strlen(maq[0]);
       x->codigo_maquina[0] = (char*)malloc((tam3+1)*sizeof(char));
       strcpy(x->codigo_maquina[0],maq[0]);
       x->bytes_calculados[0] = (char*)malloc(sizeof(char));
       strcpy(x->bytes_calculados[0],cal[0]);
       x->bytes_x_calcular[0] = (char*)malloc(sizeof(char));
       strcpy(x->bytes_x_calcular[0],x_cal[0]);
       x->suma_bytes[0] = (char*)malloc(sizeof(char));
       strcpy(x->suma_bytes[0],sum[0]);
   }
   x->sig = NULL;
   return x;
}

void verificarOperando(COD *encontrado,char *operando)
{
   if((strcmp(encontrado->operando,"SI")) == 0)
   {
       if((strcmp(operando,"null")) == 0)
          printf("EL CODOP DEBE TENER OPERANDO\n");
   }
   else if((strcmp(encontrado->operando,"NO")) == 0)
   {
       if(!(strcmp(operando,"null")) == 0)
          printf("EL CODOP NO DEBE TENER OPERANDO\n");
   }
}

void imprimirInfo(COD *p)
{
   int i,num_lineas;
   printf("\n%s ",p->instruccion);
   if(p->tipo_linea == 1)
      num_lineas = MAX;
   else
      num_lineas = 1;
   for(i = 0;i < num_lineas;i++)
   {
       printf("\t%s\t",p->modo_direccionamiento[i]);
       printf("%s\t",p->codigo_maquina[i]);
       printf("%s\t",p->bytes_calculados[i]);
       printf("%s\t",p->bytes_x_calcular[i]);
       printf("%s\n",p->suma_bytes[i]);
   }
}


gracias de antemano

Saludos

Si por ejemplo yo quiero escribir en un archivo solamente dígitos del 0 al 9, que no se acepte ningun otro caracter, y sin necesidad de hacer ninguna otra validación(como leer el archivo y verificar caracter por caracter que todos sean numeros), hay alguna manera de "bloquear" algunas teclas y que no le permita al usuario ingresar caracteres que no sean numeros?? esto se podria hacer???

Saludos

tengo una funcion llamada obtener numero, a la que le paso una cadena como argumento algo como #456 y la base(hex,octal,binaria o decimal), y me regresa un int con el numero(ya sin el #) el problema es que si le ingreso el numero #65536 me imprime que el numero es 65535 y no entiendo por qué imprime eso, ya lo habia probado para numeros de otras bases y lo hacia correctamente no se por que ahora no, solo puse la funcion que me da problemas por que el codigo es un poco largo

Código (c) [Seleccionar] Expandir

int obtenerNumero(char *operando,int base)
{
   int i,potencia,num_decimal = 0,lon,entero,x = 1;
   lon = strlen(operando);
   for(i = lon-1,potencia = 0;i >= x;i--,potencia++)
   {
       if(esLetraBase16(operando[i]))
          entero = hexadecimal(operando[i]);
       else
          entero = operando[i]-48;
       num_decimal+= pow(base,potencia)*entero;
       printf("%d\n",num_decimal);
   }
   printf("[%d]",num_decimal);
   return num_decimal;
}

int hexadecimal(char caracter)
{
   int decimal;
   switch(caracter)
   {
       case 'A':case 'a':
          decimal = 10;
          break;
       case 'B':case 'b':
          decimal = 11;
          break;
       case 'C':case 'c':
          decimal = 12;
          break;
       case 'D':case 'd':
          decimal = 13;
          break;
       case 'E':case 'e':
          decimal = 14;
          break;
       case 'F':case 'f':
          decimal = 15;
          break;
       default:
          printf("!Error!\n");
   }
   return decimal;
}


me imprime

6
36
536
5536
65535

gracias de antemano

alguien que conozca alguna funcion de la libreria gmp que me permita ingresar enteros??, tengo la función mpz_set_str(num,text.c_str(),10); pero en esta el segundo miembro tiene que ser un string, y eso es lo que no quiero necesito una función que me ingrese un entero sin el uso de cadenas

gracias

Saludos

tengo una duda con respecto al uso de strcpy

si tengo una cadena por ejemplo:

char *cadena = "hola mundo";

y despues quiero cambiar el contenido de esa cadena, puedo usar el strcpy para eso??

strcpy(cadena,"lo que quieras escribir");

gracias

Saludos, acabo de instalar la libreria gmp en codeblocks para hacer un código en c++ y apenas me estoy enseñando a usar algunas de sus funciones, por ejemplo si quiero declarar una variable uso el mpz_t, que tengo entendido es el equivalente a un int(un int del tamaño que tu quieras), despues inicializo esa variable con mpz_init, y despues le asigno un valor a la variable, pero en los ejemplos que he visto para asignarle un valor tienes que ponerle por ejemplo:

mpz_set_str(num1, "123456789101112131415161718192021222324252627282930", 10);

pero qué pasa si tu quieres que sea el usuario el que le ingrese el numero que se le va a asignar a num1, en vez de escribirlo directamente en el código, cómo haría esto??

gracias

Saludos
Tengo un codigo en el que tengo que pedirle a un usuario que me ingrese un numero de tipo long long int, y después tengo que escribir ese número en un archivo de texto, lo tengo que hacer dígito por dígito porque no tengo que usar cadenas, el problema es que me imprime basura y no entiendo por qué, el problema lo tengo creo yo, en el fwrite()

Código (c) [Seleccionar] Expandir

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define MAX 40

using namespace std;

void escribirNumero(long long int numero,FILE *fd);

int main()
{
    long long int numero;
    FILE *fd;
    int digito,x;
    if((fd = fopen("Practica1.txt","w"))!= NULL)
    {
        cout << "Dame el numero: " << endl;
        cin >> numero;
        cout << "Que digito desea buscar? " << endl;
        cin >> digito;
        escribirNumero(numero,fd);
    }
    else
       printf("No se pudo crear archivo\n");
    return 0;
}

void escribirNumero(long long int numero,FILE *fd)
{
    long long int cociente,residuo;
    for(cociente = numero;cociente != 0;cociente = cociente/10)
    {
        residuo = cociente % 10;
        fwrite(&residuo,12,1,fd);
    }
}

gracias

Saludos, estoy intentando instalar y compilar la libreria GMP en Codeblocks pero no he podido,  me dijeron que descargara estos dos archivos GMP-MinGW-package y el  gmp-4.1, pero a la hora de seguir las siguientes instrucciones, en la pestaña de link libreries no encuentro la que dice compiler:

went to the build options of this project
A. Project -> Build Options
- linker: add library "gmp" (without quotation marks)
A1. Tab: Linker Settings Subtab: Link Lib..
- directories - compiler: added [GMP-MinGW-package]\include
A2. Tab: Search Directory Subtab:Compiler
- directories - linker: added [GMP-MinGW-package]\lib
A3. Tab: Search Directory Subtab:Linker

Saludos

tengo el siguiente código en el que tengo una cadena de nombre operando como la siguiente:

2983,X

y tengo que averiguar que modo de direccionamiento indexado es, las reglas son:

Modo indizado de 5 bits. en el operando se representan números decimales con un rango de -16 a 15, despues del valor debe de haber siempre una coma, y después el nombre de registro que puede ser X,Y,SP o PC

Modo indizado de 9 bits. Es lo mismo que en el de arriba solo que los numeros decimales de  rango desde -256 a -17 y de 16 a 255.

Modo indizado de 16 bits. Es lo mismo solo que tiene rango de 256 a 65535.

para estos tres modos de direccionamiento ya tengo el código que funciona bien, pero tengo que agregarle otro modo de direccionamiento un poco diferente y no se bien cómo hacerlo:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#define CERO 0
#define MAX_DIRECTO 255
#define MAX_IDX_INDIRECTO 65535
#define MIN_IDX_9BITS 16
#define MAX_IDX_9BITS 255
#define MIN_EXT_IDX16BITS 256
#define MAX_EXT_IDX16BITS 65535
#define MIN_IDX_5BITS -16
#define MAX_IDX_5BITS 15
#define MIN_9BITS_NEG -256
#define MAX_9BITS_NEG -17
#define INMEDIATO '#'
#define HEXADECIMAL '$'
#define OCTAL '@'
#define BINARIO '%'
#define INDEXADO_INDIRECTO '['

int verificarRegistro(char *cadena);
void verificarRangoIndexado_5_9_16bits(int num);
void modoDireccionamiento(char *operando);
void indexado_5bits_9bits_16bits(char *operando,int x);
int convertir_a_numero(char *cadena);

int main()
{
   char *operando = "5,X";
   modoDireccionamiento(operando);
   return 0;
}

void modoDireccionamiento(char *operando)
{
   int car;
   car = operando[0];
   switch(car)
   {
       case '-':
          x = 1;
          indexado_5bits_9bits_16bits(operando,x);
          break;
       case '0':
       case '1':
       case '2':
       case '3':
       case '4':
       case '5':
       case '6':
       case '7':
       case '8':
       case '9':
          x = 0;
          indexado_5bits_9bits_16bits(operando,x);
          break;
       default:
          printf("Error");
   }
}

void indexado_5bits_9bits_16bits(char *operando,int x)
{
   int i,j,num;
   char *cadena = NULL,c[2],*cadena2 = NULL;
   cadena = calloc(6,sizeof(char));
   cadena2 = calloc(2,sizeof(char));
   for(i = x;operando[i] != ',';i++)
   {
       sprintf(c,"%c",operando[i]);
       strcat(cadena,c);
   }
   for(j = i+1;operando[j] != '\0';j++)
   {
       sprintf(c,"%c",operando[j]);
       strcat(cadena2,c);
   }
   num = convertir_a_numero(cadena);
   if(x == 1)
      num = num*(-1);
   if(verificarRegistro(cadena2))
      verificarRangoIndexado_5_9_16bits(num);
   else
      printf("\nRegistro invalido para modo de direccionamiento indexado Indirecto\n");
}

int convertir_a_numero(char *cadena)
{
   int i,j,entero,numero = 0,lon;
   int potencias[] = {1,10,100,1000,10000};
   lon = strlen(cadena);
   for(i = 0,j = lon-1;cadena[i] != '\0';i++,j--)
   {
       entero = cadena[i]-48;
       numero += entero*potencias[j];
   }
   return numero;
}

void verificarRangoIndexado_5_9_16bits(int num)
{
   if(num >= MIN_IDX_5BITS && num <= MAX_IDX_5BITS)
      printf("Indexado de 5 bits, (IDX)\n");
   else if((num >= MIN_9BITS_NEG && num <= MAX_9BITS_NEG)||(num >= MIN_IDX_9BITS && num <= MAX_IDX_9BITS))
      printf("Indexado de 9 bits, (IDX)\n");
   else if(num >= MIN_EXT_IDX16BITS && num <= MAX_EXT_IDX16BITS)
      printf("Indexado de 16 bits, (IDX)\n");
   else
   {
       printf("Error: El rango valido de un direccionamiento indexado de 5 bits es de -16 a 15\n");
       printf("el de un direccionamiento indexado de 9 bits es de -256 a -17 y de 16 a 255\n");
       printf("y el de un direccionamiento indexado de 16 bits es de 256 a 65535\n");
   }
}

int verificarRegistro(char *cadena)
{
   int i;
   char *registro[] = {"X","Y","SP","PC"};
   for(i = 0;i < 4;i++)
   {
       if((strcmp(cadena,registro[i])) == 0)
          return 1;
   }
   return 0;
}


y el direccionamiento que le tengo que agregar dice:

Modo indexado de Pre/Post Incremento Decremento: sus valores númericos tienen rango de 1 a 8, después del valor debe de haber siempre una coma y después de la coma hay un signo positivo o negativo y despues el nombre de registro X,Y o SP, algo como: +X,-SP..O tambien puede tener primero el nombre del registro y despues el signo como: X+,SP-

Pero no tengo una idea clara de como hacer las modificaciones al codigo que ya tengo para agregarle esto,el problema es que los registros despues de la coma son diferentes a los de los otros 3 direccionamientos, alguna idea??

gracias de antemano

Saludos

estoy empezando un código en c++ en el cual tengo que usar fopen para abrir un archivo y sprintf, pero no entiendo por qué en c si me funcionan perfectamente y en c++ me aparece un error que dice:

fopen was not declared in this scope, y lo mismo dice para sprintf

Saludos, tengo un archivo que tengo que leer e imprimir en pantalla y este archivo es bastante grande, el problema es que no lo imprime completo, pero si le empiezo a quitar lineas ya me lo imprime bien, lo que hace es que mientras mas lineas le agrego, en pantalla las lineas de al principio van desapareciendo, o sea me va cortando la parte de arriba para darle lugar a las lineas que voy agregando abajo,¿a que se debe esto y como puedo solucionarlo??

gracias

[usuario pueda meter el numero maximo permitido por el sistema]

Saludos

tengo que hacer un programa que me permita ingresarle un numero mayor a 100000000, y busque si el digito x existe en el número y cuantas veces se repite, el numero no debe de ser cadena o char, en el algoritmo ya tengo pensando como hacerlo ya que pues tienes que hacer un busqueda y eso no es la parte dificil, no necesito el codigo. El problema es que me ponen de restriccion que el usuario pueda meter el numero maximo permitido por el sistema o sea hasta que se llene el buffer y que sea a prueba de error, alguna idea de como hacer esto??

gracias

Saludos, tengo el siguiente codigo que dado un operando (una cadena) tiene que verificar que modo de direccionamiento es, puede ser inmediato,directo o indexado, yo ahora estoy verificando cuando un operando es indexado, esto es: que el primer caracter sea un corchete [, que el segundo caracter sea una d ó D, que el tercer caracter sea una coma, y ya que verificaste los primeros 3 el termino que va despues de la coma puede ser X,Y,SP,PC, o sea algo como:

[D,X], [D,Y], [D,SP], [D,PC]  

el problema lo tengo en la funcion direccionamientoIndexado() que se supone que me tiene que imprimir el termino que va despues de la coma, pero cuando los operandos son: [D,SP] o [D,PC] el segundo termino lo imprime como SSP en vez de SP y no entiendo por qué. EL codigo va leyendo desde la coma hasta el corcheta ] y lo que se encuentre entre estos dos los guarda en una cadena

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define INMEDIATO '#'
#define DIRECTO '$'
#define INDEXADO '['

void modoDireccionamiento(char *operando);
void direccionamientoIndexado(char *operando);
int esNumeroBase16(char caracter);
int esLetraBase16(char caracter);
int esOctal(char caracter);
int esBinario(char caracter);

int main()
{
   char *operando = "[D,PC]";
   modoDireccionamiento(operando);
   return 0;
}

void modoDireccionamiento(char *operando)
{
   int car,esInmediato,esDirecto,esIndexado,tam,i;
   tam = strlen(operando);
   car = operando[0];
   switch(car)
   {
       case INMEDIATO:
          esInmediato = 1;
          car = operando[1];
          switch(car)
          {
              case '\0':
                 printf("Es un formato invalido para un modo de direccionamiento inmediato\n");
                 break;
              case '$':
                 for(i = 2;((i < tam)&&(esInmediato));i++)
                 {
                     if((!esNumeroBase16(operando[i]))&&(!esLetraBase16(operando[i])))
                        esInmediato = 0;
                 }
                 if(!esInmediato)
                    printf("Se encontro un digito invalido para un numero de base 16");
                 break;
              case '@':
                 for(i = 2;((i < tam)&&(esInmediato));i++)
                 {
                     if(!esOctal(operando[i]))
                        esInmediato = 0;
                 }
                 if(!esInmediato)
                    printf("Se encontro un digito invalido para un numero de base 8");
                 break;
              case '%':
                 for(i = 2;((i < tam)&&(esInmediato));i++)
                 {
                     if(!esBinario(operando[i]))
                        esInmediato = 0;
                 }
                 if(!esInmediato)
                    printf("Se encontro un digito invalido para un numero de base 2");
                 break;
              default:
                 printf("Error");
          }
          break;
       case DIRECTO:
          esDirecto = 1;
          if(operando[1] == '\0')
             printf("Es un formato invalido para un modo de direccionamiento directo\n");
          else
          {
              for(i = 2;((i < tam)&&(esDirecto));i++)
              {
                  if((!esNumeroBase16(operando[i]))&&(!esLetraBase16(operando[i])))
                     esDirecto = 0;
              }
              if(!esDirecto)
                 printf("Se encontro un digito invalido para un numero de base 16");
          }
          break;
       case INDEXADO:
          esIndexado = 1;
          car = operando[1];
          switch(car)
          {
              case '\0':
                 printf("Es un formato invalido para un modo de direccionamiento indexado\n");
                 break;
              case ',':
                 printf("No puede haber una instruccion vacia antes de la coma");
                 break;
              case 'd':
              case 'D':
                 if(operando[2] == ',')
                 {
                     direccionamientoIndexado(operando);
                        //esIndexado = 0;
                 }
                 //if(!esIndexado)
                    //printf("Es un formato invalido para direccionamiento indexado");
                 break;
              default:
                 printf("Error");
          }
          break;
       default:
          printf("Error: es un formato invalido para los modos de direccionamiento inmediato\n");
   }
}

int esNumeroBase16(char caracter)
{
   if(caracter >= '0' && caracter <= '9')
      return 1;
   else
      return 0;
}

int esLetraBase16(char caracter)
{
   if((caracter >= 'A' && caracter <= 'F')||(caracter >= 'a' && caracter <= 'f'))
      return 1;
   else
      return 0;
}

int esOctal(char caracter)
{
   if(caracter >= '0' && caracter <= '7')
      return 1;
   else
      return 0;
}

int esBinario(char caracter)
{
   if(caracter == '1' || caracter == '0')
      return 1;
   else
      return 0;
}

void direccionamientoIndexado(char *operando)
{
   int i;
   char *cadena = NULL,c[2];
   cadena = calloc(2,sizeof(char));
   for(i = 3;operando[i] != ']';i++)
   {
       sprintf(c,"%c",operando[i]);
       strcat(cadena,c);
       printf("%s",cadena);
   }
}


si alguien me pudiera decir donde esta el error se lo agradeceria mucho

Saludos, tengo una duda acerca de cómo se pueden usar unas MACROS en lenguaje C, es posible que el nombre de la MACRO tenga asignado mas de un valor?? por ejemplo:

NOMBRE '#','$','@'

Saludos, tengo el siguiente código que me tiene que abrir un archivo que se llama P1ASM.txt, pero el programa me tiene que preguntar el nombre del archivo para ver si se encuentra, pero me imprime No se pudo abrir el archivo y no entiendo por que si el archivo se encuentra en la misma carpeta donde tengo el codigo no deberia de haber errores

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 40

int main()
{
   FILE *fd;
    char nombre[MAX],archivo[MAX];
    printf("Que archivo quieres abrir: ");
    fgets(nombre,MAX,stdin);
    sprintf(archivo,"%s.txt",nombre);
    if((fd = fopen(archivo,"r"))!= NULL)
       printf("Si se encontro");
    else
       printf("No se pudo abrir el archivo");
   return 0;
}


gracias

Saludos

necesito que alguien me recomiende un libro que hable sobre la computación tolerante a fallas, especificamente de los temas capacidad de proceso y especificacion de operacion, tengo que hacer unos resúmenes de estos temas pero no encuentro informacion que me ayude

gracias de antemano