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

 

 


Tema destacado: AIO elhacker.NET 2021 Compilación herramientas análisis y desinfección malware


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  cls_Byte ( Funciones Binarias ) ByteReplace, ByteSplit, ByteMid, ByteExits...
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: cls_Byte ( Funciones Binarias ) ByteReplace, ByteSplit, ByteMid, ByteExits...  (Leído 1,987 veces)
BlackZeroX
Wiki

Desconectado Desconectado

Mensajes: 3.148


I'Love...!¡.


Ver Perfil WWW
cls_Byte ( Funciones Binarias ) ByteReplace, ByteSplit, ByteMid, ByteExits...
« en: 27 Abril 2011, 00:32 am »

.
Tal vez a alguien le sirva esta clase que me hice para manipular un conjunto de bytes similar como vb6 las cadenas y evitarme el ajetreo de detectar los desgraciados memory leak que a mas de uno nos frustan el desarrollo/ejecucion de un programa, aun que por hay deben haber algunos agujeros... pero aun así ya funciona y eso es lo que me interesaba realmente. para mi trabajo de universidad.

Disculpen po no usar new() ni delete() para cargar las clases.

cls_byte.h
Código
  1.  
  2. #ifndef _CLS_BYTE_H_
  3. #define _CLS_BYTE_H_
  4.  
  5. #include <fstream>
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include "Bytes/modutiles.h"
  9.  
  10. //    #include <stdbool.h> <-- C ANSI... (C99)CLS_BYTE_CPP
  11.  
  12. class cls_byte;
  13.  
  14. #ifndef Struct_clsByte_
  15. #define Struct_clsByte_
  16. struct Struct_clsByte
  17. {
  18.    cls_byte    *pbyt_class;
  19.    size_t      szt_count;
  20. };
  21. #endif  // Struct_clsByte_
  22.  
  23. class cls_byte
  24. {
  25. private:
  26.    size_t        szt_len;
  27.    Byte          *pbyt_data;
  28. public:
  29.    cls_byte();
  30.    ~cls_byte();
  31.  
  32.    size_t           Getlen ( );
  33.    Byte       *GetBytesPtr ( );
  34.    struct Struct_Byte *GetBytes ( );
  35.  
  36.    Byte          *SetBytes ( Byte *pByt_Bytes , size_t szt_lnBytes );  // ok
  37.    Byte          *SetBytes ( cls_byte     *pclsbyteFind );
  38.    Byte          *SetBytes ( Struct_Byte  *pclsbyteFind );             // ok
  39.  
  40.    bool            SetBytesFromFile( const char *pcchr );
  41.    bool            SetBytesFromFile( const char *pcchr , size_t szt_ini );
  42.    bool            SetBytesFromFile( const char *pcchr , size_t szt_ini , long lng_len );
  43.  
  44.    cls_byte       *Mid     ( size_t szt_start , size_t szt_len );
  45.    cls_byte       *Mid     ( size_t szt_start );
  46.  
  47.    Struct_clsByte *Split   ( Byte *pbyt_delimiter , size_t szt_lndelimiter , long lng_limit );
  48.    Struct_clsByte *Split   ( Byte *pbyt_delimiter , size_t szt_lndelimiter );
  49.    Struct_clsByte *Split   ( cls_byte *pclsbytelim , long lng_limit );
  50.    Struct_clsByte *Split   ( cls_byte *pclsbytelim );
  51.  
  52.    cls_byte       *Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement );
  53.    cls_byte       *Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement , size_t szt_Start );
  54.    cls_byte       *Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement , size_t szt_Start , long lng_Count );
  55.    cls_byte       *Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacemente , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare );
  56.    cls_byte       *Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement );
  57.    cls_byte       *Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start );
  58.    cls_byte       *Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count );
  59.    cls_byte       *Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare );
  60.    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacemente );
  61.    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacemente , size_t szt_Start );
  62.    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacemente , size_t szt_Start , long lng_Count );
  63.    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacemente , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare );
  64.    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , Byte *pByt_Replacement , size_t szt_lnReplacement );
  65.    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start );
  66.    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count );
  67.    cls_byte       *Replace ( Byte *pByt_Find , size_t szt_lnFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare );
  68.  
  69.    size_t            Index ( cls_byte *pclsbyte );
  70.    size_t            Index ( cls_byte *pclsbyte , size_t szt_Start );
  71.    size_t            Index ( cls_byte *pclsbyte , size_t szt_Start , e_CompareMethod enum_Compare );
  72.    size_t            Index ( Byte *pByt_Find , size_t szt_lsf );
  73.    size_t            Index ( Byte *pByt_Find , size_t szt_lsf , size_t szt_Start );
  74.    size_t            Index ( Byte *pByt_Find , size_t szt_lsf , size_t szt_Start , e_CompareMethod enum_Compare );
  75.  
  76.    bool              Exits ( cls_byte *pclsbyte );
  77.    bool              Exits ( cls_byte *pclsbyte , size_t szt_Start );
  78.    bool              Exits ( cls_byte *pclsbyte , size_t szt_Start , long lng_interval );
  79.    bool              Exits ( cls_byte *pclsbyte , size_t szt_Start , long lng_interval , e_CompareMethod enum_Compare );
  80.    bool              Exits ( Byte *pByt_Find , size_t szt_lsf );
  81.    bool              Exits ( Byte *pByt_Find , size_t szt_lsf , size_t szt_Start );
  82.    bool              Exits ( Byte *pByt_Find , size_t szt_lsf , size_t szt_Start , long lng_interval );
  83.    bool              Exits ( Byte *pByt_Find , size_t szt_lsf , size_t szt_Start , long lng_interval , e_CompareMethod enum_Compare );
  84. };
  85. //    #include "cls_byte.cpp"
  86. #endif // CLS_BYTE_H
  87.  
  88.  

