← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/option.cc

Refactor

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/option.cc
35
35
 
36
36
namespace drizzled {
37
37
 
38
 
  typedef void (*init_func_p)(const struct option *option, char **variable, int64_t value);
39
 
 
40
 
  void default_reporter(enum loglevel level, const char *format, ...);
41
 
  my_error_reporter my_getopt_error_reporter= &default_reporter;
42
 
 
43
 
  bool my_getopt_skip_unknown= false;
44
 
 
45
 
  void default_reporter(enum loglevel level, const char *format, ...)
 
38
  static void default_reporter(enum loglevel level, const char *format, ...)
46
39
  {
47
40
    va_list args;
48
41
    va_start(args, format);
82
75
Returns "fixed" value.
83
76
   */
84
77
 
85
 
  int64_t getopt_ll_limit_value(int64_t num, const struct option *optp,
86
 
      bool *fix)
 
78
  int64_t getopt_ll_limit_value(int64_t num, const option& optp, bool *fix)
87
79
  {
88
80
    int64_t old= num;
89
81
    bool adjusted= false;
90
82
    char buf1[255], buf2[255];
91
 
    uint64_t block_size= optp->block_size ? optp->block_size : 1;
 
83
    uint64_t block_size= optp.block_size ? optp.block_size : 1;
92
84
 
93
 
    if (num > 0 && ((uint64_t) num > (uint64_t) optp->max_value) &&
94
 
        optp->max_value) /* if max value is not set -> no upper limit */
 
85
    if (num > 0 && ((uint64_t) num > (uint64_t) optp.max_value) &&
 
86
        optp.max_value) /* if max value is not set -> no upper limit */
95
87
    {
96
 
      num= (uint64_t) optp->max_value;
 
88
      num= (uint64_t) optp.max_value;
97
89
      adjusted= true;
98
90
    }
99
91
 
100
 
    switch ((optp->var_type & GET_TYPE_MASK)) {
 
92
    switch ((optp.var_type & GET_TYPE_MASK)) {
101
93
      case GET_INT:
102
94
        if (num > (int64_t) INT_MAX)
103
95
        {
113
105
        }
114
106
        break;
115
107
      default:
116
 
        assert((optp->var_type & GET_TYPE_MASK) == GET_LL);
 
108
        assert((optp.var_type & GET_TYPE_MASK) == GET_LL);
117
109
        break;
118
110
    }
119
111
 
120
 
    num= ((num - optp->sub_size) / block_size);
 
112
    num= ((num - optp.sub_size) / block_size);
121
113
    num= (int64_t) (num * block_size);
122
114
 
123
 
    if (num < optp->min_value)
 
115
    if (num < optp.min_value)
124
116
    {
125
 
      num= optp->min_value;
 
117
      num= optp.min_value;
126
118
      adjusted= true;
127
119
    }
128
120
 
129
121
    if (fix)
130
122
      *fix= adjusted;
131
123
    else if (adjusted)
132
 
      my_getopt_error_reporter(WARNING_LEVEL,
 
124
      default_reporter(WARNING_LEVEL,
133
125
          "option '%s': signed value %s adjusted to %s",
134
 
          optp->name, internal::llstr(old, buf1), internal::llstr(num, buf2));
 
126
          optp.name, internal::llstr(old, buf1), internal::llstr(num, buf2));
135
127
    return num;
136
128
  }
137
129
 
142
134
values.
143
135
   */
144
136
 
145
 
  uint64_t getopt_ull_limit_value(uint64_t num, const struct option *optp,
146
 
      bool *fix)
 
137
  uint64_t getopt_ull_limit_value(uint64_t num, const option& optp, bool *fix)
147
138
  {
148
139
    bool adjusted= false;
149
140
    uint64_t old= num;
150
141
    char buf1[255], buf2[255];
151
142
 
152
 
    if ((uint64_t) num > (uint64_t) optp->max_value &&
153
 
        optp->max_value) /* if max value is not set -> no upper limit */
 
143
    if ((uint64_t) num > (uint64_t) optp.max_value &&
 
144
        optp.max_value) /* if max value is not set -> no upper limit */
154
145
    {
155
 
      num= (uint64_t) optp->max_value;
 
146
      num= (uint64_t) optp.max_value;
156
147
      adjusted= true;
157
148
    }
158
149
 
159
 
    switch (optp->var_type & GET_TYPE_MASK)
 
150
    switch (optp.var_type & GET_TYPE_MASK)
160
151
    {
161
152
      case GET_UINT:
162
153
        if (num > UINT_MAX)
181
172
        }
182
173
        break;
183
174
      default:
184
 
        assert((optp->var_type & GET_TYPE_MASK) == GET_ULL || (optp->var_type & GET_TYPE_MASK) == GET_UINT64);
185
 
    }
186
 
 
187
 
    if (optp->block_size > 1)
188
 
    {
189
 
      num/= optp->block_size;
190
 
      num*= optp->block_size;
191
 
    }
192
 
 
193
 
    if (num < (uint64_t) optp->min_value)
194
 
    {
195
 
      num= (uint64_t) optp->min_value;
 
175
        assert((optp.var_type & GET_TYPE_MASK) == GET_ULL || (optp.var_type & GET_TYPE_MASK) == GET_UINT64);
 
176
    }
 
177
 
 
178
    if (optp.block_size > 1)
 
179
    {
 
180
      num/= optp.block_size;
 
181
      num*= optp.block_size;
 
182
    }
 
183
 
 
184
    if (num < (uint64_t) optp.min_value)
 
185
    {
 
186
      num= (uint64_t) optp.min_value;
196
187
      adjusted= true;
197
188
    }
198
189
 
199
190
    if (fix)
200
191
      *fix= adjusted;
201
192
    else if (adjusted)
202
 
      my_getopt_error_reporter(WARNING_LEVEL, "option '%s': unsigned value %s adjusted to %s",
203
 
          optp->name, internal::ullstr(old, buf1), internal::ullstr(num, buf2));
 
193
      default_reporter(WARNING_LEVEL, "option '%s': unsigned value %s adjusted to %s",
 
194
          optp.name, internal::ullstr(old, buf1), internal::ullstr(num, buf2));
204
195
 
205
196
    return num;
206
197
  }
212
203
Print help for all options and variables.
213
204
   */
214
205
 
215
 
  void my_print_help(const struct option *options)
 
206
  void my_print_help(const option* options)
216
207
  {
217
208
    uint32_t col, name_space= 22, comment_space= 57;
218
209
    const char *line_end;