libtu/numparser2.h

   1 /*
   2  * libtu/numparser2.h
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2002.
   5  *
   6  * You may distribute and modify this library under the terms of either
   7  * the Clarified Artistic License or the GNU LGPL, version 2.1 or later.
   8  */
   9
  10 #define MAX_MANTISSA 10  /* should be enough for our needs */
  11 #define ULONG_SIZE (sizeof(ulong)*8)
  12
  13 enum{
  14         NPNUM_INT,
  15         NPNUM_FLOAT
  16 };
  17
  18 #ifdef NP_SIMPLE_IMPL
  19
  20 typedef struct _NPNum{
  21         int type;
  22         int base;
  23         bool negative;
  24         double fval;
  25         ulong ival;
  26 } NPNum;
  27
  28 #define NUM_INIT {0, 0, 0, 0.0, 0}
  29
  30 static int npnum_mulbase_add(NPNum *num, long base, long v)
  31 {
  32         double iold=num->ival;
  33
  34         num->fval=num->fval*base+(double)v;
  35
  36         num->ival*=base;
  37
  38         if(num->ival<iold)
  39                 num->type=NPNUM_FLOAT;
  40
  41         num->ival+=v;
  42
  43         return 0;
  44 }
  45
  46 #else /* NP_SIMPLE_IMPL */
  47
  48 typedef struct _NPNum{
  49         unsigned char nmantissa;
  50         int type;
  51         int base;
  52         bool negative;
  53         ulong mantissa[MAX_MANTISSA];
  54         long exponent;
  55 } NPNum;
  56
  57 #define NUM_INIT {0, 0, 0, 0, {0,}, 0}
  58
  59 #define ADD_EXP(NUM, X) (NUM)->exponent+=(X);
  60
  61 #if defined(__GNUG__) && defined(i386) && !defined(NP_NO_I386_ASM)
  62  #define NP_I386_ASM
  63 #endif
  64
  65 static int npnum_mulbase_add(NPNum *num, long base, long v)
  66 {
  67         long i, j;
  68         ulong overflow;
  69 #ifndef NP_I386_ASM
  70         ulong val;
  71 #endif
  72
  73         for(i=num->nmantissa;i>=0;i--){
  74 #ifdef NP_I386_ASM
  75                 __asm__("mul %4\n"
  76                                 : "=a" (num->mantissa[i]), "=d" (overflow)
  77                                 : "0" (num->mantissa[i]), "1" (0), "q" (base)
  78                                 : "eax", "edx");
  79 #else
  80                 overflow=0;
  81                 val=num->mantissa[i];
  82
  83                 if(val<ULONG_MAX/base){
  84                         val*=base;
  85                 }else if(val){
  86                         ulong tmp=val;
  87                         ulong old=val;
  88                         for(j=0; j<base; j++){
  89                                 val+=tmp;
  90                                 if(val<=old)
  91                                         overflow++;
  92                                 old=val;
  93                         }
  94                 }
  95                 num->mantissa[i]=val;
  96 #endif
  97                 if(overflow){
  98                         if(i==num->nmantissa){
  99                                 if(num->nmantissa==MAX_MANTISSA)
 100                                         return E_TOKZ_TOOBIG;
 101                                 num->nmantissa++;
 102                         }
 103                         num->mantissa[i+1]+=overflow;
 104                 }
 105         }
 106         num->mantissa[0]+=v;
 107
 108         return 0;
 109 }
 110
 111 #undef NP_I386_ASM
 112
 113 #endif /* NP_SIMPLE_IMPL */
 114
 115
 116 /* */
 117
 118
 119 static bool is_end(int c)
 120 {
 121         /* oops... EOF was missing */
 122         return (c==EOF || (c!='.' && ispunct(c)) || isspace(c) || iscntrl(c));
 123 }
 124
 125
 126 /* */
 127
 128
 129 static int parse_exponent(NPNum *num, Tokenizer *tokz, int c)
 130 {
 131         long exp=0;
 132         bool neg=FALSE;
 133         int err=0;
 134
 135         c=GETCH();
 136
 137         if(c=='-' || c=='+'){
 138                 if(c=='-')
 139                         neg=TRUE;
 140                 c=GETCH();
 141         }
 142
 143         for(; 1; c=GETCH()){
 144                 if(isdigit(c)){
 145                         exp*=10;
 146                         exp+=c-'0';
 147                 }else if(is_end(c)){
 148                         UNGETCH(c);
 149                         break;
 150                 }else{
 151                         err=E_TOKZ_NUMFMT;
 152                 }
 153         }
 154
 155         if(neg)
 156                 exp*=-1;
 157
 158 #ifndef NP_SIMPLE_IMPL
 159         ADD_EXP(num, exp);
 160 #else
 161         num->fval*=pow(num->base, exp);
 162 #endif
 163         return err;
 164 }
 165
 166
 167 static int parse_number(NPNum *num, Tokenizer *tokz, int c)
 168 {
 169         int base=10;
 170         int dm=1;
 171         int err=0;
 172         int tmp;
 173 #ifdef NP_SIMPLE_IMPL
 174         double divisor=base;
 175 #endif
 176
 177         if(c=='-' || c=='+'){
 178                 if(c=='-')
 179                         num->negative=TRUE;
 180                 c=GETCH();
 181                 if(!isdigit(c))
 182                         err=E_TOKZ_NUMFMT;
 183         }
 184
 185         if(c=='0'){
 186                 dm=0;
 187                 c=GETCH();
 188                 if(c=='x' || c=='X'){
 189                         base=16;
 190                         c=GETCH();
 191                 }else if(c=='b' || c=='B'){
 192                         base=2;
 193                         c=GETCH();
 194                 }else if('0'<=c && c<='7'){
 195                         base=8;
 196                 }else{
 197                         dm=2;
 198                 }
 199         }
 200
 201         num->base=base;
 202
 203         for(; 1; c=GETCH()){
 204                 if((c=='e' || c=='E') && dm!=0){
 205                         if(dm<2){
 206                                 err=E_TOKZ_NUMFMT;
 207                                 continue;
 208                         }
 209                         tmp=parse_exponent(num, tokz, c);
 210                         if(err==0)
 211                                 err=tmp;
 212                         break;
 213                 }
 214
 215                 if(isxdigit(c)){
 216                         if('0'<=c && c<='9')
 217                                 c-='0';
 218                         else if(isupper(c))
 219                                 c-='A'-10;
 220                         else
 221                                 c-='a'-10;
 222
 223                         if(c>=base)
 224                                 err=E_TOKZ_NUMFMT;
 225
 226 #ifdef NP_SIMPLE_IMPL
 227                         if(dm==3){
 228                                 num->fval+=(double)c/divisor;
 229                                 divisor*=base;
 230                         }else
 231 #endif
 232                         {
 233                                 tmp=npnum_mulbase_add(num, base, c);
 234                                 if(err==0)
 235                                         err=tmp;
 236                         }
 237
 238                         if(dm==1)
 239                                 dm=2;
 240 #ifndef NP_SIMPLE_IMPL
 241                         else if(dm==3)
 242                                 ADD_EXP(num, -1);
 243 #endif
 244                         continue;
 245                 }
 246
 247                 if(c=='.'){
 248                         if(dm!=2){
 249                                 err=E_TOKZ_NUMFMT;
 250                         }
 251                         dm=3;
 252 #ifdef NP_SIMPLE_IMPL
 253                         num->type=NPNUM_FLOAT;
 254                         divisor=base;
 255 #endif
 256                         continue;
 257                 }
 258
 259                 if(is_end(c)){
 260                         UNGETCH(c);
 261                         break;
 262                 }
 263
 264                 err=E_TOKZ_NUMFMT;
 265         }
 266
 267 #ifndef NP_SIMPLE_IMPL
 268         num->type=(num->exponent==0 ? NPNUM_INT : NPNUM_FLOAT);
 269 #endif
 270
 271         return err;
 272 }