← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/option.cc

  • Committer: Brian Aker
  • Date: 2011-08-16 01:07:54 UTC
  • mfrom: (2363.1.8 drizzle-trunk)
  • mto: This revision was merged to the branch mainline in revision 2399.
  • Revision ID: brian@tangent.org-20110816010754-14sxcxr7r9jczh6a
Fixes for --help work.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/option.cc
35
35
 
36
36
namespace drizzled {
37
37
 
38
 
  static void default_reporter(enum loglevel level, const char *format, ...)
39
 
  {
40
 
    va_list args;
41
 
    va_start(args, format);
42
 
    if (level == WARNING_LEVEL)
43
 
      fprintf(stderr, "%s", _("Warning: "));
44
 
    else if (level == INFORMATION_LEVEL)
45
 
      fprintf(stderr, "%s", _("Info: "));
46
 
    vfprintf(stderr, format, args);
47
 
    va_end(args);
48
 
    fputc('\n', stderr);
49
 
    fflush(stderr);
50
 
  }
51
 
 
52
 
  /*
 
38
static void default_reporter(enum loglevel level, const char *format, ...)
 
39
{
 
40
  va_list args;
 
41
  va_start(args, format);
 
42
 
 
43
  if (level == WARNING_LEVEL)
 
44
    fprintf(stderr, "%s", _("Warning: "));
 
45
  else if (level == INFORMATION_LEVEL)
 
46
    fprintf(stderr, "%s", _("Info: "));
 
47
 
 
48
  vfprintf(stderr, format, args);
 
49
  va_end(args);
 
50
  fputc('\n', stderr);
 
51
  fflush(stderr);
 
52
}
 
53
 
 
54
/*
53
55
function: compare_strings
54
56
 
55
57
Works like strncmp, other than 1.) considers '-' and '_' the same.
56
58
2.) Returns -1 if strings differ, 0 if they are equal
57
59
   */
58
60
 
59
 
