← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/archive/ha_archive.cc

Renamed __attribute__((__unused__)) to __attribute__((unused)). 
It takes up a few less chars, but also seems to be the standard usage.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/archive/ha_archive.cc
198
198
    false       OK
199
199
*/
200
200
 
201
 
int archive_db_done(void *p __attribute__((__unused__)))
 
201
int archive_db_done(void *p __attribute__((unused)))
202
202
{
203
203
  hash_free(&archive_open_tables);
204
204
  VOID(pthread_mutex_destroy(&archive_mutex));
218
218
  archive_reader_open= false;
219
219
}
220
220
 
221
 
int archive_discover(handlerton *hton __attribute__((__unused__)),
222
 
                     THD* thd __attribute__((__unused__)),
 
221
int archive_discover(handlerton *hton __attribute__((unused)),
 
222
                     THD* thd __attribute__((unused)),
223
223
                     const char *db,
224
224
                     const char *name,
225
225
                     uchar **frmblob,
465
465
  We open the file we will read from.
466
466
*/
467
467
int ha_archive::open(const char *name,
468
 
                     int mode __attribute__((__unused__)),
 
468
                     int mode __attribute__((unused)),
469
469
                     uint open_options)
470
470
{
471
471
  int rc= 0;
692
692
  the bytes required for the length in the header.
693
693
*/
694
694
 
695
 
uint32_t ha_archive::max_row_length(const uchar *buf __attribute__((__unused__)))
 
695
uint32_t ha_archive::max_row_length(const uchar *buf __attribute__((unused)))
696
696
{
697
697
  uint32_t length= (uint32_t)(table->s->reclength + table->s->fields*2);
698
698
  length+= ARCHIVE_ROW_HEADER_SIZE;
843
843
}
844
844
 
845
845
 
846
 
void ha_archive::get_auto_increment(uint64_t offset __attribute__((__unused__)),
847
 
                                    uint64_t increment __attribute__((__unused__)),
848
 
                                    uint64_t nb_desired_values __attribute__((__unused__)),
849
 
                                    uint64_t *first_value __attribute__((__unused__)),
850
 
                                    uint64_t *nb_reserved_values __attribute__((__unused__)))
 
846
void ha_archive::get_auto_increment(uint64_t offset __attribute__((unused)),
 
847
                                    uint64_t increment __attribute__((unused)),
 
848
                                    uint64_t nb_desired_values __attribute__((unused)),
 
849
                                    uint64_t *first_value __attribute__((unused)),
 
850
                                    uint64_t *nb_reserved_values __attribute__((unused)))
851
851
{
852
852
  *nb_reserved_values= UINT64_MAX;
853
853
  *first_value= share->archive_write.auto_increment + 1;
854
854
}
855
855
 
856
856
/* Initialized at each key walk (called multiple times unlike rnd_init()) */
857
 
int ha_archive::index_init(uint keynr, bool sorted __attribute__((__unused__)))
 
857
int ha_archive::index_init(uint keynr, bool sorted __attribute__((unused)))
858
858
{
859
859
  active_index= keynr;
860
860
  return(0);
876
876
 
877
877
int ha_archive::index_read_idx(uchar *buf, uint index, const uchar *key,
878
878
                               uint key_len,
879
 
                               enum ha_rkey_function find_flag __attribute__((__unused__)))
 
879
                               enum ha_rkey_function find_flag __attribute__((unused)))
880
880
{
881
881
  int rc;
882
882
  bool found= 0;
1052
1052
  needed.
1053
1053
*/
1054
1054
 
1055
 
void ha_archive::position(const uchar *record __attribute__((__unused__)))
 
1055
void ha_archive::position(const uchar *record __attribute__((unused)))
1056
1056
{
1057
1057
  my_store_ptr(ref, ref_length, current_position);
1058
1058
  return;
1096
1096
  The table can become fragmented if data was inserted, read, and then
1097
1097
  inserted again. What we do is open up the file and recompress it completely. 
1098
1098
*/
1099
 
int ha_archive::optimize(THD* thd __attribute__((__unused__)),
1100
 
                         HA_CHECK_OPT* check_opt __attribute__((__unused__)))
 
1099
int ha_archive::optimize(THD* thd __attribute__((unused)),
 
1100
                         HA_CHECK_OPT* check_opt __attribute__((unused)))
1101
1101
{
1102
1102
  int rc= 0;
1103
1103
  azio_stream writer;
1369
1369
*/
1370
1370
 
1371
1371
int ha_archive::check(THD* thd,
1372
 
                      HA_CHECK_OPT* check_opt __attribute__((__unused__)))
 
1372
                      HA_CHECK_OPT* check_opt __attribute__((unused)))
1373
1373
{
1374
1374
  int rc= 0;
1375
1375
  const char *old_proc_info;