sdcc/sim/ucsim/src/core/utils.src/chars.cc

   1 /*
   2  * Simulator of microcontrollers (chars.cc)
   3  *
   4  * Copyright (C) 1997 Drotos Daniel
   5  *
   6  * To contact author send email to dr.dkdb@gmail.com
   7  *
   8  */
   9
  10 /* This file is part of microcontroller simulator: ucsim.
  11
  12 UCSIM is free software; you can redistribute it and/or modify
  13 it under the terms of the GNU General Public License as published by
  14 the Free Software Foundation; either version 2 of the License, or
  15 (at your option) any later version.
  16
  17 UCSIM is distributed in the hope that it will be useful,
  18 but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 GNU General Public License for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with UCSIM; see the file COPYING.  If not, write to the Free
  24 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  25 02111-1307, USA. */
  26 /*@1@*/
  27
  28 #include <ctype.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include <stdarg.h>
  33 #include <ctype.h>
  34
  35 #include "charscl.h"
  36
  37
  38 chars::chars(void)
  39 {
  40   chars_string= 0;
  41   chars_length= 0;
  42   dynamic= false;
  43   pars_pos= 0;
  44 }
  45
  46 chars::chars(char *s)
  47 {
  48   chars_string= 0;
  49   chars_length= 0;
  50   allocate_string(s);
  51 }
  52
  53 chars::chars(const char *s)
  54 {
  55   if ((chars_string= const_cast<char *>(s)) != NULL)
  56     chars_length= strlen(s);
  57   else
  58     chars_length= 0;
  59   dynamic= false;
  60   pars_pos= 0;
  61 }
  62 chars::chars(const chars &cs)
  63 {
  64   chars_string= 0;
  65   chars_length= 0;
  66   allocate_string(cs);
  67 }
  68
  69 chars::chars(const char *, const char *fmt, ...)
  70 {
  71   va_list ap;
  72   char n[1000];
  73
  74   va_start(ap, fmt);
  75   vsnprintf(n, 999, fmt, ap);
  76   va_end(ap);
  77
  78   chars_string= strdup(n);
  79   chars_length= strlen(n);
  80   dynamic= true;
  81   pars_pos= 0;
  82 }
  83
  84 chars::~chars(void)
  85 {
  86   deallocate_string();
  87 }
  88
  89
  90 void
  91 chars::allocate_string(const char *s)
  92 {
  93   char *n= NULL;
  94   int l= 0;
  95   bool d= false;
  96
  97   if (s)
  98     {
  99       l= strlen(s);
 100       n= (char*)malloc(l+1);
 101       strcpy(n, s);
 102       d= true;
 103     }
 104   deallocate_string();
 105   chars_length= l;
 106   chars_string= n;
 107   dynamic= d;
 108   pars_pos= 0;
 109 }
 110
 111 void
 112 chars::deallocate_string(void)
 113 {
 114   if (chars_string)
 115     if (dynamic)
 116       free(chars_string);
 117   chars_string= 0;
 118   chars_length= 0;
 119   dynamic= 0;
 120 }
 121
 122
 123 char
 124 chars::c(int idx)
 125 {
 126   if (!chars_string)
 127     return 0;
 128   if (idx>=chars_length)
 129     return 0;
 130   return chars_string[idx];
 131 }
 132
 133 chars
 134 chars::token(const char *delims) const
 135 {
 136   chars c= (char*)NULL;
 137
 138   if (!delims || !*delims)
 139     return c;
 140   if (pars_pos >= chars_length)
 141     return c;
 142   if (chars_length < 1)
 143     return c;
 144
 145   int l;
 146   // skip initial delims first;
 147   l= strspn(&chars_string[pars_pos], delims);
 148   pars_pos+= l;
 149   if (pars_pos >= chars_length)
 150     return c;
 151   // skip chars not in delims: search token end
 152   l= strcspn(&chars_string[pars_pos], delims);
 153   if (l > 0)
 154     {
 155       // found
 156       int i;
 157       for (i= pars_pos; i < pars_pos+l; i++)
 158         c+= chars_string[i];
 159       pars_pos= i;
 160       // skip delims at end
 161       l= strspn(&chars_string[pars_pos], delims);
 162       pars_pos+= l;
 163       return c;
 164     }
 165   // not found more
 166   return c;
 167 }
 168
 169 unsigned int
 170 chars::htoi(void)
 171 {
 172   unsigned int v= 0;
 173   int i, x;
 174   if (!chars_string)
 175     return 0;
 176   for (i= 0; chars_string[i]; i++)
 177     {
 178       char c= toupper(chars_string[i]);
 179       if ((c>='0') && (c<='9'))
 180         x= c-'0';
 181       else if ((c>='A') && (c<='F'))
 182         x= 10+c-'A';
 183       else
 184         x= 0;
 185       v<<= 4;
 186       v|= x;
 187     }
 188   return v;
 189 }
 190
 191 unsigned long long int
 192 chars::htoll(void)
 193 {
 194   unsigned long long int v= 0;
 195   int i, x;
 196   if (!chars_string)
 197     return 0;
 198   for (i= 0; chars_string[i]; i++)
 199     {
 200       char c= toupper(chars_string[i]);
 201       if ((c>='0') && (c<='9'))
 202         x= c-'0';
 203       else if ((c>='A') && (c<='F'))
 204         x= 10+c-'A';
 205       else
 206         return v;//x= 0;
 207       v<<= 4;
 208       v|= x;
 209     }
 210   return v;
 211 }
 212
 213
 214 void
 215 chars::ltrim(void)
 216 {
 217   char *p= chars_string;
 218   if (empty())
 219     return;
 220   while (*p && isspace(*p))
 221     p++;
 222   allocate_string(p);
 223 }
 224
 225 void
 226 chars::rtrim(void)
 227 {
 228   int i;
 229   if (empty())
 230     return;
 231   i= chars_length-1;
 232   while (i>=0)
 233     {
 234       if (isspace(chars_string[i]))
 235         chars_string[i]= 0;
 236       else
 237         break;
 238       i--;
 239     }
 240 }
 241
 242 void
 243 chars::lrip(const char *cset)
 244 {
 245   int skip;
 246   if (empty())
 247     return;
 248   if (!cset || !*cset)
 249     return;
 250   skip= strspn(chars_string, cset);
 251   if (skip > 0)
 252     allocate_string(chars_string+skip);
 253 }
 254
 255 void
 256 chars::rrip(const char *cset)
 257 {
 258   if (empty())
 259     return;
 260   if (!cset || !*cset)
 261     return;
 262   int i= chars_length-1;
 263   while (i>=0)
 264     {
 265       char c= chars_string[i];
 266       if (strchr(cset, c) != NULL)
 267         chars_string[i]= 0;
 268       else
 269         break;
 270       i--;
 271     }
 272 }
 273
 274 void
 275 chars::rrip(int nuof_chars)
 276 {
 277   if (empty()) return;
 278   if (nuof_chars < 1) return;
 279   int i= chars_length-1;
 280   while ((i>=0) && nuof_chars)
 281     {
 282       chars_string[i]= 0;
 283       i--;
 284       nuof_chars--;
 285     }
 286 }
 287
 288 bool
 289 chars::starts_with(const char *x) const
 290 {
 291   if (empty() ||
 292       !x ||
 293       !*x)
 294     return false;
 295   if (strstr(chars_string, x) == chars_string)
 296     return true;
 297   return false;
 298 }
 299
 300 int
 301 chars::first_pos(char c)
 302 {
 303   if (empty())
 304     return -1;
 305   char *pos= strchr(chars_string, c);
 306   if (pos == NULL)
 307     return -1;
 308   return pos-chars_string;
 309 }
 310
 311 long int
 312 chars::lint(void)
 313 {
 314   return lint(10);
 315 }
 316
 317 long int
 318 chars::lint(int base)
 319 {
 320   if (base < 2) base= 0;
 321   if (base > 36) base= 36;
 322   if (empty()) return 0;
 323   long int l= strtol(chars_string, 0, base);
 324   return l;
 325 }
 326
 327 chars &
 328 chars::append(const char *s)
 329 {
 330   if (!s)
 331     return(*this);
 332
 333   char *temp= (char*)malloc(chars_length + strlen(s) + 1);
 334   if (chars_string)
 335     {
 336       strcpy(temp, chars_string);
 337       if (dynamic)
 338         free(chars_string);
 339     }
 340   else
 341     temp[0]= '\0';
 342   strcat(temp, s);
 343   chars_string= temp;
 344   chars_length+= strlen(s);
 345   dynamic= true;
 346
 347   return *this;
 348 }
 349
 350 chars &
 351 chars::append(char c)
 352 {
 353   if (!c)
 354     return(*this);
 355
 356   char *temp= (char*)malloc(chars_length + 1 + 1);
 357   if (chars_string)
 358     {
 359       strcpy(temp, chars_string);
 360       if (dynamic)
 361         free(chars_string);
 362     }
 363   else
 364     temp[0]= '\0';
 365   char b[2];
 366   b[0]= c;
 367   b[1]= 0;
 368   strcat(temp, b);
 369   chars_string= temp;
 370   chars_length+= 1;
 371   dynamic= true;
 372
 373   return *this;
 374 }
 375
 376 chars &
 377 chars::appendf(const char *format, ...)
 378 {
 379   va_list ap;
 380   char n[1000];
 381
 382   va_start(ap, format);
 383   vsnprintf(n, 999, format, ap);
 384   va_end(ap);
 385
 386   char *temp= (char*)malloc(chars_length + strlen(n) + 1);
 387   if (chars_string)
 388     {
 389       strcpy(temp, chars_string);
 390       if (dynamic)
 391         free(chars_string);
 392     }
 393   else
 394     temp[0]= '\0';
 395   strcat(temp, n);
 396   chars_string= temp;
 397   chars_length+= strlen(n);
 398   dynamic= true;
 399
 400   return *this;
 401 }
 402
 403 chars &
 404 chars::appendn(const char *src, int n)
 405 {
 406   char *temp= (char*)malloc(chars_length + n + 1);
 407   if (chars_string)
 408     {
 409       strcpy(temp, chars_string);
 410       if (dynamic)
 411         free(chars_string);
 412     }
 413   else
 414     temp[0]= 0;
 415   int s= 0;
 416   while (src[s] && (s<n))
 417     temp[chars_length++]= src[s++];
 418   temp[chars_length]= '\0';
 419   chars_string= temp;
 420   dynamic= true;
 421   return *this;
 422 }
 423
 424 chars &
 425 chars::format(const char *format, ...)
 426 {
 427   deallocate_string();
 428
 429   va_list ap;
 430   char n[1000];
 431
 432   va_start(ap, format);
 433   vsnprintf(n, 999, format, ap);
 434   va_end(ap);
 435
 436   char *temp= (char*)malloc(chars_length + strlen(n) + 1);
 437   if (chars_string)
 438     {
 439       strcpy(temp, chars_string);
 440       if (dynamic)
 441         free(chars_string);
 442     }
 443   else
 444     temp[0]= '\0';
 445   strcat(temp, n);
 446   chars_string= temp;
 447   chars_length+= strlen(n);
 448   dynamic= true;
 449
 450   return *this;
 451 }
 452
 453 chars &
 454 chars::uppercase(void)
 455 {
 456   if (!dynamic)
 457     allocate_string(chars_string);
 458
 459   for (int i= 0; i < chars_length; i++)
 460     chars_string[i]= toupper(chars_string[i]);
 461
 462   return *this;
 463 }
 464
 465 chars &
 466 chars::subst(const char *what, char with)
 467 {
 468   if (!dynamic)
 469     allocate_string(chars_string);
 470
 471   for (int i= 0; i < chars_length; i++)
 472     if (strchr(what, chars_string[i]))
 473       chars_string[i] = with;
 474
 475   return *this;
 476 }
 477
 478 chars &
 479 chars::substr(int start, int maxlen)
 480 {
 481   if (!chars_string)
 482     return *this;
 483
 484   char *s= (char*)malloc(maxlen+1);
 485   int i, l;
 486   for (i= start, l= 0; i<chars_length && chars_string[i] && l<maxlen; i++, l++)
 487     s[l]= chars_string[i];
 488   s[l]= 0;
 489   deallocate_string();
 490   chars_string= s;
 491   chars_length= l;
 492   dynamic= true;
 493   return *this;
 494 }
 495
 496
 497 // Assignment operators
 498 chars &
 499 chars::operator=(const char *s)
 500 {
 501   allocate_string(s);
 502   return(*this);
 503 }
 504
 505 chars &
 506 chars::operator=(const chars &cs)
 507 {
 508   if (this != &cs)
 509     allocate_string(cs.chars_string);
 510   return(*this);
 511 }
 512
 513
 514 // Arithmetic operators
 515
 516 chars
 517 chars::operator+(char c) const
 518 {
 519   char b[2];
 520   b[0]= c;
 521   b[1]= 0;
 522   chars temp(chars_string);
 523   return temp.append(b);
 524 }
 525
 526 chars
 527 chars::operator+(const char *s) const
 528 {
 529   chars temp(chars_string);
 530   return(temp.append(s));
 531 }
 532
 533 chars
 534 operator+(char c, const chars &cs)
 535 {
 536   char b[2];
 537   b[0]= c;
 538   b[1]= 0;
 539   chars temp(b);
 540   return(temp.append(cs));
 541 }
 542
 543
 544 // Boolean operators
 545 bool
 546 chars::equal(const char *s) const
 547 {
 548   if ((chars_string &&
 549        !s) ||
 550       (!chars_string &&
 551        s))
 552     return(0);
 553   if (!chars_string &&
 554       !s)
 555     return(1);
 556   return(strcmp(chars_string, s) == 0);
 557 }
 558
 559 bool
 560 chars::operator==(const char *s) const
 561 {
 562   return(equal(s));
 563 }
 564
 565 bool
 566 chars::operator!=(const char *s) const
 567 {
 568   return(!equal(s));
 569 }
 570
 571
 572 /* End of utils.src/chars.cc */