Campos empaquetados en archivo de texto

[El Loco]

Miguel,

En el documento el importe se describe como tipo "PS" y tiene una longitud de 6 bytes a partir de la posición 408:

local Importe := SubStr( cText, 408, 6 )

Sus valores en hexadecimal:

Code: Select all  Expand view  RUN

  ? "Importe:",          hb_NumToHex( Asc( SubStr( Importe, 1, 1 ) ) ),;
                          hb_NumToHex( Asc( SubStr( Importe, 2, 1 ) ) ),;
                          hb_NumToHex( Asc( SubStr( Importe, 3, 1 ) ) ),;
                          hb_NumToHex( Asc( SubStr( Importe, 4, 1 ) ) ),;
                          hb_NumToHex( Asc( SubStr( Importe, 5, 1 ) ) ),;
                          hb_NumToHex( Asc( SubStr( Importe, 6, 1 ) ) )

Aparece:

Importe: 0 0 88 ED 1B C

Sabes que valor es el que está guardado ahi ? Asi podemos averiguar el formato usado (comp3)

Buenos días a todos.
Importe: 0 0 88 ED 1B C = 52.552,70
Antonio en la dbf que te envié están los primeros 100 casos con los valores reales de cada campo
Abrazo

[Antonio Linares]

Miguel,

Importe: 0 0 88 ED 1B C = 52.552,70

En el formato anterior que tu usabas, se veia como 52 55 27 C ?

[El Loco]

Miguel,

Importe: 0 0 88 ED 1B C = 52.552,70

En el formato anterior que tu usabas, se veia como 52 55 27 C ?

Me parece que era así:
F5 F2 F5 F5 F2 F7 F2
Cuando llegue a casa te aviso

[El Loco]

Miguel,

Importe: 0 0 88 ED 1B C = 52.552,70

En el formato anterior que tu usabas, se veia como 52 55 27 C ?

Me parece que era así:
F5 F2 F5 F5 F2 F7 F2
Cuando llegue a casa te aviso

Exacto Antonio venía así en un principio, luego lo pasaron a EBCDIC y gracias a una función que realizo Daniel Garcia-Gil se podia pasar a texto/Ascii sin ningun problema.
Abrazo.
Miguel

[El Loco]

La funcion que hizo Daniel eran estas:

Code: Select all  Expand view  RUN

#pragma BEGINDUMP
#include <hbapi.h>

//
//    ASCII to EBCDIC translation table
//
static char ASCII_translate_EBCDIC [ 256 ] =
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, 0x4D,
0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61,
0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F,
0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8,
0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
0xE8, 0xE9, 0xAD, 0xE0, 0xBD, 0x5F, 0x6D,
0x7D, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
0xA8, 0xA9, 0xC0, 0x6A, 0xD0, 0xA1, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B,
0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B } ;

//
//    EBCDIC to ASCII translation table
//
static char EBCDIC_translate_ASCII [ 256 ] =
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
0x2E, 0x2E, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x2E, 0x3F,
0x20, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
0x2E, 0x2E, 0x2E, 0x3C, 0x28, 0x2B, 0x7C,
0x26, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
0x2E, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x5E,
0x2D, 0x2F, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
0x2E, 0x7C, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
0x2E, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22,
0x2E, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
0x69, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
0x2E, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
0x72, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
0x2E, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
0x7A, 0x2E, 0x2E, 0x2E, 0x5B, 0x2E, 0x2E,
0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
0x2E, 0x2E, 0x2E, 0x2E, 0x5D, 0x2E, 0x2E,
0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
0x49, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50, 0x51,
0x52, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
0x5C, 0x2E, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
0x5A, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
0x39, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E, 0x2E } ;

//
//      EBCDIC_to_ASCII (string conversion)
//
void    EBCDIC_to_ASCII ( long buf_length, char *buf_addr1, char *buf_addr2)
{   int i;
    unsigned char temp;
    for (i=0; i < buf_length; i++)
    {
        temp = (unsigned char) buf_addr1[i];
        buf_addr2[i] = EBCDIC_translate_ASCII[temp];
        buf_addr2[i+1] = '\0';              // <nul> terminate
    }
}

//
//      ASCII_to_EBCDIC (string conversion)
//
void    ASCII_to_EBCDIC ( long buf_length, char *buf_addr1, char *buf_addr2)
{   int i;
    unsigned char temp;
    for (i=0; i < buf_length; i++)
    {
        temp = (unsigned char) buf_addr1[i];
        buf_addr2[i] = ASCII_translate_EBCDIC[temp];
        buf_addr2[i+1] = '\0';              // <nul> terminate
    }
}

