← Back to branch summary

~gaul/percona-data-recovery-tool-for-innodb/prerequisites

« back to all changes in this revision

Viewing changes to mysql-source/strings/int2str.c

  • Committer: Aleksandr Kuzminsky
  • Date: 2010-01-14 13:05:06 UTC
  • mfrom: (1.1.1 page-signature-check)
  • Revision ID: aleksandr.kuzminsky@percona.com-20100114130506-72t6jxtll15gk3pp
Added InnoDB page signature check.
At the beginning of InnoDB page (type FIL_PAGE_INODE) there are infimum and supremum records.
They are located in fixed position depending on InnoDB page format(REDUNDANT (4.x and 5.x versions) or COMPACT(5.x only)).

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysql-source/strings/int2str.c
 
1
/* Copyright (C) 2000 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
#include <my_global.h>
 
17
#include "m_string.h"
 
18
 
 
19
/*
 
20
  _dig_vec arrays are public because they are used in several outer places.
 
21
*/
 
22
char NEAR _dig_vec_upper[] =
 
23
  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
24
char NEAR _dig_vec_lower[] =
 
25
  "0123456789abcdefghijklmnopqrstuvwxyz";
 
26
 
 
27
 
 
28
/*
 
29
  Convert integer to its string representation in given scale of notation.
 
30
   
 
31
  SYNOPSIS
 
32
    int2str()
 
33
      val     - value to convert
 
34
      dst     - points to buffer where string representation should be stored
 
35
      radix   - radix of scale of notation
 
36
      upcase  - set to 1 if we should use upper-case digits
 
37
 
 
38
  DESCRIPTION
 
39
    Converts the (long) integer value to its character form and moves it to 
 
40
    the destination buffer followed by a terminating NUL. 
 
41
    If radix is -2..-36, val is taken to be SIGNED, if radix is  2..36, val is
 
42
    taken to be UNSIGNED. That is, val is signed if and only if radix is. 
 
43
    All other radixes treated as bad and nothing will be changed in this case.
 
44
 
 
45
    For conversion to decimal representation (radix is -10 or 10) one can use
 
46
    optimized int10_to_str() function.
 
47
 
 
48
  RETURN VALUE
 
49
    Pointer to ending NUL character or NullS if radix is bad.
 
50
*/
 
51
  
 
52
char *
 
53
int2str(register long int val, register char *dst, register int radix, 
 
54
        int upcase)
 
55
{
 
56
  char buffer[65];
 
57
  register char *p;
 
58
  long int new_val;
 
59
  char *dig_vec= upcase ? _dig_vec_upper : _dig_vec_lower;
 
60
 
 
61
  if (radix < 0)
 
62
  {
 
63
    if (radix < -36 || radix > -2)
 
64
      return NullS;
 
65
    if (val < 0)
 
66
    {
 
67
      *dst++ = '-';
 
68
      val = -val;
 
69
    }
 
70
    radix = -radix;
 
71
  }
 
72
  else if (radix > 36 || radix < 2)
 
73
    return NullS;
 
74
 
 
75
  /*
 
76
    The slightly contorted code which follows is due to the fact that
 
77
    few machines directly support unsigned long / and %.  Certainly
 
78
    the VAX C compiler generates a subroutine call.  In the interests
 
79
    of efficiency (hollow laugh) I let this happen for the first digit
 
80
    only; after that "val" will be in range so that signed integer
 
81
    division will do.  Sorry 'bout that.  CHECK THE CODE PRODUCED BY
 
82
    YOUR C COMPILER.  The first % and / should be unsigned, the second
 
83
    % and / signed, but C compilers tend to be extraordinarily
 
84
    sensitive to minor details of style.  This works on a VAX, that's
 
85
    all I claim for it.
 
86
  */
 
87
  p = &buffer[sizeof(buffer)-1];
 
88
  *p = '\0';
 
89
  new_val=(ulong) val / (ulong) radix;
 
90
  *--p = dig_vec[(uchar) ((ulong) val- (ulong) new_val*(ulong) radix)];
 
91
  val = new_val;
 
92
#ifdef HAVE_LDIV
 
93
  while (val != 0)
 
94
  {
 
95
    ldiv_t res;
 
96
    res=ldiv(val,radix);
 
97
    *--p = dig_vec[res.rem];
 
98
    val= res.quot;
 
99
  }
 
100
#else
 
101
  while (val != 0)
 
102
  {
 
103
    new_val=val/radix;
 
104
    *--p = dig_vec[(uchar) (val-new_val*radix)];
 
105
    val= new_val;
 
106
  }
 
107
#endif
 
108
  while ((*dst++ = *p++) != 0) ;
 
109
  return dst-1;
 
110
}
 
111
 
 
112
 
 
113
/*
 
114
  Converts integer to its string representation in decimal notation.
 
115
   
 
116
  SYNOPSIS
 
117
    int10_to_str()
 
118
      val     - value to convert
 
119
      dst     - points to buffer where string representation should be stored
 
120
      radix   - flag that shows whenever val should be taken as signed or not
 
121
 
 
122
  DESCRIPTION
 
123
    This is version of int2str() function which is optimized for normal case
 
124
    of radix 10/-10. It takes only sign of radix parameter into account and 
 
125
    not its absolute value.
 
126
 
 
127
  RETURN VALUE
 
128
    Pointer to ending NUL character.
 
129
*/
 
130
 
 
131
char *int10_to_str(long int val,char *dst,int radix)
 
132
{
 
133
  char buffer[65];
 
134
  register char *p;
 
135
  long int new_val;
 
136
 
 
137
  if (radix < 0)                                /* -10 */
 
138
  {
 
139
    if (val < 0)
 
140
    {
 
141
      *dst++ = '-';
 
142
      val = -val;
 
143
    }
 
144
  }
 
145
 
 
146
  p = &buffer[sizeof(buffer)-1];
 
147
  *p = '\0';
 
148
  new_val= (long) ((unsigned long int) val / 10);
 
149
  *--p = '0'+ (char) ((unsigned long int) val - (unsigned long) new_val * 10);
 
150
  val = new_val;
 
151
 
 
152
  while (val != 0)
 
153
  {
 
154
    new_val=val/10;
 
155
    *--p = '0' + (char) (val-new_val*10);
 
156
    val= new_val;
 
157
  }
 
158
  while ((*dst++ = *p++) != 0) ;
 
159
  return dst-1;
 
160
}