lib/ecoli_tk_int.c

   1 /*
   2  * Copyright (c) 2016, Olivier MATZ <zer0@droids-corp.org>
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  *     * Redistributions of source code must retain the above copyright
   8  *       notice, this list of conditions and the following disclaimer.
   9  *     * Redistributions in binary form must reproduce the above copyright
  10  *       notice, this list of conditions and the following disclaimer in the
  11  *       documentation and/or other materials provided with the distribution.
  12  *     * Neither the name of the University of California, Berkeley nor the
  13  *       names of its contributors may be used to endorse or promote products
  14  *       derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
  17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  * DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
  20  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  21  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  22  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  23  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  25  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <limits.h>
  32 #include <ctype.h>
  33 #include <errno.h>
  34
  35 #include <ecoli_log.h>
  36 #include <ecoli_malloc.h>
  37 #include <ecoli_tk.h>
  38 #include <ecoli_tk_int.h>
  39 #include <ecoli_test.h>
  40
  41 static size_t parse_llint(struct ec_tk_int *tk, const char *str,
  42         long long *val)
  43 {
  44         char *endptr;
  45
  46         errno = 0;
  47         *val = strtoll(str, &endptr, tk->base);
  48
  49         /* starts with a space */
  50         if (isspace(str[0]))
  51                 return 0;
  52
  53         /* out of range */
  54         if ((errno == ERANGE && (*val == LLONG_MAX || *val == LLONG_MIN)) ||
  55                         (errno != 0 && *val == 0))
  56                 return 0;
  57
  58         if (*val < tk->min || *val > tk->max)
  59                 return 0;
  60
  61         return endptr - str;
  62 }
  63
  64 static struct ec_parsed_tk *ec_tk_int_parse(const struct ec_tk *gen_tk,
  65         const char *str)
  66 {
  67         struct ec_tk_int *tk = (struct ec_tk_int *)gen_tk;
  68         struct ec_parsed_tk *parsed_tk;
  69         long long val;
  70         size_t len;
  71
  72         len = parse_llint(tk, str, &val);
  73         if (len == 0)
  74                 return NULL;
  75
  76         parsed_tk = ec_parsed_tk_new(gen_tk);
  77         if (parsed_tk == NULL)
  78                 return NULL;
  79
  80         parsed_tk->str = ec_strndup(str, len);
  81
  82         return parsed_tk;
  83 }
  84
  85 static struct ec_tk_ops ec_tk_int_ops = {
  86         .parse = ec_tk_int_parse,
  87 };
  88
  89 struct ec_tk *ec_tk_int_new(const char *id, long long int min,
  90         long long int max, unsigned int base)
  91 {
  92         struct ec_tk_int *tk = NULL;
  93
  94         tk = (struct ec_tk_int *)ec_tk_new(id, &ec_tk_int_ops, sizeof(*tk));
  95         if (tk == NULL)
  96                 return NULL;
  97
  98         tk->min = min;
  99         tk->max = max;
 100         tk->base = base;
 101
 102         return &tk->gen;
 103 }
 104
 105 long long ec_tk_int_getval(struct ec_tk *gen_tk, const char *str)
 106 {
 107         struct ec_tk_int *tk = (struct ec_tk_int *)gen_tk;
 108         long long val = 0;
 109
 110         // XXX check type here
 111         // if gen_tk->type != int fail
 112
 113         parse_llint(tk, str, &val);
 114
 115         return val;
 116 }
 117
 118 static int ec_tk_int_testcase(void)
 119 {
 120         struct ec_parsed_tk *p;
 121         struct ec_tk *tk;
 122         const char *s;
 123         int ret = 0;
 124
 125         tk = ec_tk_int_new(NULL, 0, 256, 0);
 126         if (tk == NULL) {
 127                 ec_log(EC_LOG_ERR, "cannot create tk\n");
 128                 return -1;
 129         }
 130         ret |= EC_TEST_CHECK_TK_PARSE(tk, "0", "0");
 131         ret |= EC_TEST_CHECK_TK_PARSE(tk, "256", "256");
 132         ret |= EC_TEST_CHECK_TK_PARSE(tk, "0x100", "0x100");
 133         ret |= EC_TEST_CHECK_TK_PARSE(tk, "-1", NULL);
 134         ret |= EC_TEST_CHECK_TK_PARSE(tk, "0x101", NULL);
 135         ret |= EC_TEST_CHECK_TK_PARSE(tk, " 1", NULL);
 136
 137         p = ec_tk_parse(tk, "0");
 138         s = ec_parsed_tk_to_string(p);
 139         if (s == NULL) {
 140                 TEST_ERR();
 141         } else {
 142                 if (ec_tk_int_getval(tk, s) != 0)
 143                         TEST_ERR();
 144         }
 145         ec_parsed_tk_free(p);
 146
 147         p = ec_tk_parse(tk, "10");
 148         s = ec_parsed_tk_to_string(p);
 149         if (s == NULL) {
 150                 TEST_ERR();
 151         } else {
 152                 if (ec_tk_int_getval(tk, s) != 10)
 153                         TEST_ERR();
 154         }
 155         ec_parsed_tk_free(p);
 156         ec_tk_free(tk);
 157
 158         tk = ec_tk_int_new(NULL, -1, LLONG_MAX, 16);
 159         if (tk == NULL) {
 160                 ec_log(EC_LOG_ERR, "cannot create tk\n");
 161                 return -1;
 162         }
 163         ret |= EC_TEST_CHECK_TK_PARSE(tk, "0", "0");
 164         ret |= EC_TEST_CHECK_TK_PARSE(tk, "-1", "-1");
 165         ret |= EC_TEST_CHECK_TK_PARSE(tk, "7fffffffffffffff",
 166                 "7fffffffffffffff");
 167         ret |= EC_TEST_CHECK_TK_PARSE(tk, "0x7fffffffffffffff",
 168                 "0x7fffffffffffffff");
 169         ret |= EC_TEST_CHECK_TK_PARSE(tk, "-2", NULL);
 170
 171         p = ec_tk_parse(tk, "10");
 172         s = ec_parsed_tk_to_string(p);
 173         if (s == NULL) {
 174                 TEST_ERR();
 175         } else {
 176                 if (ec_tk_int_getval(tk, s) != 16)
 177                         TEST_ERR();
 178         }
 179         ec_parsed_tk_free(p);
 180         ec_tk_free(tk);
 181
 182         tk = ec_tk_int_new(NULL, LLONG_MIN, 0, 10);
 183         if (tk == NULL) {
 184                 ec_log(EC_LOG_ERR, "cannot create tk\n");
 185                 return -1;
 186         }
 187         ret |= EC_TEST_CHECK_TK_PARSE(tk, "0", "0");
 188         ret |= EC_TEST_CHECK_TK_PARSE(tk, "-1", "-1");
 189         ret |= EC_TEST_CHECK_TK_PARSE(tk, "-9223372036854775808",
 190                 "-9223372036854775808");
 191         ret |= EC_TEST_CHECK_TK_PARSE(tk, "0x0", "0");
 192         ret |= EC_TEST_CHECK_TK_PARSE(tk, "1", NULL);
 193         ec_tk_free(tk);
 194
 195         /* test completion */
 196         tk = ec_tk_int_new(NULL, 0, 10, 0);
 197         if (tk == NULL) {
 198                 ec_log(EC_LOG_ERR, "cannot create tk\n");
 199                 return -1;
 200         }
 201         ret |= EC_TEST_CHECK_TK_COMPLETE(tk, "", "");
 202         ret |= EC_TEST_CHECK_TK_COMPLETE(tk, "x", "");
 203         ret |= EC_TEST_CHECK_TK_COMPLETE(tk, "1", "");
 204         ec_tk_free(tk);
 205
 206         return ret;
 207 }
 208
 209 static struct ec_test ec_tk_int_test = {
 210         .name = "tk_int",
 211         .test = ec_tk_int_testcase,
 212 };
 213
 214 EC_REGISTER_TEST(ec_tk_int_test);