  bool getopt_compare_strings(const char *s, const char *t,
60
 
      uint32_t length)
 
61
bool getopt_compare_strings(const char *s, const char *t, uint32_t length)
 
62
{
 
63
  char const *end= s + length;
 
64
  for (;s != end ; s++, t++)
61
65
  {
62
 
    char const *end= s + length;
63
 
    for (;s != end ; s++, t++)
 
66
    if ((*s != '-' ? *s : '_') != (*t != '-' ? *t : '_'))
64
67
    {
65
 
      if ((*s != '-' ? *s : '_') != (*t != '-' ? *t : '_'))
66
 
        return 1;
 
68
      return true;
67
69
    }
68
 
    return 0;
69
70
  }
70
71
 
71
 
  /*
 
72
  return false;
 
73
}
 
74
 
 
75
/*
72
76
function: getopt_ll_limit_value
73
77
 
74
78
Applies min/max/block_size to a numeric value of an option.
75
79
Returns "fixed" value.
76
80
   */
77
81
 
78
 
  int64_t getopt_ll_limit_value(int64_t num, const option& optp, bool *fix)
79
 
  {
80
 
    int64_t old= num;
81
 
    bool adjusted= false;
82
 
    char buf1[255], buf2[255];
83
 
    uint64_t block_size= optp.block_size ? optp.block_size : 1;
84
 
 
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 */
87
 
    {
88
 
      num= (uint64_t) optp.max_value;
89
 
      adjusted= true;
90
 
    }
91
 
 
92
 
    switch ((optp.var_type & GET_TYPE_MASK)) {
93
 
      case GET_INT:
94
 
        if (num > (int64_t) INT_MAX)
95
 
        {
96
 
          num= ((int64_t) INT_MAX);
97
 
          adjusted= true;
98
 
        }
99
 
        break;
100
 
      case GET_LONG:
101
 
        if (num > (int64_t) INT32_MAX)
102
 
        {
103
 
          num= ((int64_t) INT32_MAX);
104
 
          adjusted= true;
105
 
        }
106
 
        break;
107
 
      default:
108
 
        assert((optp.var_type & GET_TYPE_MASK) == GET_LL);
109
 
        break;
110
 
    }
111
 
 
112
 
    num= ((num - optp.sub_size) / block_size);
113
 
    num= (int64_t) (num * block_size);
114
 
 
115
 
    if (num < optp.min_value)
116
 
    {
117
 
      num= optp.min_value;
118
 
      adjusted= true;
119
 
    }
120
 
 
121
 
    if (fix)
122
 
      *fix= adjusted;
123
 
    else if (adjusted)
124
 
      default_reporter(WARNING_LEVEL,
125
 
          "option '%s': signed value %s adjusted to %s",
126
 
          optp.name, internal::llstr(old, buf1), internal::llstr(num, buf2));
127
 
    return num;
128
 
  }
129
 
 
130
 
  /*
 
82
int64_t getopt_ll_limit_value(int64_t num, const option& optp, bool *fix)
 
83
{
 
84
  int64_t old= num;
 
85
  bool adjusted= false;
 
86
  char buf1[255], buf2[255];
 
87
  uint64_t block_size= optp.block_size ? optp.block_size : 1;
 
88
 
 
89
  if (num > 0 && ((uint64_t) num > (uint64_t) optp.max_value) &&
 
90
      optp.max_value) /* if max value is not set -> no upper limit */
 
91
  {
 
92
    num= (uint64_t) optp.max_value;
 
93
    adjusted= true;
 
94
  }
 
95
 
 
96
  switch ((optp.var_type & GET_TYPE_MASK)) {
 
97
  case GET_INT:
 
98
    if (num > (int64_t) INT_MAX)
 
99
    {
 
100
      num= ((int64_t) INT_MAX);
 
101
      adjusted= true;
 
102
    }
 
103
    break;
 
104
  case GET_LONG:
 
105
    if (num > (int64_t) INT32_MAX)
 
106
    {
 
107
      num= ((int64_t) INT32_MAX);
 
108
      adjusted= true;
 
109
    }
 
110
    break;
 
111
  default:
 
112
    assert((optp.var_type & GET_TYPE_MASK) == GET_LL);
 
113
    break;
 
114
  }
 
115
 
 
116
  num= ((num - optp.sub_size) / block_size);
 
117
  num= (int64_t) (num * block_size);
 
118
 
 
119
  if (num < optp.min_value)
 
120
  {
 
121
    num= optp.min_value;
 
122
    adjusted= true;
 
123
  }
 
124
 
 
125
  if (fix)
 
126
  {
 
127
    *fix= adjusted;
 
128
  }
 
129
  else if (adjusted)
 
130
  {
 
131
    default_reporter(WARNING_LEVEL,
 
132
                     "option '%s': signed value %s adjusted to %s",
 
133
                     optp.name, internal::llstr(old, buf1), internal::llstr(num, buf2));
 
134
  }
 
135
  return num;
 
136
}
 
137
 
 
138
/*
131
139
function: getopt_ull
132
140
 
133
141
This is the same as getopt_ll, but is meant for uint64_t
134
142
values.
135
143
   */
136
144
 
137
 
  uint64_t getopt_ull_limit_value(uint64_t num, const option& optp, bool *fix)
138
 
  {
139
 
    bool adjusted= false;
140
 
    uint64_t old= num;
141
 
    char buf1[255], buf2[255];
142
 
 
143
 
    if ((uint64_t) num > (uint64_t) optp.max_value &&
144
 
        optp.max_value) /* if max value is not set -> no upper limit */
145
 
    {
146
 
      num= (uint64_t) optp.max_value;
147
 
      adjusted= true;
148
 
    }
149
 
 
150
 
    switch (optp.var_type & GET_TYPE_MASK)
151
 
    {
152
 
      case GET_UINT:
153
 
        if (num > UINT_MAX)
154
 
        {
155
 
          num= UINT_MAX;
156
 
          adjusted= true;
157
 
        }
158
 
        break;
159
 
      case GET_UINT32:
160
 
      case GET_ULONG_IS_FAIL:
161
 
        if (num > UINT32_MAX)
162
 
        {
163
 
          num= UINT32_MAX;
164
 
          adjusted= true;
165
 
        }
166
 
        break;
167
 
      case GET_SIZE:
168
 
        if (num > SIZE_MAX)
169
 
        {
170
 
          num= SIZE_MAX;
171
 
          adjusted= true;
172
 
        }
173
 
        break;
174
 
      default:
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;
187
 
      adjusted= true;
188
 
    }
189
 
 
190
 
    if (fix)
191
 
      *fix= adjusted;
192
 
    else if (adjusted)
193
 
      default_reporter(WARNING_LEVEL, "option '%s': unsigned value %s adjusted to %s",
194
 
          optp.name, internal::ullstr(old, buf1), internal::ullstr(num, buf2));
195
 
 
196
 
    return num;
197
 
  }
198
 
 
199
 
  
200
 
  /*
 
145
uint64_t getopt_ull_limit_value(uint64_t num, const option& optp, bool *fix)
 
146
{
 
147
  bool adjusted= false;
 
148
  uint64_t old= num;
 
149
  char buf1[255], buf2[255];
 
150
 
 
151
  if ((uint64_t) num > (uint64_t) optp.max_value &&
 
152
      optp.max_value) /* if max value is not set -> no upper limit */
 
153
  {
 
154
    num= (uint64_t) optp.max_value;
 
155
    adjusted= true;
 
156
  }
 
157
 
 
158
  switch (optp.var_type & GET_TYPE_MASK)
 
159
  {
 
160
  case GET_UINT:
 
161
    if (num > UINT_MAX)
 
162
    {
 
163
      num= UINT_MAX;
 
164
      adjusted= true;
 
165
    }
 
166
    break;
 
167
  case GET_UINT32:
 
168
  case GET_ULONG_IS_FAIL:
 
169
    if (num > UINT32_MAX)
 
170
    {
 
171
      num= UINT32_MAX;
 
172
      adjusted= true;
 
173
    }
 
174
    break;
 
175
  case GET_SIZE:
 
176
    if (num > SIZE_MAX)
 
177
    {
 
178
      num= SIZE_MAX;
 
179
      adjusted= true;
 
180
    }
 
181
    break;
 
182
  default:
 
183
    assert((optp.var_type & GET_TYPE_MASK) == GET_ULL || (optp.var_type & GET_TYPE_MASK) == GET_UINT64);
 
184
  }
 
185
 
 
186
  if (optp.block_size > 1)
 
187
  {
 
188
    num/= optp.block_size;
 
189
    num*= optp.block_size;
 
190
  }
 
191
 
 
192
  if (num < (uint64_t) optp.min_value)
 
193
  {
 
194
    num= (uint64_t) optp.min_value;
 
195
    adjusted= true;
 
196
  }
 
197
 
 
198
  if (fix)
 
199
    *fix= adjusted;
 
200
  else if (adjusted)
 
201
    default_reporter(WARNING_LEVEL, "option '%s': unsigned value %s adjusted to %s",
 
202
                     optp.name, internal::ullstr(old, buf1), internal::ullstr(num, buf2));
 
203
 
 
204
  return num;
 
205
}
 
206
 
 
207
 
 
208
/*
201
209
function: my_print_options
202
210
 
203
211
Print help for all options and variables.
204
212
   */
205
213
 
206
 
  void my_print_help(const option* options)
 
214
void my_print_help(const option* options)
 