HB_FUNC( ASCII_TO_EBCDIC ){
    const char * src = hb_parc( 1 );
    int iLenSrc = hb_parclen( 1 );
    char * dest = hb_xgrab( iLenSrc );
    ASCII_to_EBCDIC( iLenSrc, (char*)src,  dest );
    hb_retc( dest );
}


HB_FUNC( EBCDIC_TO_ASCII ){
    const char * src = hb_parc( 1 );
    int iLenSrc = hb_parclen( 1 );
    char * dest = hb_xgrab( iLenSrc );
    EBCDIC_to_ASCII( iLenSrc, (char*)src,  dest );
    hb_retc( dest );
}

#pragma ENDDUMP


 

[Antonio Linares]

Aqui esta la función adaptada a Harbour, pero aun algo falla:

Code: Select all  Expand view  RUN

function Main()

   local cText := hb_MemoRead( "Prueba.txt" )

   local aResult := Unpack( SubStr( cText, 408, 6 ), 2 )

   ? aResult[ 1 ]
   ? aResult[ 2 ]
   ? aResult[ 3 ]
   ? aResult[ 4 ]
   ? aResult[ 5 ]

return nil

#pragma BEGINDUMP

#include <hbapi.h>
#include <hbapierr.h>

typedef unsigned char byte;
typedef enum { false, true } bool;

int nibble( byte * inp, int nibbleNo)
{
   int b = inp[ strlen( ( char * ) inp ) - 1 - nibbleNo / 2];
   return (nibbleNo % 2 == 0) ? (b & 0x0000000F) : (b >> 4);
}

