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

 

 


Tema destacado: Entrar al Canal Oficial Telegram de elhacker.net


+  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 2,802 veces)
BlackZeroX
Wiki

Desconectado Desconectado

Mensajes: 3.158


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


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 7,463 Último mensaje 21 Septiembre 2006, 00:07 am
por deya
Funciones en php
PHP 		Lambda 2 2,532 Ú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 4,984 Ú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 28,419 Último mensaje 17 Mayo 2015, 12:14 pm
por pkj
Estructuras Binarias x86-64
Ingeniería Inversa 		FFernandez 9 6,674 Último mensaje 14 Diciembre 2020, 19:30 pm
por FFernandez
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines