libgoblin/drd64_libgoblin_srcfile.c

   1 /*DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64
   2
   3                          D r . D e a m o n  6 4
   4                         for INTEL64(R), AMD64(R)
   5
   6    Copyright(C) 2007-2009 Koine Yuusuke(koinec). All rights reserved.
   7
   8 Redistribution and use in source and binary forms, with or without
   9 modification, are permitted provided that the following conditions are met:
  10
  11  1. Redistributions of source code must retain the above copyright notice,
  12     this list of conditions and the following disclaimer.
  13  2. Redistributions in binary form must reproduce the above copyright
  14     notice, this list of conditions and the following disclaimer in the
  15     documentation and/or other materials provided with the distribution.
  16
  17 THIS SOFTWARE IS PROVIDED BY Koine Yuusuke(koinec) ``AS IS'' AND ANY
  18 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 DISCLAIMED. IN NO EVENT SHALL Koine Yuusuke(koinec) OR CONTRIBUTORS BE
  21 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  27 OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64*/
  30
  31 /* File Info -----------------------------------------------------------
  32 File: drd64_.c
  33 Function:
  34 Comment:
  35 ----------------------------------------------------------------------*/
  36
  37 #define DRD64_SRC_LIBGOBLIN_SRCFILE
  38 #include"drd64_libgoblin.h"
  39
  40 #define LOCATION(n) DRD64_ERR_LOCATION( \
  41                                                 DRD64_ERROR_MODULE_LIBGOBLIN, DRD64_ERROR_ARCH_NODEPEND, \
  42                                                 DRD64_SRCID_LIBGOBLIN_SRCFILE, (n))
  43
  44
  45 /*----------------------------------------------------------------------
  46 ----------------------------------------------------------------------*/
  47 #define FUNCID_LibGoblin_SrcFile_GetSrcFile     0x14
  48 LIBGOBLIN_SRCFILE_EXTERN
  49 LibGoblin_SrcFile       *
  50         SrcFile_GetSrcFile(
  51                         LibGoblin_BinaryFile    *p_bfile,
  52                         int             i_srcid )
  53 {
  54         assert( NULL != p_bfile );
  55
  56         if(( p_bfile->srcfile.i_max <= i_srcid ) || ( 0 > i_srcid ))    {
  57                 LibBrownie_Error_SetErrorInfo(
  58                         DRD64_ERROR( DRD64_ERROR_PTN_FAILED_ARG, 0x01, 0x01 ),
  59                         LOCATION( FUNCID_LibGoblin_SrcFile_GetSrcFile ), errno,
  60                         (QWord)i_srcid , (QWord)p_bfile->srcfile.i_max, __LINE__ );
  61                 return NULL;
  62         }
  63
  64         if( -0x01 == SRCFILE( p_bfile, i_srcid )->i_id )        {
  65                 LibBrownie_Error_SetErrorInfo(
  66                         DRD64_ERROR( DRD64_ERROR_PTN_FAILCALL, 0x01, 0x01 ),
  67                         LOCATION( FUNCID_LibGoblin_SrcFile_GetSrcFile ),
  68                         errno, (QWord)i_srcid , (QWord)0x00, __LINE__ );
  69                 return NULL;
  70         }
  71
  72         return SRCFILE( p_bfile, i_srcid );
  73 }
  74
  75
  76 /*----------------------------------------------------------------------
  77 OK
  78 ----------------------------------------------------------------------*/
  79 #define FUNCID_LibGoblin_SrcFile_AllocSrcFile   0x11
  80 LIBGOBLIN_SRCFILE_EXTERN
  81 LibGoblin_SrcFile       *
  82         SrcFile_AllocSrcFile(
  83                         LibGoblin_BinaryFile    *p_bfile )
  84 {
  85         int                                     i_cnt;
  86         int                                     i_id_now        = -0x01;
  87         LibGoblin_SrcFile       *p_srcfile      = NULL;
  88         LibGoblin_SrcFile       *p_srcbase;
  89
  90         assert( NULL != p_bfile );
  91
  92         if( p_bfile->srcfile.i_now < p_bfile->srcfile.i_max )   {
  93                 // Search Non-Used & Alloced SrcFile struct.
  94                 for( i_cnt = 0; i_cnt < p_bfile->srcfile.i_max; i_cnt++ )       {
  95                         if( -0x01 == SRCFILE( p_bfile, i_cnt )->i_id )  {
  96                                 p_srcfile       = SRCFILE( p_bfile, i_cnt );
  97                                 i_id_now        = i_cnt;
  98                                 goto    goto_SrcFile_AllocSrcFile_dataset;
  99                         }
 100                 }
 101
 102                 // Bug -- Not Exist Non-used SrcFile struct.
 103                 LibBrownie_Error_SetErrorInfo(
 104                         DRD64_ERROR( DRD64_ERROR_PTN_BUG, 0x01, 0x01 ),
 105                         LOCATION( FUNCID_LibGoblin_SrcFile_AllocSrcFile ), errno,
 106                         (QWord)p_bfile->srcfile.i_now , (QWord)p_bfile->srcfile.i_max, __LINE__ );
 107                 goto    goto_SrcFile_AllocSrcFile_post;
 108         }
 109
 110         if( p_bfile->srcfile.i_now == p_bfile->srcfile.i_alloc )        {
 111                 p_srcbase       = (LibGoblin_SrcFile *)realloc( p_bfile->srcfile.p_srcfile,
 112                                                                 sizeof( LibGoblin_SrcFile ) *
 113                                                                 ( p_bfile->srcfile.i_alloc + LIBGOBLIN_SRCFILE_UNITS ) );
 114                 if( NULL == p_srcbase ) {
 115                         LibBrownie_Error_SetErrorInfo(
 116                                 DRD64_ERROR( DRD64_ERROR_PTN_NOMEMORY, 0x01, 0x02 ),
 117                                 LOCATION( FUNCID_LibGoblin_SrcFile_AllocSrcFile ), errno,
 118                                 (QWord)p_bfile->srcfile.i_alloc, (QWord)p_bfile->srcfile.i_max, __LINE__ );
 119                         goto    goto_SrcFile_AllocSrcFile_post;
 120                 }
 121
 122                 p_bfile->srcfile.p_srcfile      = p_srcbase;
 123                 p_bfile->srcfile.i_alloc        += LIBGOBLIN_SRCFILE_UNITS;
 124         }
 125
 126         i_id_now        = p_bfile->srcfile.i_now;
 127
 128 goto_SrcFile_AllocSrcFile_dataset:
 129         if( i_id_now == p_bfile->srcfile.i_max )        { p_bfile->srcfile.i_max++; }
 130         p_srcfile                               = SRCFILE( p_bfile, i_id_now );
 131         p_srcfile->i_id                 = i_id_now;
 132         p_srcfile->i_bfile_id   = p_bfile->i_id;
 133         p_bfile->srcfile.i_now++;
 134
 135 goto_SrcFile_AllocSrcFile_post:
 136         return p_srcfile;
 137 }
 138
 139
 140 /*----------------------------------------------------------------------
 141 ----------------------------------------------------------------------*/
 142 #define FUNCID_LibGoblin_SrcFile_SearchSrcFile  0x31
 143 LibGoblin_SrcFile       *
 144         SrcFile_SearchSrcFile(
 145                         LibGoblin_BinaryFile    *p_bfile,
 146                         char    *pstr_filename,
 147                         char    *pstr_path )
 148 {
 149         int             i_cnt;
 150         int             i_result;
 151         DWord   dw_hash;
 152         LibGoblin_SrcFile       *p_srcfile;
 153
 154         assert( NULL != p_bfile );
 155         assert( NULL != pstr_filename );
 156
 157         dw_hash = Common_CalcDJBhash( pstr_filename );
 158
 159         for( i_cnt = 0; i_cnt < p_bfile->srcfile.i_max; i_cnt++ )       {
 160                 p_srcfile       = SRCFILE( p_bfile, i_cnt );
 161
 162                 if( -0x01 == p_srcfile->i_id )  { continue; }
 163
 164                 if( dw_hash != p_srcfile->dw_hash_filename )    { continue; }
 165
 166                 i_result        = strncmp( pstr_filename, p_srcfile->str_filename, DRD64_MAX_PATH );
 167                 if( 0x00 != i_result )  { continue; }
 168
 169                 if( NULL == pstr_path )
 170                         { goto  goto_SrcFile_SearchSrcFile_post; }
 171
 172                 if( '\0' == p_srcfile->str_srcpath[0] )
 173                         { goto  goto_SrcFile_SearchSrcFile_post; }
 174
 175                 i_result        = strncmp( pstr_path, p_srcfile->str_srcpath, DRD64_MAX_PATH );
 176                 if( 0x00 == i_result )
 177                         { goto  goto_SrcFile_SearchSrcFile_post; }
 178         }
 179
 180         p_srcfile       = NULL;
 181
 182 goto_SrcFile_SearchSrcFile_post:
 183         return p_srcfile;
 184 }
 185
 186
 187 /*----------------------------------------------------------------------
 188 ----------------------------------------------------------------------*/
 189 #define FUNCID_LibGoblin_SrcFile_DispenseSrcFile        0x21
 190 LIBGOBLIN_SRCFILE_EXTERN
 191 LibGoblin_SrcFile       *
 192         SrcFile_DispenseSrcFile(
 193                         LibGoblin_BinaryFile    *p_bfile,
 194                         char    *pstr_filename,
 195                         char    *pstr_path )
 196 {
 197         LibGoblin_SrcFile       *p_srcfile;
 198
 199         assert( NULL != p_bfile );
 200
 201         p_srcfile       = SrcFile_SearchSrcFile( p_bfile, pstr_filename, pstr_path );
 202         if( NULL == p_srcfile ) {
 203                 p_srcfile       = SrcFile_AllocSrcFile( p_bfile );
 204         }
 205
 206         assert( NULL != p_srcfile );
 207
 208         strncpy( p_srcfile->str_filename, pstr_filename, DRD64_MAX_PATH );
 209         p_srcfile->dw_hash_filename     = Common_CalcDJBhash( pstr_filename );
 210
 211         if( NULL == pstr_path )
 212                 { p_srcfile->str_srcpath[0]     = '\0'; }
 213         else
 214                 { strncpy( p_srcfile->str_srcpath, pstr_path, DRD64_MAX_PATH ); }
 215
 216         return  p_srcfile;
 217 }
 218
 219
 220 /*----------------------------------------------------------------------
 221 OK
 222 ----------------------------------------------------------------------*/
 223 #define FUNCID_LibGoblin_SrcFile_ClearSrcFile   0x13
 224 void
 225         SrcFile_ClearSrcFile(
 226                         LibGoblin_SrcFile       *p_srcfile )
 227 {
 228         assert( NULL != p_srcfile );
 229
 230         memset( p_srcfile, 0x00, sizeof( LibGoblin_SrcFile ) );
 231
 232         p_srcfile->i_id                 = -0x01;
 233         p_srcfile->i_bfile_id   = -0x01;
 234
 235         return;
 236 }
 237
 238
 239 /*----------------------------------------------------------------------
 240 OK
 241 ----------------------------------------------------------------------*/
 242 #define FUNCID_LibGoblin_SrcFile_FreeSrcFile    0x12
 243 LIBGOBLIN_SRCFILE_EXTERN
 244 int
 245         SrcFile_FreeSrcFile(
 246                         LibGoblin_BinaryFile    *p_bfile,
 247                         LibGoblin_SrcFile       *p_srcfile )
 248 {
 249         int             i_id;
 250
 251         assert( NULL != p_bfile );
 252         assert( NULL != p_srcfile );
 253
 254         if( -0x01 == p_srcfile->i_id )  {
 255                 LibBrownie_Error_SetErrorInfo(
 256                         DRD64_ERROR( DRD64_ERROR_PTN_FAILCALL, 0x01, 0x01 ),
 257                         LOCATION( FUNCID_LibGoblin_SrcFile_FreeSrcFile ),
 258                         errno, (QWord)0x00 , (QWord)0x00, __LINE__ );
 259                 return 0x00;
 260         }
 261
 262         i_id    = p_srcfile->i_id;
 263         SrcFile_ClearSrcFile( p_srcfile );
 264
 265         if( p_bfile->srcfile.i_max == (i_id + 1) )
 266                 { p_bfile->srcfile.i_max--; }
 267
 268         p_bfile->srcfile.i_now--;
 269         if( 0 == p_bfile->srcfile.i_now )
 270                 { p_bfile->srcfile.i_max = 0; }
 271
 272         return 0x00;
 273 }
 274
 275
 276 /*----------------------------------------------------------------------
 277 OK
 278 ----------------------------------------------------------------------*/
 279 #define FUNCID_LibGoblin_SrcFile_Init   0x01
 280 LIBGOBLIN_SRCFILE_EXTERN
 281 int
 282         SrcFile_Init(
 283                         LibGoblin_BinaryFile    *p_bfile )
 284 {
 285         int             i_cnt;
 286         LibGoblin_SrcFile       *p_srcmaster;
 287         LibGoblin_SrcFile       *p_srcfile;
 288
 289         assert( NULL != p_bfile );
 290
 291         if( 0 != p_bfile->srcfile.i_max )       {
 292                 LibBrownie_Error_SetErrorInfo(
 293                         DRD64_ERROR( DRD64_ERROR_PTN_FAILCALL, 0x01, 0x01 ),
 294                         LOCATION( FUNCID_LibGoblin_SrcFile_Init ),
 295                         errno, (QWord)p_bfile->srcfile.i_max , (QWord)0x00, __LINE__ );
 296                 return -0x01;
 297         }
 298
 299         p_srcmaster     = (LibGoblin_SrcFile *)malloc(
 300                                                 sizeof( LibGoblin_SrcFile ) * LIBGOBLIN_SRCFILE_UNITS );
 301         if( NULL == p_srcmaster )       {
 302                 LibBrownie_Error_SetErrorInfo(
 303                         DRD64_ERROR( DRD64_ERROR_PTN_NOMEMORY, 0x01, 0x02 ),
 304                         LOCATION( FUNCID_LibGoblin_SrcFile_Init ),
 305                         errno, (QWord)0x00 , (QWord)0x00, __LINE__ );
 306                 return -0x02;
 307         }
 308         p_bfile->srcfile.p_srcfile      = p_srcmaster;
 309
 310         for( i_cnt = 0; i_cnt < LIBGOBLIN_SRCFILE_UNITS; i_cnt++ )              {
 311                 p_srcfile       = SRCFILE( p_bfile, i_cnt );
 312                 SrcFile_ClearSrcFile( p_srcfile );
 313         }
 314
 315         p_bfile->srcfile.i_alloc        = LIBGOBLIN_SRCFILE_UNITS;
 316         p_bfile->srcfile.i_max          = 0;
 317         p_bfile->srcfile.i_now          = 0;
 318
 319         return 0x00;
 320 }
 321
 322
 323 /*----------------------------------------------------------------------
 324 OK
 325 ----------------------------------------------------------------------*/
 326 #define FUNCID_LibGoblin_SrcFile_Term   0x02
 327 LIBGOBLIN_SRCFILE_EXTERN
 328 int
 329         SrcFile_Term(
 330                         LibGoblin_BinaryFile    *p_bfile )
 331 {
 332         LibGoblin_SrcFile       *p_srcfile;
 333
 334         assert( NULL != p_bfile );
 335
 336         if( 0 < p_bfile->srcfile.i_now )        {
 337                 for( ; p_bfile->srcfile.i_max > 0; p_bfile->srcfile.i_max-- )   {
 338                         p_srcfile       = SRCFILE( p_bfile, (p_bfile->srcfile.i_max - 1) );
 339                         SrcFile_FreeSrcFile( p_bfile, p_srcfile );
 340                 }
 341         }
 342
 343         free( p_bfile->srcfile.p_srcfile );
 344
 345         p_bfile->srcfile.p_srcfile      = NULL;
 346         p_bfile->srcfile.i_alloc        = 0;
 347         p_bfile->srcfile.i_max          = 0;
 348         p_bfile->srcfile.i_now          = 0;
 349
 350         return 0x00;
 351 }
 352
 353
 354 /* EOF of drd64_.c ----------------------------------- */