cls_byte.cpp
Código
  1.  
  2. #ifndef _CLS_BYTE_CPP
  3. #define _CLS_BYTE_CPP 1
  4.  
  5.    #include "cls_byte.h"
  6.  
  7.    cls_byte::cls_byte()
  8.    {
  9.        this->szt_len   = 0;
  10.        this->pbyt_data  = NULL;
  11.    }
  12.  
  13.    cls_byte::~cls_byte()
  14.        { setnewptrf<Byte*>( this->pbyt_data , NULL ); }
  15.  
  16.    size_t cls_byte::Getlen()
  17.        { return this->szt_len; }
  18.  
  19.    Byte *cls_byte::GetBytesPtr()
  20.        { return this->pbyt_data; }
  21.  
  22.    bool cls_byte::SetBytesFromFile(const char *pcchr)
  23.        { return this->SetBytesFromFile( pcchr , 0 , -1 ); }
  24.    bool cls_byte::SetBytesFromFile(const char *pcchr, size_t szt_ini)
  25.        { return this->SetBytesFromFile( pcchr , szt_ini , -1 ); }
  26.    bool cls_byte::SetBytesFromFile(const char *pcchr, size_t szt_ini, long lng_len)
  27.        {
  28.            FILE            *hfile              = fopen( pcchr , "r+b" );
  29.            Struct_Byte     stbyt_data          = { NULL , 0 };
  30.            size_t          szt_end             = 0;
  31.  
  32.            if ( hfile != NULL )
  33.            {
  34.                stbyt_data.szt_lenbytes             = flen( hfile );
  35.                if ( lng_len <= -1 )
  36.                    lng_len                             = stbyt_data.szt_lenbytes;
  37.                szt_end = 0;
  38.                if ( fix_numbers_range<size_t>( &szt_ini , &szt_end , &lng_len , NULL ,  0 , stbyt_data.szt_lenbytes-1 ) == true )
  39.                {
  40.                    stbyt_data.pbyt_bytes       = (Byte*)malloc(sizeof(Byte)*lng_len);
  41.                    fseek       ( hfile , (long)szt_ini , SEEK_SET);
  42.                    fread       ( (char*)stbyt_data.pbyt_bytes , 1 , lng_len ,  hfile );
  43.                }
  44.                stbyt_data.szt_lenbytes     = (size_t)lng_len;
  45.                fclose      ( hfile );
  46.                this->SetBytes( &stbyt_data );
  47.            }
  48.  
  49.        }
  50.    Byte *cls_byte::SetBytes(Struct_Byte *pclsbyteFind)
  51.        { return this->SetBytes( pclsbyteFind->pbyt_bytes , pclsbyteFind->szt_lenbytes ); }
  52.    Byte *cls_byte::SetBytes(cls_byte *pclsbyteFind)
  53.        { return this->SetBytes( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() ); }
  54.    Byte *cls_byte::SetBytes(Byte *pByt_Bytes, size_t szt_lnBytes)
  55.    {
  56.        this->szt_len = szt_lnBytes;
  57.        if ( setnewptrf<Byte*>( this->pbyt_data , ByteClone( pByt_Bytes , this->szt_len ) ) == NULL)
  58.        {
  59.            this->szt_len = 0;
  60.            return pByt_Bytes;
  61.        }
  62.        return NULL;
  63.    }
  64.  
  65.    Struct_Byte *cls_byte::GetBytes()
  66.    {
  67.        struct Struct_Byte *pstrbyt_ret = (Struct_Byte*)malloc(sizeof(Struct_Byte));
  68.        pstrbyt_ret->pbyt_bytes = ByteClone( this->pbyt_data , this->szt_len );
  69.        pstrbyt_ret->szt_lenbytes =  this->szt_len;
  70.        if ( pstrbyt_ret->pbyt_bytes == NULL )
  71.            pstrbyt_ret->szt_lenbytes = 0;
  72.        return pstrbyt_ret;
  73.    }
  74.  
  75.    size_t cls_byte::Index(Byte *pByt_Find, size_t szt_lsf)
  76.        { return ByteIndex( this->pbyt_data , this->szt_len  ,pByt_Find , szt_lsf ); }
  77.    size_t cls_byte::Index(Byte *pByt_Find, size_t szt_lsf, size_t szt_Start)
  78.        { return ByteIndex( this->pbyt_data , this->szt_len , pByt_Find , szt_lsf , szt_Start ); }
  79.    size_t cls_byte::Index(Byte *pByt_Find, size_t szt_lsf, size_t szt_Start, e_CompareMethod enum_Compare)
  80.        { return ByteIndex( this->pbyt_data , this->szt_len , pByt_Find , szt_lsf , szt_Start , enum_Compare ); }
  81.    size_t cls_byte::Index(cls_byte *pclsbyte)
  82.        { return ByteIndex( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len ); }
  83.    size_t cls_byte::Index(cls_byte *pclsbyte, size_t szt_Start)
  84.        { return ByteIndex( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len , szt_Start ); }
  85.    size_t cls_byte::Index(cls_byte *pclsbyte, size_t szt_Start, e_CompareMethod enum_Compare)
  86.        { return ByteIndex( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len , szt_Start , enum_Compare ); }
  87.  
  88.  
  89.    bool cls_byte::Exits(cls_byte *pclsbyte)
  90.        { return ByteExits( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len ); }
  91.    bool cls_byte::Exits(cls_byte *pclsbyte, size_t szt_Start)
  92.        { return ByteExits( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len , szt_Start ); }
  93.    bool cls_byte::Exits(cls_byte *pclsbyte, size_t szt_Start, long lng_interval)
  94.        { return ByteExits( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len , szt_Start , lng_interval ); }
  95.    bool cls_byte::Exits(cls_byte *pclsbyte, size_t szt_Start, long lng_interval, e_CompareMethod enum_Compare)
  96.        { return ByteExits( this->pbyt_data , this->szt_len , pclsbyte->pbyt_data , pclsbyte->szt_len , szt_Start , lng_interval , enum_Compare ); }
  97.    bool cls_byte::Exits(Byte *pByt_Find, size_t szt_lsf)
  98.        { return ByteExits( this->pbyt_data , this->szt_len , pByt_Find , szt_lsf ); }
  99.    bool cls_byte::Exits(Byte *pByt_Find, size_t szt_lsf, size_t szt_Start)
  100.        { return ByteExits( this->pbyt_data , this->szt_len , pByt_Find , szt_lsf , szt_Start ); }
  101.    bool cls_byte::Exits(Byte *pByt_Find, size_t szt_lsf, size_t szt_Start, long lng_interval)
  102.        { return ByteExits( this->pbyt_data , this->szt_len , pByt_Find , szt_lsf , szt_Start , lng_interval ); }
  103.    bool cls_byte::Exits(Byte *pByt_Find, size_t szt_lsf, size_t szt_Start, long lng_interval, e_CompareMethod enum_Compare)
  104.        { return ByteExits( this->pbyt_data , this->szt_len , pByt_Find , szt_lsf , szt_Start , lng_interval , enum_Compare ); }
  105.  
  106.  
  107.  
  108.    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement )
  109.        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , 0 , -1 , BINARY ); }
  110.    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement , size_t szt_Start )
  111.        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , szt_Start , -1 , BINARY ); }
  112.    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement , size_t szt_Start , long lng_Count )
  113.        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , szt_Start , lng_Count , BINARY ); }
  114.    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , cls_byte *pclsbyteReplacement , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare )
  115.        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , szt_Start , lng_Count , enum_Compare ); }
  116.    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement )
  117.        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pByt_Replacement , szt_lnReplacement , 0 , -1 , BINARY ); }
  118.    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start )
  119.        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pByt_Replacement , szt_lnReplacement , szt_Start , -1 , BINARY ); }
  120.    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count )
  121.        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pByt_Replacement , szt_lnReplacement , szt_Start , lng_Count , BINARY ); }
  122.    cls_byte *cls_byte::Replace ( cls_byte *pclsbyteFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare )
  123.        { return this->Replace( pclsbyteFind->GetBytesPtr() , pclsbyteFind->Getlen() , pByt_Replacement , szt_lnReplacement , szt_Start , lng_Count , enum_Compare ); }
  124.    cls_byte *cls_byte::Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacement )
  125.        { return this->Replace( pByt_Find , szt_lnFind , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , 0 , -1 , BINARY ); }
  126.    cls_byte *cls_byte::Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacement , size_t szt_Start )
  127.        { return this->Replace( pByt_Find , szt_lnFind , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , szt_Start , -1 , BINARY ); }
  128.    cls_byte *cls_byte::Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacement , size_t szt_Start , long lng_Count )
  129.        { return this->Replace( pByt_Find , szt_lnFind , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , szt_Start , lng_Count , BINARY ); }
  130.    cls_byte *cls_byte::Replace ( Byte *pByt_Find , size_t szt_lnFind , cls_byte *pclsbyteReplacement , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare )
  131.        { return this->Replace( pByt_Find , szt_lnFind , pclsbyteReplacement->GetBytesPtr() , pclsbyteReplacement->Getlen() , szt_Start , lng_Count , enum_Compare ); }
  132.    cls_byte *cls_byte::Replace(Byte *pByt_Find, size_t szt_lnFind, Byte *pByt_Replacement, size_t szt_lnReplacement)
  133.        { return this->Replace( pByt_Find , szt_lnFind , pByt_Replacement , szt_lnReplacement , 0 , -1 , BINARY ); }
  134.    cls_byte *cls_byte::Replace(Byte *pByt_Find, size_t szt_lnFind, Byte *pByt_Replacement, size_t szt_lnReplacement, size_t szt_Start)
  135.        { return this->Replace( pByt_Find , szt_lnFind , pByt_Replacement , szt_lnReplacement , szt_Start , -1 , BINARY ); }
  136.    cls_byte *cls_byte::Replace(Byte *pByt_Find, size_t szt_lnFind, Byte *pByt_Replacement, size_t szt_lnReplacement, size_t szt_Start, long lng_Count)
  137.        { return this->Replace( pByt_Find , szt_lnFind , pByt_Replacement , szt_lnReplacement , szt_Start , lng_Count , BINARY ); }
  138.    cls_byte *cls_byte::Replace(Byte *pByt_Find, size_t szt_lnFind, Byte *pByt_Replacement, size_t szt_lnReplacement, size_t szt_Start, long lng_Count, e_CompareMethod enum_Compare)
  139.        {
  140.            cls_byte            *cls_Ret    = (cls_byte*)malloc(sizeof(cls_byte));
  141.            Struct_Byte         *pByt_Ret   = NULL;
  142.            Byte                *pByt_ClnF  = ByteClone ( pByt_Find , szt_lnFind );
  143.            Byte                *pByt_ClnR  = ByteClone ( pByt_Replacement , szt_lnReplacement );
  144.  
  145.            pByt_Ret                = ByteReplace( this->pbyt_data , this->szt_len , pByt_ClnF , szt_lnFind , pByt_ClnR , szt_lnReplacement , szt_Start , lng_Count , enum_Compare );
  146.            cls_Ret->SetBytes       ( pByt_Ret );
  147.  
  148.            setnewptrf<Byte*>        ( pByt_ClnF , NULL );
  149.            setnewptrf<Byte*>        ( pByt_ClnR , NULL );
  150.            setnewptrf<Byte*>        ( pByt_Ret->pbyt_bytes , NULL );
  151.            setnewptrf<Struct_Byte*> ( pByt_Ret , NULL );
  152.  
  153.            return cls_Ret;
  154.        }
  155.    cls_byte *cls_byte::Mid(size_t szt_start)
  156.        { return this->Mid   ( szt_start , this->szt_len ); }
  157.    cls_byte *cls_byte::Mid(size_t szt_start, size_t szt_len)
  158.        {
  159.            cls_byte            *cls_Ret    = (cls_byte*)malloc(sizeof(cls_byte));
  160.            Struct_Byte         *pByt_Ret   = NULL;
  161.  
  162.            pByt_Ret                = ByteMid ( this->pbyt_data , this->szt_len , szt_start , szt_len );
  163.            cls_Ret->SetBytes       ( pByt_Ret );
  164.  
  165.            setnewptrf<Byte*>        ( pByt_Ret->pbyt_bytes , NULL );
  166.            setnewptrf<Struct_Byte*> ( pByt_Ret , NULL );
  167.  
  168.            return cls_Ret;
  169.        }
  170.  
  171.    Struct_clsByte *cls_byte::Split(Byte *pbyt_delimiter, size_t szt_lndelimiter)
  172.        { return this->Split ( pbyt_delimiter , szt_lndelimiter , -1 ); }
  173.    Struct_clsByte *cls_byte::Split(Byte *pbyt_delimiter, size_t szt_lndelimiter, long lng_limit)
  174.        {
  175.            Struct_clsByte      *cls_Ret    = (Struct_clsByte*)malloc(sizeof(Struct_clsByte));
  176.            Struct_Byte_Split   *pByt_Ret   = NULL;
  177.            Byte                *pByt_Clone = ByteClone ( pbyt_delimiter , szt_lndelimiter );
  178.  
  179.            pByt_Ret                = ByteSplit ( this->pbyt_data , this->szt_len , pByt_Clone , szt_lndelimiter , lng_limit );
  180.  
  181.            cls_Ret->szt_count      = 0;
  182.            cls_Ret->pbyt_class     = (cls_byte*)malloc(sizeof(cls_byte)*pByt_Ret->szt_ln);
  183.  
  184.            for ( cls_Ret->szt_count=0 ; cls_Ret->szt_count<pByt_Ret->szt_ln ; ++cls_Ret->szt_count )
  185.            {
  186.                cls_Ret->pbyt_class[ cls_Ret->szt_count ].SetBytes( pByt_Ret->Struct[ cls_Ret->szt_count ] );
  187.                setnewptrf<Byte*>        ( pByt_Ret->Struct[ cls_Ret->szt_count ]->pbyt_bytes , NULL );
  188.                setnewptrf<Struct_Byte*> ( pByt_Ret->Struct[ cls_Ret->szt_count ] , NULL );
  189.            }
  190.  
  191.            setnewptrf<Byte*>                ( pByt_Clone , NULL );
  192.            setnewptrf<Struct_Byte_Split*>   ( pByt_Ret , NULL );
  193.  
  194.            return cls_Ret;
  195.        }
  196.    Struct_clsByte *cls_byte::Split(cls_byte *pclsbytelim)
  197.        { return this->Split ( pclsbytelim->GetBytesPtr() , pclsbytelim->Getlen() , -1 ); }
  198.    Struct_clsByte *cls_byte::Split(cls_byte *pclsbytelim, long lng_limit)
  199.        { return this->Split ( pclsbytelim->GetBytesPtr() , pclsbytelim->Getlen() , lng_limit ); }
  200.  
  201. #endif
  202.  
  203.  

