← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/unireg.cc

  • Committer: Brian Aker
  • Date: 2008-10-06 05:57:49 UTC
  • Revision ID: brian@tangent.org-20081006055749-svg700gciuqi0zu1
Remove all of uchar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/unireg.cc
28
28
 
29
29
#define FCOMP                   17              /* Bytes for a packed field */
30
30
 
31
 
static uchar * pack_screens(List<Create_field> &create_fields,
 
31
static unsigned char * pack_screens(List<Create_field> &create_fields,
32
32
                            uint *info_length, uint *screens, bool small_file);
33
 
static uint pack_keys(uchar *keybuff,uint key_count, KEY *key_info,
 
33
static uint pack_keys(unsigned char *keybuff,uint key_count, KEY *key_info,
34
34
                      ulong data_offset);
35
 
static bool pack_header(uchar *forminfo,
 
35
static bool pack_header(unsigned char *forminfo,
36
36
                        List<Create_field> &create_fields,
37
37
                        uint info_length, uint screens, uint table_options,
38
38
                        ulong data_offset, handler *file);
107
107
  ulong key_buff_length;
108
108
  File file;
109
109
  ulong filepos, data_offset;
110
 
  uchar fileinfo[64],forminfo[288],*keybuff;
 
110
  unsigned char fileinfo[64],forminfo[288],*keybuff;
111
111
  TYPELIB formnames;
112
 
  uchar *screen_buff;
 
112
  unsigned char *screen_buff;
113
113
  char buff[128];
114
114
  const uint format_section_header_size= 8;
115
115
  uint format_section_len;
199
199
  else{
200
200
    strmake((char*) forminfo+47, create_info->comment.str ?
201
201
            create_info->comment.str : "", create_info->comment.length);
202
 
    forminfo[46]=(uchar) create_info->comment.length;
 
202
    forminfo[46]=(unsigned char) create_info->comment.length;
203
203
#ifdef EXTRA_DEBUG
204
204
    /*
205
205
      EXTRA_DEBUG causes strmake() to initialize its buffer behind the
218
218
  }
219
219
 
220
220
  key_buff_length= uint4korr(fileinfo+47);
221
 
  keybuff=(uchar*) my_malloc(key_buff_length, MYF(0));
 
221
  keybuff=(unsigned char*) my_malloc(key_buff_length, MYF(0));
222
222
  key_info_length= pack_keys(keybuff, keys, key_info, data_offset);
223
223
  get_form_pos(file,fileinfo,&formnames);
224
224
  if (!(filepos=make_new_entry(file,fileinfo,&formnames,"")))
226
226
  maxlength=(uint) next_io_size((ulong) (uint2korr(forminfo)+1000));
227
227
  int2store(forminfo+2,maxlength);
228
228
  int4store(fileinfo+10,(ulong) (filepos+maxlength));
229
 
  fileinfo[26]= (uchar) test((create_info->max_rows == 1) &&
 
229
  fileinfo[26]= (unsigned char) test((create_info->max_rows == 1) &&
230
230
                             (create_info->min_rows == 1) && (keys == 0));
231
231
  int2store(fileinfo+28,key_info_length);
232
232
 
245
245
    goto err;
246
246
 
247
247
  int2store(buff, create_info->connect_string.length);
248
 
  if (my_write(file, (const uchar*)buff, 2, MYF(MY_NABP)) ||
249
 
      my_write(file, (const uchar*)create_info->connect_string.str,
 
248
  if (my_write(file, (const unsigned char*)buff, 2, MYF(MY_NABP)) ||
 
249
      my_write(file, (const unsigned char*)create_info->connect_string.str,
250
250
               create_info->connect_string.length, MYF(MY_NABP)))
251
251
      goto err;
252
252
 
253
253
  int2store(buff, str_db_type.length);
254
 
  if (my_write(file, (const uchar*)buff, 2, MYF(MY_NABP)) ||
255
 
      my_write(file, (const uchar*)str_db_type.str,
 
254
  if (my_write(file, (const unsigned char*)buff, 2, MYF(MY_NABP)) ||
 
255
      my_write(file, (const unsigned char*)str_db_type.str,
256
256
               str_db_type.length, MYF(MY_NABP)))
257
257
    goto err;
258
258
 
259
259
  {
260
260
    memset(buff, 0, 6);
261
 
    if (my_write(file, (uchar*) buff, 6, MYF_RW))
 
261
    if (my_write(file, (unsigned char*) buff, 6, MYF_RW))
262
262
      goto err;
263
263
  }
264
264
 
265
 
  if (forminfo[46] == (uchar)255)
 
265
  if (forminfo[46] == (unsigned char)255)
266
266
  {
267
 
    uchar comment_length_buff[2];
 
267
    unsigned char comment_length_buff[2];
268
268
    int2store(comment_length_buff,create_info->comment.length);
269
269
    if (my_write(file, comment_length_buff, 2, MYF(MY_NABP)) ||
270
 
        my_write(file, (uchar*)create_info->comment.str,
 
270
        my_write(file, (unsigned char*)create_info->comment.str,
271
271
                  create_info->comment.length, MYF(MY_NABP)))
272
272
      goto err;
273
273
  }
286
286
      /* 2 bytes left for future use */
287
287
    }
288
288
    /* write header */
289
 
    if (my_write(file, (const uchar*)buff, format_section_header_size, MYF_RW))
 
289
    if (my_write(file, (const unsigned char*)buff, format_section_header_size, MYF_RW))
290
290
      goto err;
291
291
    buff[0]= 0;
292
 
    if (my_write(file, (const uchar*)buff, 1, MYF_RW))
 
292
    if (my_write(file, (const unsigned char*)buff, 1, MYF_RW))
293
293
      goto err;
294
294
    /* write column info, 1 byte per column */
295
295
    {
296
296
      List_iterator<Create_field> it(create_fields);
297
297
      Create_field *field;
298
 
      uchar column_format, write_byte;
 
298
      unsigned char column_format, write_byte;
299
299
      while ((field=it++))
300
300
      {
301
 
        column_format= (uchar)field->column_format();
 
301
        column_format= (unsigned char)field->column_format();
302
302
        write_byte= (column_format << COLUMN_FORMAT_SHIFT);
303
303
        if (my_write(file, &write_byte, 1, MYF_RW))
304
304
          goto err;
406
406
 
407
407
        /* Pack screens to a screen for save in a form-file */
408
408
 
409
 
static uchar *pack_screens(List<Create_field> &create_fields,
 
409
static unsigned char *pack_screens(List<Create_field> &create_fields,
410
410
                           uint *info_length, uint *screens,
411
411
                           bool small_file)
412
412
{
413
413
  register uint i;
414
414
  uint row,start_row,end_row,fields_on_screen;
415
415
  uint length,cols;
416
 
  uchar *info,*pos,*start_screen;
 
416
  unsigned char *info,*pos,*start_screen;
417
417
  uint fields=create_fields.elements;
418
418
  List_iterator<Create_field> it(create_fields);
419
419
  
427
427
  while ((field=it++))
428
428
    length+=(uint) strlen(field->field_name)+1+TE_INFO_LENGTH+cols/2;
429
429
 
430
 
  if (!(info=(uchar*) my_malloc(length,MYF(MY_WME))))
 
430
  if (!(info=(unsigned char*) my_malloc(length,MYF(MY_WME))))
431
431
    return(0);
432
432
 
433
433
  start_screen=0;
443
443
      {
444
444
        length=(uint) (pos-start_screen);
445
445
        int2store(start_screen,length);
446
 
        start_screen[2]=(uchar) (fields_on_screen+1);
447
 
        start_screen[3]=(uchar) (fields_on_screen);
 
446
        start_screen[2]=(unsigned char) (fields_on_screen+1);
 
447
        start_screen[3]=(unsigned char) (fields_on_screen);
448
448
      }
449
449
      row=start_row;
450
450
      start_screen=pos;
451
451
      pos+=4;
452
 
      pos[0]= (uchar) start_row-2;      /* Header string */
453
 
      pos[1]= (uchar) (cols >> 2);
454
 
      pos[2]= (uchar) (cols >> 1) +1;
 
452
      pos[0]= (unsigned char) start_row-2;      /* Header string */
 
453
      pos[1]= (unsigned char) (cols >> 2);
 
454
      pos[2]= (unsigned char) (cols >> 1) +1;
455
455
      strfill((char *) pos+3,(uint) (cols >> 1),' ');
456
456
      pos+=(cols >> 1)+4;
457
457
    }
461
461
 
462
462
    if (!small_file)
463
463
    {
464
 
      pos[0]=(uchar) row;
 
464
      pos[0]=(unsigned char) row;
465
465
      pos[1]=0;
466
 
      pos[2]=(uchar) (length+1);
467
 
      pos=(uchar*) strmake((char*) pos+3,cfield->field_name,length)+1;
 
466
      pos[2]=(unsigned char) (length+1);
 
467
      pos=(unsigned char*) strmake((char*) pos+3,cfield->field_name,length)+1;
468
468
    }
469
469
    cfield->row=(uint8_t) row;
470
470
    cfield->col=(uint8_t) (length+1);
472
472
  }
473
473
  length=(uint) (pos-start_screen);
474
474
  int2store(start_screen,length);
475
 
  start_screen[2]=(uchar) (row-start_row+2);
476
 
  start_screen[3]=(uchar) (row-start_row+1);
 
475
  start_screen[2]=(unsigned char) (row-start_row+2);
 
476
  start_screen[3]=(unsigned char) (row-start_row+1);
477
477
 
478
478
  *info_length=(uint) (pos-info);
479
479
  return(info);
482
482
 
483
483
        /* Pack keyinfo and keynames to keybuff for save in form-file. */
484
484
 
485
 
static uint pack_keys(uchar *keybuff, uint key_count, KEY *keyinfo,
 
485
static uint pack_keys(unsigned char *keybuff, uint key_count, KEY *keyinfo,
486
486
                      ulong data_offset)
487
487
{
488
488
  uint key_parts,length;
489
 
  uchar *pos, *keyname_pos;
 
489
  unsigned char *pos, *keyname_pos;
490
490
  KEY *key,*end;
491
491
  KEY_PART_INFO *key_part,*key_part_end;
492
492
  
497
497
  {
498
498
    int2store(pos, (key->flags ^ HA_NOSAME));
499
499
    int2store(pos+2,key->key_length);
500
 
    pos[4]= (uchar) key->key_parts;
501
 
    pos[5]= (uchar) key->algorithm;
 
500
    pos[4]= (unsigned char) key->key_parts;
 
501
    pos[5]= (unsigned char) key->algorithm;
502
502
    int2store(pos+6, key->block_size);
503
503
    pos+=8;
504
504
    key_parts+=key->key_parts;
519
519
  }
520
520
        /* Save keynames */
521
521
  keyname_pos=pos;
522
 
  *pos++=(uchar) NAMES_SEP_CHAR;
 
522
  *pos++=(unsigned char) NAMES_SEP_CHAR;
523
523
  for (key=keyinfo ; key != end ; key++)
524
524
  {
525
 
    uchar *tmp=(uchar*) my_stpcpy((char*) pos,key->name);
526
 
    *tmp++= (uchar) NAMES_SEP_CHAR;
 
525
    unsigned char *tmp=(unsigned char*) my_stpcpy((char*) pos,key->name);
 
526
    *tmp++= (unsigned char) NAMES_SEP_CHAR;
527
527
    *tmp=0;
528
528
    pos=tmp;
529
529
  }
534
534
    if (key->flags & HA_USES_COMMENT)
535
535
    {
536
536
      int2store(pos, key->comment.length);
537
 
      uchar *tmp= (uchar*)my_stpncpy((char*) pos+2,key->comment.str,key->comment.length);
 
537
      unsigned char *tmp= (unsigned char*)my_stpncpy((char*) pos+2,key->comment.str,key->comment.length);
538
538
      pos= tmp;
539
539
    }
540
540
  }
547
547
  }
548
548
  else
549
549
  {
550
 
    keybuff[0]=(uchar) key_count;
551
 
    keybuff[1]=(uchar) key_parts;
 
550
    keybuff[0]=(unsigned char) key_count;
 
551
    keybuff[1]=(unsigned char) key_parts;
552
552
    keybuff[2]= keybuff[3]= 0;
553
553
  }
554
554
  length=(uint) (pos-keyname_pos);
559
559
 
560
560
/* Make formheader */
561
561
 
562
 
static bool pack_header(uchar *forminfo,
 
562
static bool pack_header(unsigned char *forminfo,
563
563
                        List<Create_field> &create_fields,
564
564
                        uint info_length, uint screens, uint table_options,
565
565
                        ulong data_offset, handler *file)
752
752
{
753
753
  register uint i;
754
754
  uint int_count, comment_length=0;
755
 
  uchar buff[MAX_FIELD_WIDTH];
 
755
  unsigned char buff[MAX_FIELD_WIDTH];
756
756
  Create_field *field;
757
757
  
758
758
 
764
764
  while ((field=it++))
765
765
  {
766
766
    uint recpos;
767
 
    buff[0]= (uchar) field->row;
768
 
    buff[1]= (uchar) field->col;
769
 
    buff[2]= (uchar) field->sc_length;
 
767
    buff[0]= (unsigned char) field->row;
 
768
    buff[1]= (unsigned char) field->col;
 
769
    buff[2]= (unsigned char) field->sc_length;
770
770
    int2store(buff+3, field->length);
771
771
    /* The +1 is here becasue the col offset in .frm file have offset 1 */
772
772
    recpos= field->offset+1 + (uint) data_offset;
773
773
    int3store(buff+5,recpos);
774
774
    int2store(buff+8,field->pack_flag);
775
775
    int2store(buff+10,field->unireg_check);
776
 
    buff[12]= (uchar) field->interval_id;
777
 
    buff[13]= (uchar) field->sql_type; 
 
776
    buff[12]= (unsigned char) field->interval_id;
 
777
    buff[13]= (unsigned char) field->sql_type; 
778
778
    if (field->charset) 
779
 
      buff[14]= (uchar) field->charset->number;
 
779
      buff[14]= (unsigned char) field->charset->number;
780
780
    else
781
781
      buff[14]= 0;                              // Numerical
782
782
    int2store(buff+15, field->comment.length);
787
787
  }
788
788
 
789
789
        /* Write fieldnames */
790
 
  buff[0]=(uchar) NAMES_SEP_CHAR;
 
790
  buff[0]=(unsigned char) NAMES_SEP_CHAR;
791
791
  if (my_write(file, buff, 1, MYF_RW))
792
792
    return(1);
793
793
  i=0;
858
858
        tmp.append('\0');                      // End of intervall
859
859
      }
860
860
    }
861
 
    if (my_write(file,(uchar*) tmp.ptr(),tmp.length(),MYF_RW))
 
861
    if (my_write(file,(unsigned char*) tmp.ptr(),tmp.length(),MYF_RW))
862
862
      return(1);
863
863
  }
864
864
  if (comment_length)
868
868
    while ((field=it++))
869
869
    {
870
870
      if (field->comment.length)
871
 
        if (my_write(file, (uchar*) field->comment.str, field->comment.length,
 
871
        if (my_write(file, (unsigned char*) field->comment.str, field->comment.length,
872
872
                     MYF_RW))
873
873
          return(1);
874
874
    }
890
890
  int error= 0;
891
891
  Field::utype type;
892
892
  uint null_count;
893
 
  uchar *buff,*null_pos;
 
893
  unsigned char *buff,*null_pos;
894
894
  Table table;
895
895
  TABLE_SHARE share;
896
896
  Create_field *field;
902
902
  memset(&share, 0, sizeof(share));
903
903
  table.s= &share;
904
904
 
905
 
  if (!(buff=(uchar*) my_malloc((size_t) reclength,MYF(MY_WME | MY_ZEROFILL))))
 
905
  if (!(buff=(unsigned char*) my_malloc((size_t) reclength,MYF(MY_WME | MY_ZEROFILL))))
906
906
  {
907
907
    return(1);
908
908
  }
987
987
    of 8 there are no unused bits.
988
988
  */
989
989
  if (null_count & 7)
990
 
    *(null_pos + null_count / 8)|= ~(((uchar) 1 << (null_count & 7)) - 1);
 
990
    *(null_pos + null_count / 8)|= ~(((unsigned char) 1 << (null_count & 7)) - 1);
991
991
 
992
992
  error= my_write(file, buff, (size_t) reclength,MYF_RW) != 0;
993
993