215
{
 
216
  uint32_t col, name_space= 22, comment_space= 57;
 
217
  const char *line_end;
 
218
  const struct option *optp;
 
219
 
 
220
  for (optp= options; optp->id; optp++)
207
221
  {
208
 
    uint32_t col, name_space= 22, comment_space= 57;
209
 
    const char *line_end;
210
 
    const struct option *optp;
211
 
 
212
 
    for (optp= options; optp->id; optp++)
213
 
    {
214
 
      if (optp->id < 256)
215
 
      {
216
 
        printf("  -%c%s", optp->id, strlen(optp->name) ? ", " : "  ");
217
 
        col= 6;
 
222
    if (optp->id < 256)
 
223
    {
 
224
      printf("  -%c%s", optp->id, strlen(optp->name) ? ", " : "  ");
 
225
      col= 6;
 
226
    }
 
227
    else
 
228
    {
 
229
      printf("  ");
 
230
      col= 2;
 
231
    }
 
232
    if (strlen(optp->name))
 
233
    {
 
234
      printf("--%s", optp->name);
 
235
      col+= 2 + (uint32_t) strlen(optp->name);
 
236
      if ((optp->var_type & GET_TYPE_MASK) == GET_STR ||
 
237
          (optp->var_type & GET_TYPE_MASK) == GET_STR_ALLOC)
 
238
      {
 
239
        printf("%s=name%s ", optp->arg_type == OPT_ARG ? "[" : "",
 
240
               optp->arg_type == OPT_ARG ? "]" : "");
 
241
        col+= (optp->arg_type == OPT_ARG) ? 8 : 6;
 
242
      }
 
243
      else if ((optp->var_type & GET_TYPE_MASK) == GET_NO_ARG ||
 
244
               (optp->var_type & GET_TYPE_MASK) == GET_BOOL)
 
245
      {
 
246
        putchar(' ');
 
247
        col++;
218
248
      }
219
249
      else
220
250
      {
221
 
        printf("  ");
222
 
        col= 2;
223
 
      }
224
 
      if (strlen(optp->name))
225
 
      {
226
 
        printf("--%s", optp->name);
227
 
        col+= 2 + (uint32_t) strlen(optp->name);
228
 
        if ((optp->var_type & GET_TYPE_MASK) == GET_STR ||
229
 
            (optp->var_type & GET_TYPE_MASK) == GET_STR_ALLOC)
230
 
        {
231
 
          printf("%s=name%s ", optp->arg_type == OPT_ARG ? "[" : "",
232
 
              optp->arg_type == OPT_ARG ? "]" : "");
233
 
          col+= (optp->arg_type == OPT_ARG) ? 8 : 6;
234
 
        }
235
 
        else if ((optp->var_type & GET_TYPE_MASK) == GET_NO_ARG ||
236
 
            (optp->var_type & GET_TYPE_MASK) == GET_BOOL)
237
 
        {
 
251
        printf("%s=#%s ", optp->arg_type == OPT_ARG ? "[" : "",
 
252
               optp->arg_type == OPT_ARG ? "]" : "");
 
253
        col+= (optp->arg_type == OPT_ARG) ? 5 : 3;
 
254
      }
 
255
      if (col > name_space && optp->comment && *optp->comment)
 
256
      {
 
257
        putchar('\n');
 
258
        col= 0;
 
259
      }
 
260
    }
 
261
    for (; col < name_space; col++)
 
262
      putchar(' ');
 
263
    if (optp->comment && *optp->comment)
 
264
    {
 
265
      const char *comment= _(optp->comment), *end= strchr(comment, '\0');
 
266
 
 
267
      while ((uint32_t) (end - comment) > comment_space)
 
268
      {
 
269
        for (line_end= comment + comment_space; *line_end != ' '; line_end--)
 
270
        {}
 
271
        for (; comment != line_end; comment++)
 
272
          putchar(*comment);
 
273
        comment++; /* skip the space, as a newline will take it's place now */
 
274
        putchar('\n');
 
275
        for (col= 0; col < name_space; col++)
238
276
          putchar(' ');
239
 
          col++;
240
 
        }
241
 
        else
242
 
        {
243
 
          printf("%s=#%s ", optp->arg_type == OPT_ARG ? "[" : "",
244
 
              optp->arg_type == OPT_ARG ? "]" : "");
245
 
          col+= (optp->arg_type == OPT_ARG) ? 5 : 3;
246
 
        }
247
 
        if (col > name_space && optp->comment && *optp->comment)
248
 
        {
249
 
          putchar('\n');
250
 
          col= 0;
251
 
        }
252
 
      }
253
 
      for (; col < name_space; col++)
254
 
        putchar(' ');
255
 
      if (optp->comment && *optp->comment)
256
 
      {
257
 
        const char *comment= _(optp->comment), *end= strchr(comment, '\0');
258
 
 
259
 
        while ((uint32_t) (end - comment) > comment_space)
260
 
        {
261
 
          for (line_end= comment + comment_space; *line_end != ' '; line_end--)
262
 
          {}
263
 
          for (; comment != line_end; comment++)
264
 
            putchar(*comment);
265
 
          comment++; /* skip the space, as a newline will take it's place now */
266
 
          putchar('\n');
267
 
          for (col= 0; col < name_space; col++)
268
 
            putchar(' ');
269
 
        }
270
 
        printf("%s", comment);
271
 
      }
272
 
      putchar('\n');
273
 
      if ((optp->var_type & GET_TYPE_MASK) == GET_NO_ARG ||
274
 
          (optp->var_type & GET_TYPE_MASK) == GET_BOOL)
275
 
      {
276
 
        if (optp->def_value != 0)
277
 
        {
278
 
          printf(_("%*s(Defaults to on; use --skip-%s to disable.)\n"), name_space, "", optp->name);
279
 
        }
 
277
      }
 
278
      printf("%s", comment);
 
279
    }
 
280
    putchar('\n');
 
281
    if ((optp->var_type & GET_TYPE_MASK) == GET_NO_ARG ||
 
282
        (optp->var_type & GET_TYPE_MASK) == GET_BOOL)
 
283
    {
 
284
      if (optp->def_value != 0)
 
285
      {
 
286
        printf(_("%*s(Defaults to on; use --skip-%s to disable.)\n"), name_space, "", optp->name);
280
287
      }
281
288
    }
282
289
  }
 
290
}
283
291
 
284
292
 
285
293
} /* namespace drizzled */