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??

es para el hc12 de motorola

gracias

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".

#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

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

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.

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

muchas gracias Carloswaldo por tu respuesta, una ultima duda si yo tengo :

3.2 Mostrar los IDs de los clientes, sin repetirse, que en algún pedido hayan comprado más de dos ejemplares de un mismo producto (cantidad) durante 1999, utilizando subconsultas.

SELECT DISTINCT id_cliente
FROM info_clientes,partidas_pedidos
WHERE id_cliente=cliente AND cantidad > 2 AND fecha_pedido LIKE ‘1999%’;

aqui tengo que utilizar la tabla de info_clientes y la de partidas_pedidos, pero me aparece un error por donde tengo el id_cliente y no se por que? si creo que la subconsulta esta bien hecha

muchas gracias por sus respuestas

El arreglo lo necesito para una función como esta:

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

para que en la condicion operando != aqui pueda ser o '\0' o la coma

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