Temibles Lunas!¡.


En línea

The Dark Shadow is my passion.
[Zero]
Wiki

Desconectado Desconectado

Mensajes: 1.082


CALL DWORD PTR DS:[0]


Ver Perfil WWW
Re: cls_Byte ( Funciones Binarias ) ByteReplace, ByteSplit, ByteMid, ByteExits...
« Respuesta #1 en: 27 Abril 2011, 14:04 pm »

Muy útil, y buen código, aunque no estaría de más algún comentario  :P.

Saludos


En línea


“El Hombre, en su orgullo, creó a Dios a su imagen y semejanza.”
Nietzsche
BlackZeroX
Wiki

Desconectado Desconectado

Mensajes: 3.148


I'Love...!¡.


Ver Perfil WWW
Re: cls_Byte ( Funciones Binarias ) ByteReplace, ByteSplit, ByteMid, ByteExits...
« Respuesta #2 en: 27 Abril 2011, 21:17 pm »

.
[Zero]... amm los comentarios natos estan en estos archivos, ya que la anterior clase solo es para manipular una estructura de datos que encapsula informacion y metodos/funciones aplicables a si misma, aun hay me dio un poco de peresa meter comentarios en los siguientes codigos estan un poco mas explicados.

Se me olvido poner el código madre ( modutiles.cpp y modutiles.h ).

