Ignore:
Timestamp:
Mar 18, 2008, 9:36:56 PM (15 years ago)
Author:
Sam Hocevar
Message:
  • Get rid of ugly tabs and trailing spaces everywhere.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • abuse/trunk/src/imlib/specs.cpp

    r112 r124  
    7373void set_filename_prefix(char const *prefix)
    7474{
    75         if( spec_prefix )
    76         {
    77                 jfree( spec_prefix );
    78         }
    79        
    80         if( prefix )
    81         {
    82                 spec_prefix = strcpy( (char *)jmalloc( strlen( prefix ) + 2, "prefix_name" ), prefix );
    83                 int len = strlen( prefix );
    84                 if( prefix[len - 1] != '\\' && prefix[len - 1] != '/')
    85                 {
    86                         spec_prefix[len] = '/';
    87                         spec_prefix[len + 1] = 0;
    88                 }
    89         }
    90         else
    91         {
    92                 spec_prefix = NULL;
    93         }
     75    if( spec_prefix )
     76    {
     77        jfree( spec_prefix );
     78    }
     79   
     80    if( prefix )
     81    {
     82        spec_prefix = strcpy( (char *)jmalloc( strlen( prefix ) + 2, "prefix_name" ), prefix );
     83        int len = strlen( prefix );
     84        if( prefix[len - 1] != '\\' && prefix[len - 1] != '/')
     85        {
     86            spec_prefix[len] = '/';
     87            spec_prefix[len + 1] = 0;
     88        }
     89    }
     90    else
     91    {
     92        spec_prefix = NULL;
     93    }
    9494}
    9595
    9696char *get_filename_prefix()
    9797{
    98         return spec_prefix;
     98    return spec_prefix;
    9999}
    100100
     
    102102void set_save_filename_prefix(char const *save_prefix)
    103103{
    104         if( save_spec_prefix )
    105         {
    106                 jfree( save_spec_prefix );
    107         }
    108 
    109         if( save_prefix )
    110         {
    111                 int len = strlen( save_prefix );
    112                 save_spec_prefix = (char *)jmalloc( len + 1, "prefix_name" );
    113                 strcpy( save_spec_prefix, save_prefix );
     104    if( save_spec_prefix )
     105    {
     106        jfree( save_spec_prefix );
     107    }
     108
     109    if( save_prefix )
     110    {
     111        int len = strlen( save_prefix );
     112        save_spec_prefix = (char *)jmalloc( len + 1, "prefix_name" );
     113        strcpy( save_spec_prefix, save_prefix );
    114114/* AK - Commented this out as it may cause problems
    115                 if( save_prefix[len - 1] != '\\' && save_prefix[len - 1] != '/' )
    116                 {
    117                         save_spec_prefix[len] = '/';
    118                         save_spec_prefix[len + 1] = '\0';
    119                 } */
    120         }
    121         else
    122         {
    123                 save_spec_prefix = NULL;
    124         }
     115        if( save_prefix[len - 1] != '\\' && save_prefix[len - 1] != '/' )
     116        {
     117            save_spec_prefix[len] = '/';
     118            save_spec_prefix[len + 1] = '\0';
     119        } */
     120    }
     121    else
     122    {
     123        save_spec_prefix = NULL;
     124    }
    125125}
    126126
     
    144144  rbuf_size=8192;
    145145  rbuf=(unsigned char *)jmalloc(rbuf_size,"File read buffer");
    146   rbuf_start=rbuf_end=0; 
     146  rbuf_start=rbuf_end=0;
    147147
    148148  wbuf_size=8192;
    149149  wbuf=(unsigned char *)jmalloc(wbuf_size,"File write buffer");
    150   wbuf_end=0; 
     150  wbuf_end=0;
    151151}
    152152
    153153bFILE::~bFILE()
    154 { 
     154{
    155155  if (rbuf) jfree(rbuf);
    156156  flush_writes();
     
    158158}
    159159
    160 int bFILE::flush_writes() 
     160int bFILE::flush_writes()
    161161{
    162162  if (wbuf_end!=0)
     
    165165    if (ret!=wbuf_end && no_space_handle_fun)
    166166      no_space_handle_fun();
    167      
     167
    168168    wbuf_end=0;
    169169    return ret;
     
    174174int bFILE::read(void *buf, size_t count)       // returns number of bytes read, calls unbuffer_read
    175175{
    176   if (!allow_read_buffering()) 
     176  if (!allow_read_buffering())
    177177    return unbuffered_read(buf,count);
    178178
     
    188188      buf=(void *)(((unsigned char *)buf)+copy_size);
    189189      rbuf_start+=copy_size;
    190       if (rbuf_start>=rbuf_end)   
     190      if (rbuf_start>=rbuf_end)
    191191      {
    192                                 if (rbuf_end!=rbuf_size)  // buffer wasn't full before so there is no way we can complete read
    193                                   error=1;
    194                                 rbuf_start=rbuf_end=0;
     192                if (rbuf_end!=rbuf_size)  // buffer wasn't full before so there is no way we can complete read
     193                  error=1;
     194                rbuf_start=rbuf_end=0;
    195195      }
    196196      total_read+=copy_size;
     
    208208
    209209int bFILE::write(void const *buf, size_t count)      // returns number of bytes written
    210 { 
     210{
    211211  if (allow_write_buffering())
    212212  {
     
    214214    while (count)
    215215    {
    216       int copy_size=wbuf_end+count<=wbuf_size ? count :  wbuf_size-wbuf_end;           
     216      int copy_size=wbuf_end+count<=wbuf_size ? count :  wbuf_size-wbuf_end;
    217217      memcpy(wbuf+wbuf_end,buf,copy_size);
    218218      wbuf_end+=copy_size;
     
    221221      if (wbuf_end==wbuf_size)
    222222        if ((unsigned int)flush_writes()!=wbuf_size)
    223           return total_written;
    224      
    225       total_written+=copy_size;     
     223      return total_written;
     224
     225      total_written+=copy_size;
    226226    }
    227227    return total_written;
     
    236236
    237237int bFILE::seek(long offset, int whence) // whence=SEEK_SET, SEEK_CUR, SEEK_END, ret=0=success
    238 { 
     238{
    239239//    rbuf_start=rbuf_end=0;
    240240//    unbuffered_seek(offset,SEEK_SET);
     
    249249    rbuf_start=rbuf_end=0;
    250250    unbuffered_seek(offset,SEEK_SET);
    251   } else 
     251  } else
    252252    rbuf_start=rbuf_end-(realpos-offset);
    253253  return 1;
     
    278278  strcpy(spec_main_file,filename);
    279279  search_order=Search_order;
    280  
     280
    281281#if (defined(__APPLE__) && !defined(__MACH__))
    282282  spec_main_jfile.open_external(filename,"rb",O_BINARY|O_RDONLY);
     
    332332  if (flags&O_WRONLY)
    333333  {
    334     if ((flags&O_APPEND)==0) 
     334    if ((flags&O_APPEND)==0)
    335335    {
    336336      skip_size=1;
     
    342342
    343343    fd=open(tmp_name,flags,S_IRWXU | S_IRWXG | S_IRWXO);
    344   } else 
     344  } else
    345345    fd=open(tmp_name,flags);
    346346
     
    352352      lseek(fd,0,SEEK_SET);
    353353    else
    354         current_offset = file_length;
     354        current_offset = file_length;
    355355    start_offset=0;
    356   } else 
     356  } else
    357357  {
    358358    file_length=0;
     
    373373  virtual int file_size() { return 0; }
    374374  virtual ~null_file() { ; }
    375 } ; 
     375} ;
    376376
    377377
     
    397397{
    398398  int wr=0;
    399   for (char const *s=mode;*s;s++) 
     399  for (char const *s=mode;*s;s++)
    400400    if (toupper(*s)=='A' || toupper(*s)=='W')
    401401      wr=1;
     
    405405  else
    406406  {
    407         fd = spec_main_fd;
     407       fd = spec_main_fd;
    408408    if (fd>=0)                    // if we were able to open the main file, see if it's in there
    409409    {
    410410      start_offset=0;
    411411      spec_entry *se=spec_main_sd.find(filename);
    412       if (se)   
     412      if (se)
    413413      {
    414         start_offset=se->offset;
    415         current_offset = 0;
    416         file_length=se->size;
    417         rbuf_start=rbuf_end=0;
    418       } else 
     414    start_offset=se->offset;
     415    current_offset = 0;
     416    file_length=se->size;
     417    rbuf_start=rbuf_end=0;
     418      } else
    419419      {
    420         close(fd);
    421         fd=-1;
     420    close(fd);
     421    fd=-1;
    422422      }
    423     } 
     423    }
    424424  }
    425425}
     
    427427jFILE::jFILE(char const *filename, char const *access_string)      // same as fopen parameters
    428428{
    429  flags=access=0; 
     429 flags=access=0;
    430430 char const *s=access_string;
    431   for (;*s;s++) 
     431  for (;*s;s++)
    432432    if (toupper(*s)=='R') access=O_RDONLY;
    433433
    434   for (s=access_string;*s;s++) 
    435     if (toupper(*s)=='W')     
     434  for (s=access_string;*s;s++)
     435    if (toupper(*s)=='W')
    436436      if (access)
    437437        access=O_RDWR;
    438438      else access=O_WRONLY;
    439439
    440   for (s=access_string;*s;s++) 
    441     if (toupper(*s)=='A')     
     440  for (s=access_string;*s;s++)
     441    if (toupper(*s)=='A')
    442442      access|=O_APPEND|O_WRONLY;
    443443
     
    465465    total_files_open--;
    466466    if (fd != spec_main_fd)
    467             close(fd);
     467        close(fd);
    468468  }
    469469}
     
    471471int jFILE::unbuffered_tell()
    472472{
    473 //      int ret = ::lseek(fd,0,SEEK_CUR) - start_offset;
    474 //      if (ret != current_offset)
    475 //              fprintf(stderr,"Bad tell %d\n",current_offset);
    476         return current_offset;
     473//    int ret = ::lseek(fd,0,SEEK_CUR) - start_offset;
     474//    if (ret != current_offset)
     475//        fprintf(stderr,"Bad tell %d\n",current_offset);
     476    return current_offset;
    477477}
    478478
    479479int jFILE::unbuffered_read(void *buf, size_t count)
    480480{
    481         unsigned long len;
    482 
    483         if (fd == spec_main_fd)
    484         {
    485                 switch (fast_load_mode)
    486                 {
    487                 case 0:
    488                         if (current_offset+start_offset != spec_main_offset)
    489                                 spec_main_offset = lseek(fd, start_offset+current_offset, SEEK_SET);
    490                        
    491                         len = ::read(fd,(char*)buf,count);
    492                         break;
    493                 case 1:
    494                         if (current_offset+start_offset != spec_main_offset)
    495                                 spec_main_offset = lseek(fd, start_offset+current_offset, SEEK_SET);
    496                        
    497                         len = ::read(fd,(char*)buf,count);
    498                         ::write(fast_load_fd,(char*)&len,sizeof(len));
    499                         ::write(fast_load_fd,(char*)buf,len);
    500                         break;
    501                 case 2:
    502                         ::read(fast_load_fd,(char*)&len,sizeof(len));
    503                         len = ::read(fast_load_fd,(char*)buf,len);
    504                         break;
    505                 }
    506                
    507                 spec_main_offset += len;
    508         }
    509         else
    510         {
    511                 switch (fast_load_mode)
    512                 {
    513                 case 0:
    514                 len = ::read(fd,(char*)buf,count);
    515                 break;
    516                 case 1:
    517                 len = ::read(fd,(char*)buf,count);
    518                         ::write(fast_load_fd,(char*)&len,sizeof(len));
    519                         ::write(fast_load_fd,(char*)buf,len);
    520                 break;
    521                 case 2:
    522                         ::read(fast_load_fd,(char*)&len,sizeof(len));
    523                         len = ::read(fast_load_fd,(char*)buf,len);
    524                         if (count != len)
    525                                 printf("short read! %ld:%ld\n",current_offset,len);
    526                 break;
    527           }
    528         }
    529         current_offset += len;
    530         return len;
     481    unsigned long len;
     482
     483    if (fd == spec_main_fd)
     484    {
     485        switch (fast_load_mode)
     486        {
     487        case 0:
     488            if (current_offset+start_offset != spec_main_offset)
     489                spec_main_offset = lseek(fd, start_offset+current_offset, SEEK_SET);
     490           
     491            len = ::read(fd,(char*)buf,count);
     492            break;
     493        case 1:
     494            if (current_offset+start_offset != spec_main_offset)
     495                spec_main_offset = lseek(fd, start_offset+current_offset, SEEK_SET);
     496           
     497            len = ::read(fd,(char*)buf,count);
     498            ::write(fast_load_fd,(char*)&len,sizeof(len));
     499            ::write(fast_load_fd,(char*)buf,len);
     500            break;
     501        case 2:
     502            ::read(fast_load_fd,(char*)&len,sizeof(len));
     503            len = ::read(fast_load_fd,(char*)buf,len);
     504            break;
     505        }
     506       
     507        spec_main_offset += len;
     508    }
     509    else
     510    {
     511        switch (fast_load_mode)
     512        {
     513        case 0:
     514          len = ::read(fd,(char*)buf,count);
     515          break;
     516        case 1:
     517          len = ::read(fd,(char*)buf,count);
     518            ::write(fast_load_fd,(char*)&len,sizeof(len));
     519            ::write(fast_load_fd,(char*)buf,len);
     520          break;
     521        case 2:
     522            ::read(fast_load_fd,(char*)&len,sizeof(len));
     523            len = ::read(fast_load_fd,(char*)buf,len);
     524            if (count != len)
     525                printf("short read! %ld:%ld\n",current_offset,len);
     526          break;
     527      }
     528    }
     529    current_offset += len;
     530    return len;
    531531}
    532532
     
    534534{
    535535  long ret = ::write(fd,(char*)buf,count);
    536         current_offset += ret;
    537         return ret;
     536    current_offset += ret;
     537    return ret;
    538538}
    539539
     
    546546    switch (whence)
    547547    {
    548     case SEEK_SET : 
     548    case SEEK_SET :
    549549      current_offset = start_offset+offset;
    550550      break;
    551     case SEEK_END : 
     551    case SEEK_END :
    552552      current_offset = start_offset+file_length-offset;
    553553      break;
    554     case SEEK_CUR : 
     554    case SEEK_CUR :
    555555      current_offset += offset;
    556556      break;
     
    564564  switch (whence)
    565565  {
    566     case SEEK_SET : 
     566    case SEEK_SET :
    567567    { ret = lseek(fd,start_offset+offset,SEEK_SET); } break;
    568     case SEEK_END : 
     568    case SEEK_END :
    569569    { ret = lseek(fd,start_offset+file_length-offset,SEEK_SET); } break;
    570     case SEEK_CUR : 
     570    case SEEK_CUR :
    571571    { ret = lseek(fd,offset,SEEK_CUR); } break;
    572572    default:
    573         ret = -1;
    574         break;
     573        ret = -1;
     574        break;
    575575  }
    576576  if (ret>=0)
     
    593593
    594594uint16_t bFILE::read_uint16()
    595 { 
     595{
    596596  uint16_t x;
    597   read(&x,2); 
     597  read(&x,2);
    598598  return uint16_to_local(x);
    599599}
     
    601601
    602602uint32_t bFILE::read_uint32()
    603 { 
     603{
    604604  uint32_t x;
    605   read(&x,4); 
     605  read(&x,4);
    606606  return uint32_to_local(x);
    607607}
     
    613613
    614614void bFILE::write_uint16(uint16_t x)
    615 { 
     615{
    616616  x=uint16_to_local(x);
    617617  write(&x,2);
     
    661661  long o=SPEC_SIG_SIZE+2;
    662662  if (total)
    663   { 
     663  {
    664664    for (i=0,e=entries;i<total;i++,e++)          // calculate the size of directory info
    665665    {
     
    738738  spec_entry **se;
    739739  int i;
    740   printf("[   Entry type   ][   Entry name   ][  Size  ][ Offset ]\n"); 
     740  printf("[   Entry type   ][   Entry name   ][  Size  ][ Offset ]\n");
    741741  for (i=0,se=entries;i<total;i++,se++)
    742742    (*se)->print();
     
    752752  size=0;
    753753  if (!strcmp(buf,SPEC_SIGNATURE))
    754   {   
    755     total=fp->read_uint16();   
     754  {
     755    total=fp->read_uint16();
    756756    entries=(spec_entry **)jmalloc(sizeof(spec_entry *)*total,"spec_directory::entries");
    757757    long start=fp->tell();
     
    759759    int i;
    760760    for (i=0;i<total;i++)
    761     {           
     761    {
    762762      fp->read(buf,2);
    763763      long entry_size=sizeof(spec_entry)+(unsigned char)buf[1];
     
    772772    fp->seek(start,SEEK_SET);
    773773    for (i=0;i<total;i++)
    774     {           
     774    {
    775775      spec_entry *se=(spec_entry *)dp;
    776776      entries[i]=se;
    777777
    778778      unsigned char len,flags,type;
    779       fp->read(&type,1);     
    780       fp->read(&len,1); 
     779      fp->read(&type,1);
     780      fp->read(&len,1);
    781781      se->type=type;
    782782      se->name=dp+sizeof(spec_entry);
    783783      fp->read(se->name,len);
    784       fp->read(&flags,1); 
     784      fp->read(&flags,1);
    785785
    786786      se->size=fp->read_uint32();
     
    789789    }
    790790  }
    791   else 
     791  else
    792792  {
    793793    total=0;
    794794    data=NULL;
    795795    entries=NULL;
    796   } 
     796  }
    797797}
    798798
     
    845845    /* FIXME: no need for a for loop here! */
    846846    long i;
    847     for(i = 0; i < total; i++) 
     847    for(i = 0; i < total; i++)
    848848        return entries[i]->offset;
    849849
    850850    // If no entries, then no data, but return where it would start anyway
    851851    return SPEC_SIG_SIZE + 2;
    852 } 
     852}
    853853
    854854long spec_directory::data_end_offset()
     
    861861
    862862  return SPEC_SIG_SIZE+2;
    863 } 
     863}
    864864
    865865int spec_directory::write(bFILE *fp)
     
    882882    if (!write_string(fp,(*e)->name))                return 0;
    883883    flags=0;
    884     if (fp->write(&flags,1)!=1)                     return 0; 
    885 
    886     data_size=uint32_to_intel((*e)->size); 
    887     if (fp->write((char *)&data_size,4)!=4)              return 0; 
     884    if (fp->write(&flags,1)!=1)                     return 0;
     885
     886    data_size=uint32_to_intel((*e)->size);
     887    if (fp->write((char *)&data_size,4)!=4)              return 0;
    888888    offset=uint32_to_intel((*e)->offset);
    889     if (fp->write((char *)&offset,4)!=4)                  return 0; 
    890 
    891   }
    892   return 1; 
     889    if (fp->write((char *)&offset,4)!=4)                  return 0;
     890
     891  }
     892  return 1;
    893893}
    894894
     
    909909{
    910910  uint16_t x;
    911   fread(&x,1,2,fp); 
     911  fread(&x,1,2,fp);
    912912  return uint16_to_local(x);
    913913}
     
    961961}
    962962
    963 void spec_directory::remove(spec_entry *e) 
    964 { 
     963void spec_directory::remove(spec_entry *e)
     964{
    965965  int i;
    966966  for (i=0;i<total && entries[i]!=e;i++);            // find the entry in the array first
    967  
     967
    968968  if (entries[i]==e)                                 // make sre it was found
    969969  {
     
    980980
    981981
    982 void spec_directory::add_by_hand(spec_entry *e) 
    983 { 
     982void spec_directory::add_by_hand(spec_entry *e)
     983{
    984984  total++;
    985985  entries=(spec_entry **)jrealloc(entries,sizeof(spec_entry *)*total,"spec_directory::entries");
Note: See TracChangeset for help on using the changeset viewer.