void Unpack( byte * inp, int scale )
{
   long lo = 0;
   long mid = 0;
   long hi = 0;
   bool isNegative;
   long intermediate;
   long carry;
   long digit;
   int j;

   // this nybble stores only the sign, not a digit.  
   // "C" hex is positive, "D" hex is negative, and "F" hex is unsigned.
   switch( nibble(inp, 0))
   {
      case 0x0D:
            isNegative = true;
            break;
      case 0x0F:
      case 0x0C:
            isNegative = false;
            break;
      default:
            hb_errRT_BASE_SubstR( EG_ARG, 1089, "Bad sign nibble", HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
   }

   for ( j = strlen( ( char * ) inp ) * 2 - 1; j > 0; j--)
   {
      // multiply by 10
      intermediate = lo * 10;
      lo = intermediate & 0xffffffff;
      carry = intermediate >> 32;
      intermediate = mid * 10 + carry;
      mid = intermediate & 0xffffffff;
      carry = intermediate >> 32;
      intermediate = hi * 10 + carry;
      hi = intermediate & 0xffffffff;
      carry = intermediate >> 32;
      // By limiting input length to 14, we ensure overflow will never occur

      digit = nibble(inp, j);
      if (digit > 9)
      {
         hb_errRT_BASE_SubstR( EG_ARG, 1089, "Bad digit", HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS );
      }
      intermediate = lo + digit;
      lo = intermediate & 0xffffffff;
      carry = intermediate >> 32;
      if (carry > 0)
      {
            intermediate = mid + carry;
            mid = intermediate & 0xffffffff;
            carry = intermediate >> 32;
            if (carry > 0)
            {
               intermediate = hi + carry;
               hi = intermediate & 0xffffffff;
               carry = intermediate >> 32;
               // carry should never be non-zero. Back up with validation
            }
      }
   }

   hb_reta( 5 );
   hb_storvnl( -1, 1, (int) lo );
   hb_storvnl( -1, 2, (int) mid );
   hb_storvnl( -1, 3, (int) hi );
   hb_storvnl( -1, 4, isNegative );
   hb_storvnl( -1, 5, (byte) scale );
}

HB_FUNC( UNPACK )
{
   byte * inp = hb_parc( 1 );
   int scale = hb_parnl( 2 );

   Unpack( inp, scale );
}

#pragma ENDDUMP

[Antonio Linares]

Siguiendo la lógica de ese código lo primero que tenemos que hacer es obtener los "nibbles" (cuatro bits) mitad superior y mitad inferior de un byte:

Code: Select all  Expand view  RUN

function Main()

   local cText := hb_MemoRead( "Prueba.txt" )
   local cCode := SubStr( cText, 408, 6 )
   local n, cHex, cSigno

   for n = 1 to Len( cCode )  // mostramos el codigo comp3 a analizar
      cHex = hb_NumToHex( Asc( SubStr( cCode, n, 1 ) ) )
      if Len( cHex ) < 2
        cHex = "0" + cHex
      endif  
      ?? cHex, " "
   next  

   // verificamos que obtenemos los nibbles correctos, comparando con lo anterior mostrado
   for n = 1 to Len( cCode ) * 2   // 6 bytes son 12 nibbles
      ? Nibble( cCode, n )
   next  

   ? "es un valor " + Signo( cCode )

return nil

function Signo( cCode )

   local cSigno := Nibble( cCode, 12 )
   local cResult

   do case
      case cSigno == "C"
         cResult = "positivo"

      case cSigno == "D"
         cResult = "negativo"

      case cSigno == "H"
         cResult = "hex"

      otherwise
         cResult = "desconocido"
   endcase

return cResult        

function Nibble( cValue, nPos )

   local cHex := hb_NumToHex( Asc( SubStr( cValue, Int( nPos / 2 ) + ;
                              If( nPos % 2 == 0, 0, 1 ), 1 ) ) )

   if Len( cHex ) < 2
      cHex = "0" + cHex
   endif                              

return If( nPos % 2 == 0, Right( cHex, 1 ), Left( cHex, 1 ) )

Resultado:

C:\soporte\MiguelAngel>comp3
00 00 88 ED 1B 0C
0
0
0
0
8
8
E
D
1
B
0
C
es un valor positivo

Ya obtenemos bien los nibbles, ahora el siguiente paso...

[Antonio Linares]

Miguel,

> Importe: 0 0 88 ED 1B C = 52.552,70

Estas completamente seguro de eso ?

En decimal obtenemos: 0, 0, 136, 237, 27, 12

el 12 lo descartamos porque es el signo. Pero como podemos obtener 52.552,70 usando 136, 237 y 27 ???

[El Loco]

Miguel,

> Importe: 0 0 88 ED 1B C = 52.552,70

Estas completamente seguro de eso ?

En decimal obtenemos: 0, 0, 136, 237, 27, 12

el 12 lo descartamos porque es el signo. Pero como podemos obtener 52.552,70 usando 136, 237 y 27 ???

Buenos días Antonio... si es 52.552,70 totalmente seguro.

[El Loco]

los siguientes tres dentro de la secuencia de 30 ocurrencias dentro del mismo registro son estas
00002D200425 = 60.403,76
0000097270B1 = 59.99,72
0000CA45CD0C = 87.13,00
Abrazo
Miguel

[Antonio Linares]

Miguel,

Ese formato no tiene nada que ver con el comp3.

O es una nueva versión de comp3 ?

[El Loco]

Miguel,

Ese formato no tiene nada que ver con el comp3.

O es una nueva versión de comp3 ?

Mira Antonio por la especificaciones que me dieron supuestamente si
Hoy a la noche cuando llegue a casa de trabajar controlo o mejor mañana me comunico con esta gente y te comento
Igualmente mil gracias por el trabajo que hicistre GRACIAS
Abrazo
Miguel

[El Loco]

Miguel,

Ese formato no tiene nada que ver con el comp3.

O es una nueva versión de comp3 ?

Mira Antonio por la especificaciones que me dieron supuestamente si
Hoy a la noche cuando llegue a casa de trabajar controlo o mejor mañana me comunico con esta gente y te comento
Igualmente mil gracias por el trabajo que hicistre GRACIAS
Abrazo
Miguel

Buenas.... Antonio ya llame y mande mensajes a esta gente para que aclare un poco más por este tipo de campo....y todavía nada ...habra que esperar.
Aviso cualquier novedad .
Igualmente te reitero infinitas gracias por tu apoyo.
Abrazo
Miguel

[El Loco]

Miguel,

Ese formato no tiene nada que ver con el comp3.

O es una nueva versión de comp3 ?

Mira Antonio por la especificaciones que me dieron supuestamente si
Hoy a la noche cuando llegue a casa de trabajar controlo o mejor mañana me comunico con esta gente y te comento
Igualmente mil gracias por el trabajo que hicistre GRACIAS
Abrazo
Miguel

Buenas.... Antonio ya llame y mande mensajes a esta gente para que aclare un poco más por este tipo de campo....y todavía nada ...habra que esperar.
Aviso cualquier novedad .
Igualmente te reitero infinitas gracias por tu apoyo.
Abrazo
Miguel

[El Loco]

Antonio todavía no he tenido ninguna novedad en concreto de esta gente, pero como vos suponías, este campo tiene una codificación especial que desconocen por el momento.
Así que sigo investigando el tema.
Cualquier novedad te aviso.
Gracias por todo.
Abrazo
Miguel