modutiles.h
Código
  1.  
  2. #ifndef _MODUTILES_H
  3. #define _MODUTILES_H
  4.  
  5. #include <stdlib.h>
  6. #include <stdio.h>
  7. #include <string.h>
  8. #include <iostream>
  9.  
  10. using namespace std;
  11.  
  12. #ifndef Byte_
  13.    #define Byte_
  14.    typedef unsigned char Byte;
  15. #endif  // Byte_
  16.  
  17. #ifndef e_CompareMethod_
  18. #define e_CompareMethod_
  19. enum e_CompareMethod{
  20.    BINARY          = 1,
  21.    TEXTCOMPARE     = 2
  22. };
  23. #endif  //e_CompareMethod_
  24.  
  25. #ifndef Struct_Byte_
  26. #define Struct_Byte_
  27. struct Struct_Byte
  28. {
  29.    Byte        *pbyt_bytes;
  30.    size_t      szt_lenbytes;
  31. };
  32. #endif  // Struct_Byte_
  33.  
  34. #ifndef Struct_Byte_Split_
  35. #define Struct_Byte_Split_
  36. struct Struct_Byte_Split
  37. {
  38.    struct Struct_Byte  **Struct;
  39.    size_t              szt_ln;
  40. };
  41. #endif  // Struct_Byte_Split_
  42.  
  43.  
  44. size_t              ByteIndex       ( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find, size_t szt_lsf, size_t szt_Start, e_CompareMethod enum_Compare );
  45. size_t              ByteIndex       ( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find, size_t szt_lsf, size_t szt_Start );
  46. size_t              ByteIndex       ( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find, size_t szt_lsf );
  47. bool                ByteExits       ( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find , size_t szt_lsf , size_t szt_Start , long lng_interval, e_CompareMethod enum_Compare);
  48. bool                ByteExits       ( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find , size_t szt_lsf , size_t szt_Start , long lng_interval);
  49. bool                ByteExits       ( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find , size_t szt_lsf , size_t szt_Start);
  50. bool                ByteExits       ( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find , size_t szt_lsf );
  51. Struct_Byte         *ByteReplace    ( Byte *pByt_Bytes , size_t szt_lnBytes , Byte *pByt_Find , size_t szt_lnFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count , e_CompareMethod enum_Compare );
  52. Struct_Byte         *ByteReplace    ( Byte *pByt_Bytes , size_t szt_lnBytes , Byte *pByt_Find , size_t szt_lnFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start , long lng_Count );
  53. Struct_Byte         *ByteReplace    ( Byte *pByt_Bytes , size_t szt_lnBytes , Byte *pByt_Find , size_t szt_lnFind , Byte *pByt_Replacement , size_t szt_lnReplacement , size_t szt_Start );
  54. Struct_Byte         *ByteReplace    ( Byte *pByt_Bytes , size_t szt_lnBytes , Byte *pByt_Find , size_t szt_lnFind , Byte *pByt_Replacement , size_t szt_lnReplacement );
  55. Byte                *reallocpp      ( Byte *pvoid_in , size_t szt_a, size_t szt_n );
  56. Byte                *ByteClone      ( Byte *pByt_Bytes , size_t szt_lenbytes );
  57. Byte                CmpCharMTLTM    ( Byte *chr_v );
  58. Struct_Byte         *ByteMid        ( Byte* pbyt_str , size_t szt_lnstr , size_t szt_start , size_t szt_len );
  59. Struct_Byte_Split   *ByteSplit      ( Byte *pbyt_str , size_t szt_lnstr , Byte *pbyt_delimiter , size_t szt_lndelimiter , long lng_limit );
  60. Struct_Byte_Split   *ByteSplit      ( Byte *pbyt_str , size_t szt_lnstr , Byte *pbyt_delimiter , size_t szt_lndelimiter );
  61. size_t              flen            ( FILE *pFl );
  62.  
  63. template <class T>
  64. T setnewptrd( T &old , T New , bool array ) {
  65.    if ( old != NULL ) {
  66.        if ( array == false ) {
  67.            delete old;
  68.        } else {
  69.            delete[] old;
  70.        }
  71.    }
  72.    return old = New;
  73. }
  74.  
  75. template <class T>
  76. T setnewptrf( T &old , T New ) {
  77.    if ( &old != NULL ) {
  78.        free (old);
  79.    }
  80.    return old = New;
  81. }
  82.  
  83. template <class T>
  84. T setnewptrf( T &old , T New , size_t sztln ) {
  85.    if ( &old != NULL ) {
  86.        for (;sztln>0;--sztln) {
  87.            free (&old[sztln-1]);
  88.        }
  89.        free ( old );
  90.    }
  91.    //return old = New;
  92. }
  93.  
  94.  
  95.  
  96. template <class T>
  97. T rectific_num( T t_val , T t_min , T t_max )
  98. /**
  99.     Corrige [vVal] con respecto a un minimo y a un maximo valor.
  100.     By BlackZeroX ( http://Infrangelux.sytes.net/ )
  101. **/
  102. {
  103.    if (t_val < t_min)
  104.        return t_min;
  105.    else if ( t_val > t_max )
  106.        return t_max;
  107.    else
  108.        return t_val;
  109. }
  110. template <class T>
  111. bool fix_numbers_range( T *t_ini , T *t_end , long *lng_ln , long *lng_distance , T t_min , T t_max )
  112. /**
  113.     Corrige los rangos de [t_ini],[t_end], [lng_ln] con respecto a un minimo y a un maximo valor.
  114.     [lng_ln]      corresponde a la distancia entre [t_ini] y [t_end].
  115.     Se retorna false solo si [t_max] es menor que que [t_ini] o que [*lng_ln] es igual o menor a [0]
  116.     By BlackZeroX ( http://Infrangelux.sytes.net/ )
  117. **/
  118. {
  119.    T T_Swap;
  120.  
  121.    if ( t_ini!=NULL && lng_ln!=NULL )
  122.        if ( t_max >= *t_ini && *lng_ln != 0 )
  123.        {
  124.            if (*lng_ln < 0 )
  125.            {
  126.                t_ini = t_ini + *lng_ln + 1;
  127.                *lng_ln = *lng_ln * -1;
  128.            }
  129.            if ( lng_distance != NULL )
  130.                if (*lng_distance < 0)
  131.                {
  132.                    t_ini += *lng_distance;
  133.                    if (*t_ini < 0)
  134.                        return false;
  135.                    T_Swap          = *lng_distance*(-1);
  136.                    *lng_distance   = *lng_ln;
  137.                    *lng_ln         = T_Swap;
  138.                }
  139.            (*lng_ln)--;
  140.            *t_ini      = rectific_num<T>( *t_ini , t_min , t_max);
  141.            *t_end      = rectific_num<T>( *t_ini+*lng_ln , *t_ini , t_max);
  142.            if ( lng_distance != NULL )
  143.                *lng_distance = rectific_num<T>( *lng_distance , t_min , t_max-(*t_end));
  144.            *lng_ln           = *t_end-*t_ini+1;
  145.            return *lng_ln>0 ? true: false;
  146.        }
  147.    return false;
  148. }
  149.  
  150. #endif // MODUTILES_H
  151.  
  152.  


modutiles.cpp
Código
  1.  
  2.  
  3. #include "modutiles.h"
  4.  
  5. size_t ByteIndex( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find, size_t szt_lsf, size_t szt_Start, e_CompareMethod enum_Compare )
  6. /**
  7.     [*pByt_Bytes]       Puntero a los Bytes.
  8.     [szt_ls]]           Longitud de [*pByt_Bytes].
  9.     [*pByt_Find]        Puntero a los Bytes a buscar dentro de [*pByt_Bytes].
  10.     [szt_lsf]]          Longitud de [*pByt_Find].
  11.     [szt_Start]         Punto inicial desde donde se buscara en [*pByt_Bytes].
  12.     [enum_Compare]      Indica el metodo de busqueda.
  13.  
  14.     Retorna la posicion de [*pByt_Find] en [*pByt_Bytes] desde [szt_Start] hasta [szt_ls].
  15.     Nota: se pude quitar [szt_Start] y obviar en [*pByt_Bytes].
  16.     By BlackZeroX ( http://Infrangelux.sytes.net/ )
  17. **/
  18. {
  19.    size_t          szt_i   = 0;
  20.    bool            boo_v   = false;
  21.    if ( szt_ls>=szt_lsf )
  22.        for ( szt_i=szt_Start, boo_v=false ; szt_i<(szt_ls-szt_lsf+1) && boo_v==false; szt_i++ )
  23.            boo_v = ByteExits(pByt_Bytes, szt_ls, pByt_Find, szt_lsf, szt_i, 1, enum_Compare);
  24.    if (boo_v != false)
  25.        return szt_i;
  26.    return 0;
  27. }
  28. size_t ByteIndex( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find, size_t szt_lsf, size_t szt_Start )
  29.    { return ByteIndex ( pByt_Bytes , szt_ls, pByt_Find , szt_lsf , szt_Start , TEXTCOMPARE); }
  30. size_t ByteIndex( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find, size_t szt_lsf )
  31.    { return ByteIndex ( pByt_Bytes , szt_ls, pByt_Find , szt_lsf , 0, TEXTCOMPARE); }
  32.  
  33. bool ByteExits ( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find , size_t szt_lsf , size_t szt_Start , long lng_interval, e_CompareMethod enum_Compare)
  34. /**
  35.     [*pByt_Bytes]       Puntero a los Bytes.
  36.     [szt_ls]]           Longitud de [*pByt_Bytes].
  37.     [*pByt_Find]        Puntero a los Bytes a buscar dentro de [*pByt_Bytes].
  38.     [szt_lsf]]          Longitud de [*pByt_Find].
  39.     [szt_Start]         Punto inicial desde donde se buscara en [*pByt_Bytes].
  40.     [lng_interval]      Intervalo de busqueda de [*pByt_Find].
  41.     [enum_Compare]      Indica el metodo de busqueda.
  42.  
  43.     Retorna [true] si se encuentra [*pByt_Find] en [*pByt_Bytes] desde [szt_Start] hasta [szt_ls] en un intervalo de [lng_interval] y [false] si no lo encuentra.
  44.     Nota: se pude quitar [szt_Start] y obviar en [*pByt_Bytes].
  45.     By BlackZeroX ( http://Infrangelux.sytes.net/ )
  46. **/
  47. {
  48.    size_t          szt_i,
  49.                    szt_j;
  50.    bool            boo_v;
  51.    long            lng_res = (lng_interval*(szt_lsf-1)) + szt_Start;
  52.    boo_v = lng_res>=0 && lng_res<=szt_ls ? true:false; // Verifica limites cerrados de [ 0 , szt_ls ].
  53.    switch ( enum_Compare ) {
  54.        case BINARY:
  55.            for ( szt_i=szt_Start, szt_j=0; szt_j<szt_lsf && boo_v==true ; szt_i+=lng_interval, szt_j++  ) {
  56.                boo_v = pByt_Bytes[szt_i]==pByt_Find[szt_j] ? true:false;
  57.            }
  58.            break;
  59.        case TEXTCOMPARE:
  60.            for ( szt_i=szt_Start, szt_j=0; szt_j<szt_lsf && boo_v==true ; szt_i+=lng_interval, szt_j++  ) {
  61.                if ( pByt_Bytes[szt_i]==pByt_Find[szt_j] )
  62.                    boo_v = true;
  63.                else if ( CmpCharMTLTM(&pByt_Bytes[szt_i]) == pByt_Find[szt_j] )
  64.                    boo_v = true ;
  65.                else
  66.                    boo_v = false;
  67.            }
  68.            break;
  69.    }
  70.    return boo_v;
  71. }
  72. bool ByteExits ( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find , size_t szt_lsf , size_t szt_Start , long lng_interval)
  73.    { return ByteExits ( pByt_Bytes , szt_ls, pByt_Find , szt_lsf , szt_Start , lng_interval, TEXTCOMPARE); }
  74. bool ByteExits ( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find , size_t szt_lsf , size_t szt_Start)
  75.    { return ByteExits ( pByt_Bytes , szt_ls, pByt_Find , szt_lsf , szt_Start , 1, TEXTCOMPARE); }
  76. bool ByteExits ( Byte *pByt_Bytes , size_t szt_ls, Byte *pByt_Find , size_t szt_lsf )
  77.    { return ByteExits ( pByt_Bytes , szt_ls, pByt_Find , szt_lsf , 0 , 1, TEXTCOMPARE); }
  78.  
  79. Struct_Byte* ByteReplace(Byte *pByt_Bytes, size_t szt_lnBytes, Byte *pByt_Find, size_t szt_lnFind, Byte *pByt_Replacement, size_t szt_lnReplacement, size_t szt_Start, long lng_Count, e_CompareMethod enum_Compare)
  80. /**
  81.     [*pByt_Bytes]       Bytes a Clonar.
  82.     [*szt_lnBytes]      Cantidad de Bytes a Clonar.
  83.     [*pByt_Find]        Puntero al inicio de los bytes a buscar en [*pByt_Bytes].
  84.     [szt_lnFind]        longitud de [*pByt_Find].
  85.     [*pByt_Replacement] Puntero a los bytes con los cuales se reemplazaran [*pByt_Find].
  86.     [szt_lnReplacement] Indica la longitud de Bytes de [*pByt_Replacement].
  87.     [szt_Start]         Indice de [*pByt_Bytes] donde se empesara a buscar a [*pByt_Find].
  88.     [lng_Count]         Indica la cantidad de Coherencias a reemplazar, si es -1 indica TODAs las coherencias encontradas.
  89.     [enum_Compare]      Indica el modo de Buqueda.
  90.  
  91.     Retorna una copia con los TODAS las coherencias de bytes ya reemplazados en [*pByt_Bytes].
  92.     By BlackZeroX ( http://Infrangelux.sytes.net/ )
  93. **/
  94. {
  95.    size_t              szt_c           = 0;
  96.    Struct_Byte         *pstrs_ret      = NULL;
  97.    Struct_Byte_Split   *pstrspli_ret   = NULL;
  98.  
  99.    if ( (pstrs_ret = (Struct_Byte*)malloc(sizeof(Struct_Byte))) == NULL || szt_lnBytes <= 0 )
  100.        return pstrs_ret;
  101.  
  102.    pstrs_ret->pbyt_bytes   = NULL;
  103.    pstrs_ret->szt_lenbytes = 0;
  104.  
  105.    if ( !(szt_lnFind > 0 && szt_lnBytes >= (szt_lnFind) && lng_Count != 0) )
  106.        return pstrs_ret;
  107.  
  108.    if ( szt_Start > (szt_lnBytes - szt_lnFind) )
  109.        return pstrs_ret;
  110.  
  111.    if ( lng_Count == 0 )
  112.        return pstrs_ret;
  113.  
  114.    pstrspli_ret = ByteSplit ( &pByt_Bytes[szt_Start] , szt_lnBytes  , pByt_Find , szt_lnFind , lng_Count+1 );
  115.    if ( pstrspli_ret != NULL ) {
  116.        for ( szt_c = 0 ; szt_c < pstrspli_ret->szt_ln ; szt_c++ ) {
  117.            if ( pstrspli_ret->Struct[ szt_c ] != NULL ) {
  118.                if ( pByt_Replacement != NULL )
  119.                    if ( szt_c >= (pstrspli_ret->szt_ln-1))
  120.                        szt_lnReplacement = 0;
  121.                pstrs_ret->pbyt_bytes = (Byte*)reallocpp( pstrs_ret->pbyt_bytes , pstrs_ret->szt_lenbytes , szt_lnReplacement+pstrs_ret->szt_lenbytes+pstrspli_ret->Struct[szt_c]->szt_lenbytes);
  122.  
  123.                if ( pstrs_ret->pbyt_bytes != NULL ) {
  124.                    if ( pstrspli_ret->Struct[ szt_c ]->szt_lenbytes>0 ) {
  125.                        memcpy( &pstrs_ret->pbyt_bytes[ pstrs_ret->szt_lenbytes ] , pstrspli_ret->Struct[ szt_c ]->pbyt_bytes , pstrspli_ret->Struct[ szt_c ]->szt_lenbytes );
  126.                        pstrs_ret->szt_lenbytes  += pstrspli_ret->Struct[szt_c]->szt_lenbytes;
  127.                    }
  128.                    if ( pByt_Replacement != NULL )
  129.                        if ( szt_c < (pstrspli_ret->szt_ln-1) ) {
  130.                            memcpy( &pstrs_ret->pbyt_bytes[ pstrs_ret->szt_lenbytes ] , pByt_Replacement , szt_lnReplacement );
  131.                            pstrs_ret->szt_lenbytes  += szt_lnReplacement;
  132.                        }
  133.                }
  134.                free ( pstrspli_ret->Struct[ szt_c ]->pbyt_bytes );
  135.                free ( pstrspli_ret->Struct[ szt_c ] );
  136.            }
  137.        }
  138.        free ( pstrspli_ret->Struct );
  139.        free ( pstrspli_ret         );
  140.    }
  141.    return pstrs_ret;
  142. }
  143. Struct_Byte* ByteReplace(Byte *pByt_Bytes, size_t szt_lnBytes, Byte *pByt_Find, size_t szt_lnFind, Byte *pByt_Replacement, size_t szt_lnReplacement, size_t szt_Start, long lng_Count)
  144.    { return ByteReplace( pByt_Bytes , szt_lnBytes , pByt_Find , szt_lnFind , pByt_Replacement , szt_lnReplacement , szt_Start , lng_Count , BINARY ); }
  145. Struct_Byte* ByteReplace(Byte *pByt_Bytes, size_t szt_lnBytes, Byte *pByt_Find, size_t szt_lnFind, Byte *pByt_Replacement, size_t szt_lnReplacement, size_t szt_Start)
  146.    { return ByteReplace( pByt_Bytes , szt_lnBytes , pByt_Find , szt_lnFind , pByt_Replacement , szt_lnReplacement , szt_Start , -1 , BINARY ); }
  147. Struct_Byte* ByteReplace(Byte *pByt_Bytes, size_t szt_lnBytes, Byte *pByt_Find, size_t szt_lnFind, Byte *pByt_Replacement, size_t szt_lnReplacement)
  148.    { return ByteReplace( pByt_Bytes , szt_lnBytes , pByt_Find , szt_lnFind , pByt_Replacement , szt_lnReplacement , 0 , -1 , BINARY ); }
  149.  
  150. Byte *reallocpp( Byte *pvoid_in , size_t szt_a, size_t szt_n )
  151. {
  152.    Byte *pvoid_ret = (Byte*)malloc(sizeof(Byte)*szt_n);
  153.    if ( pvoid_in != NULL && pvoid_ret != NULL ) {
  154.        if ( szt_a>0 ) {
  155.            memcpy ( pvoid_ret , pvoid_in , szt_a );
  156.        }
  157.        delete pvoid_in;
  158.    }
  159.    return pvoid_ret;
  160. }
  161.  
  162. Byte* ByteClone( Byte *pByt_Bytes , size_t szt_lenbytes )
  163. /**
  164.     [*pByt_Bytes]       Bytes a Clonar.
  165.     [*szt_lenbytes]     Cantidad de Bytes a Clonar.
  166.  
  167.     Retorna una copia exacta de [*pByt_Bytes] con la longitud indicada en [*szt_lenbytes],
  168.     By BlackZeroX ( http://Infrangelux.sytes.net/ )
  169. **/
  170. {
  171.    if ( pByt_Bytes == NULL || szt_lenbytes <= 0 ) {
  172.        return NULL;
  173.    }
  174.    szt_lenbytes  *= sizeof(Byte);
  175.    return (Byte*)memcpy( (Byte*)malloc(sizeof(Byte)*szt_lenbytes) , pByt_Bytes , szt_lenbytes );
  176. }
  177.  
  178. Byte CmpCharMTLTM(Byte *chr_v)
  179. /**
  180.     [*chr_v]              Puntero a la Cedena (Solo se tomara en cuenta el primer elemento).
  181.  
  182.     Se retorna si es Alfabeto ( de la "AZaz" en mayusculas y minusculas) y segun el primer elemento se retornara la consonante o vocal contraria; es decir si es mayuscula se retornara una minuscula y viceversa, si no es del Alfabeto se retornara solo el 1er elemento de [*chr_v]
  183.     Nota: se puede obviar a [ulng_pos] por medio de [*chr_v].
  184.     By BlackZeroX ( http://Infrangelux.sytes.net/ )
  185. **/
  186. {
  187.    if ( chr_v != NULL ) {
  188.        if ( (chr_v[0]>='a' && chr_v[0]<='z') )
  189.            return (Byte)(chr_v[0] - ('a' - 'A'));
  190.        else if ( chr_v[0]=='ñ' )
  191.            return (Byte)'Ñ';
  192.        else if ( (chr_v[0]>='A' && chr_v[0]<='Z') || chr_v[0]=='Ñ' )
  193.            return (Byte)(chr_v[0] + ('a' - 'A'));
  194.        else if ( chr_v[0]=='Ñ' )
  195.            return (Byte)'ñ';
  196.  
  197.        return chr_v[0];
  198.    }
  199.    return (Byte)'\0';
  200. }
  201.  
  202. Struct_Byte* ByteMid( Byte* pbyt_str , size_t szt_lnstr , size_t szt_start , size_t szt_len )
  203. /**
  204.     Se obtiene el fragmento deseado de [*pbyt_str]
  205.     [szt_start]         Indica desde donde se empesara
  206.     [Len]           Indica la distancia.
  207.     Retorna el puntero al clon del fragmento deseado de [*pbyt_str]
  208.     By BlackZeroX ( http://Infrangelux.sytes.net/ )
  209. **/
  210. {
  211.    struct Struct_Byte  *strbyte_ret    = (Struct_Byte*)malloc(sizeof(Struct_Byte));
  212.    size_t              szt_end         = szt_start+szt_len-1;
  213.  
  214.    strbyte_ret->szt_lenbytes           = 0;
  215.    strbyte_ret->pbyt_bytes             = NULL;
  216.  
  217.    if ( fix_numbers_range<size_t>( &szt_start , &szt_end , (long*)&szt_len , NULL , 0 , szt_lnstr-1) == true ) {
  218.        strbyte_ret->szt_lenbytes       = sizeof(Byte) * szt_len;
  219.        strbyte_ret->pbyt_bytes         = (Byte*)malloc(sizeof(Byte)*strbyte_ret->szt_lenbytes);
  220.        if ( strbyte_ret->pbyt_bytes == NULL )
  221.            setnewptrf<Struct_Byte*>( strbyte_ret , NULL );
  222.        else
  223.            memcpy( strbyte_ret->pbyt_bytes , &pbyt_str[szt_start] , szt_len );
  224.    }
  225.    return strbyte_ret;
  226. }
  227.  
  228. Struct_Byte_Split *ByteSplit( Byte *pbyt_str , size_t szt_lnstr , Byte *pbyt_delimiter , size_t szt_lndelimiter , long lng_limit )
  229. /**
  230.     Separa a [*pbyt_str] cada vez que se encuentre a [*pbyt_delimiter] con un limite definido en [lng_limit]
  231.     Si [lng_limit] = -1 se crea un Maximo mayor a [-1] en el indice del vector retornado
  232.     Si [lng_limit] > -1 Se indica y establece un indice mayor [pero no fijo] del indice mayor del vector retornado
  233.     Se retorna el puntero a la estructura contenedora a los puntos separados. funcion retorna el puntero a el vector retultante.
  234.     En casos contrarios no crea un vector y retorna 0 y [lng_limit] = [-1]
  235.     By BlackZeroX ( http://Infrangelux.sytes.net/ )
  236. **/
  237. {
  238.    size_t                      szt_bytind  = 0,
  239.                                szt_bytindb = 0;
  240.    struct Struct_Byte_Split    *pi_out     = (Struct_Byte_Split*)malloc(sizeof(Struct_Byte_Split));
  241.    pi_out->szt_ln = 0;
  242.  
  243.    if ( lng_limit >= -1 && pi_out != NULL ) {
  244.        pi_out->szt_ln          = 0;
  245.        pi_out->Struct          = NULL;
  246.        if ( szt_lndelimiter != 0 )
  247.            for(;;) {
  248.                pi_out->Struct                      = (Struct_Byte**)reallocpp( (Byte*)pi_out->Struct , sizeof(Struct_Byte*)*(pi_out->szt_ln) , sizeof(Struct_Byte*)*(pi_out->szt_ln+1) );
  249.                if ( pi_out->szt_ln == (lng_limit-1) ) {
  250.                    pi_out->Struct[ pi_out->szt_ln++ ]  = ByteMid( pbyt_str , szt_lnstr , szt_bytindb , szt_lnstr );
  251.                    break;
  252.                }
  253.                szt_bytind = ByteIndex( pbyt_str , szt_lnstr , pbyt_delimiter , szt_lndelimiter , szt_bytindb , BINARY );
  254.                if ( szt_bytind == 0 && szt_bytindb >= szt_lnstr )
  255.                    break;
  256.                if ( szt_bytind == 0 ) {
  257.                    pi_out->Struct[pi_out->szt_ln++]    = ByteMid( pbyt_str , szt_lnstr , szt_bytindb , szt_lnstr );
  258.                    break;
  259.                }
  260.                pi_out->Struct[pi_out->szt_ln++]    = ByteMid( pbyt_str , szt_lnstr , szt_bytindb , ((--szt_bytind)-szt_bytindb) );
  261.                szt_bytindb = szt_bytind + szt_lndelimiter;
  262.  
  263.                if ( szt_bytindb == szt_lnstr) {
  264.                    pi_out->Struct                                  = (Struct_Byte**)reallocpp( (Byte*)pi_out->Struct , sizeof(Struct_Byte*)*(pi_out->szt_ln) , sizeof(Struct_Byte*)*(pi_out->szt_ln+1) );
  265.                    pi_out->Struct[pi_out->szt_ln]                  = (Struct_Byte*)malloc(sizeof(Struct_Byte));
  266.                    pi_out->Struct[pi_out->szt_ln]->pbyt_bytes      = NULL;
  267.                    pi_out->Struct[pi_out->szt_ln++]->szt_lenbytes  = 0;
  268.                    break;
  269.                }
  270.            }
  271.    }
  272.    return pi_out;
  273. }
  274. Struct_Byte_Split *ByteSplit( Byte *pbyt_str , size_t szt_lnstr , Byte *pbyt_delimiter , size_t szt_lndelimiter )
  275.    { return ByteSplit( pbyt_str , szt_lnstr , pbyt_delimiter , szt_lndelimiter ); }
  276.  
  277. size_t flen(FILE *pFl)
  278. /**
  279.     [*pFl]              Puntero al Archivo abierto
  280.  
  281.     Retorna el peso en [BYTES] del archivo [*pFl].
  282.     By BlackZeroX ( http://Infrangelux.sytes.net/ )
  283. **/
  284. {
  285.    size_t      szt_pn          = 0,
  286.                szt_fl          = 0;
  287.    if ( pFl != NULL ) {
  288.        szt_pn      = ftell( pFl );
  289.        fseek       ( pFl , 0L , SEEK_END);
  290.        szt_fl      = ftell( pFl );
  291.        fseek       ( pFl , szt_pn , SEEK_SET);
  292.    }
  293.    return szt_fl;
  294. }
  295.  
  296.  

Temibles Lunas!¡.
En línea

The Dark Shadow is my passion.
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
PHP y funciones tcp/ip « 1 2 »
PHP
nacho2003 11 5,004 Último mensaje 21 Septiembre 2006, 00:07 am
por deya
Funciones en php
PHP
Lambda 2 1,793 Último mensaje 14 Octubre 2006, 17:00 pm
por Thaorius
Dudas binarias o de muy muy pero de muy bajo nivel (7 dudas)
Ingeniería Inversa
jamonyqueso 7 3,602 Último mensaje 7 Noviembre 2007, 04:45 am
por Ferсhu
Recopilacion de Funciones con operaciones Binarias. « 1 2 »
Programación Visual Basic
BlackZeroX 14 24,494 Último mensaje 17 Mayo 2015, 12:14 pm
por pkj
Estructuras Binarias x86-64
Ingeniería Inversa
FFernandez 9 3,840 Último mensaje 14 Diciembre 2020, 19:30 pm
por FFernandez
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines