common/misc.cpp

   1
   2 #include <stdio.h>
   3 #include <stdint.h>
   4 #include <string.h>
   5 #include <stdlib.h>
   6 #include <stdarg.h>
   7 #include <math.h>
   8 #include <ctype.h>
   9
  10 #include "basics.h"
  11 #include "misc.fdh"
  12
  13 void stat(const char *fmt, ...);
  14
  15 #if __BYTE_ORDER == __LITTLE_ENDIAN
  16 uint16_t fgeti(FILE *fp)
  17 {
  18 uint16_t value;
  19         fread(&value, 2, 1, fp);
  20         return value;
  21 }
  22
  23 uint32_t fgetl(FILE *fp)
  24 {
  25 uint32_t value;
  26         fread(&value, 4, 1, fp);
  27         return value;
  28 }
  29
  30 void fputi(uint16_t word, FILE *fp)
  31 {
  32         fwrite(&word, 2, 1, fp);
  33 }
  34
  35 void fputl(uint32_t word, FILE *fp)
  36 {
  37         fwrite(&word, 4, 1, fp);
  38 }
  39 #else
  40 uint16_t fgeti(FILE *fp)
  41 {
  42 uint16_t a, b;
  43         a = fgetc(fp);
  44         b = fgetc(fp);
  45         return (b << 8) | a;
  46 }
  47
  48 uint32_t fgetl(FILE *fp)
  49 {
  50 uint32_t a, b, c, d;
  51         a = fgetc(fp);
  52         b = fgetc(fp);
  53         c = fgetc(fp);
  54         d = fgetc(fp);
  55         return (d<<24)|(c<<16)|(b<<8)|(a);
  56 }
  57
  58 void fputi(uint16_t word, FILE *fp)
  59 {
  60         fputc(word, fp);
  61         fputc(word >> 8, fp);
  62 }
  63
  64 void fputl(uint32_t word, FILE *fp)
  65 {
  66         fputc(word, fp);
  67         fputc(word >> 8, fp);
  68         fputc(word >> 16, fp);
  69         fputc(word >> 24, fp);
  70 }
  71 #endif          // __BYTE_ORDER  == __LITTLE_ENDIAN
  72
  73
  74
  75 double fgetfloat(FILE *fp)
  76 {
  77 char buf[16];
  78 double *float_ptr;
  79 int i;
  80
  81         for(i=0;i<4;i++) fgetc(fp);
  82         for(i=0;i<8;i++) buf[i] = fgetc(fp);
  83
  84         float_ptr = (double *)&buf[0];
  85         return *float_ptr;
  86 }
  87
  88 void fputfloat(double q, FILE *fp)
  89 {
  90 char *float_ptr;
  91 int i;
  92
  93         float_ptr = (char *)&q;
  94
  95         for(i=0;i<4;i++) fputc(0, fp);
  96         for(i=0;i<8;i++) fputc(float_ptr[i], fp);
  97
  98         return;
  99 }
 100
 101
 102 // read a string from a file until a null is encountered
 103 void freadstring(FILE *fp, char *buf, int max)
 104 {
 105 int i;
 106
 107         --max;
 108         for(i=0;i<max;i++)
 109         {
 110                 buf[i] = fgetc(fp);
 111                 if (!buf[i])
 112                 {
 113                         return;
 114                 }
 115         }
 116
 117         buf[i] = 0;
 118 }
 119
 120 // write a string to a file and null-terminate it
 121 void fputstring(const char *buf, FILE *fp)
 122 {
 123         if (buf[0]) fprintf(fp, "%s", buf);
 124         fputc(0, fp);
 125 }
 126
 127 // write a string to a file-- does NOT null-terminate it
 128 void fputstringnonull(const char *buf, FILE *fp)
 129 {
 130         if (buf[0])
 131                 fprintf(fp, "%s", buf);
 132 }
 133
 134
 135 // reads strlen(str) bytes from file fp, and returns true if they match "str"
 136 bool fverifystring(FILE *fp, const char *str)
 137 {
 138 int i;
 139 char result = 1;
 140 int stringlength = strlen(str);
 141
 142         for(i=0;i<stringlength;i++)
 143         {
 144                 if (fgetc(fp) != str[i]) result = 0;
 145         }
 146
 147         return result;
 148 }
 149
 150 // read data from a file until ',' or CR
 151 void fgetcsv(FILE *fp, char *str, int maxlen)
 152 {
 153 int i, j;
 154 char ch;
 155
 156         maxlen--;
 157         for(i=j=0;i<maxlen;i++)
 158         {
 159                 ch = fgetc(fp);
 160
 161                 if (ch==13 || ch==',' || ch=='}' || ch==-1)
 162                 {
 163                         break;
 164                 }
 165
 166                 if (ch != 10)
 167                 {
 168                         str[j++] = ch;
 169                 }
 170         }
 171
 172         str[j] = 0;
 173 }
 174
 175 // read a number from a CSV'd list in a file
 176 int fgeticsv(FILE *fp)
 177 {
 178 char buffer[80];
 179         fgetcsv(fp, buffer, sizeof(buffer));
 180         return atoi(buffer);
 181 }
 182
 183 double fgetfcsv(FILE *fp)
 184 {
 185 char buffer[80];
 186         fgetcsv(fp, buffer, sizeof(buffer));
 187         return atof(buffer);
 188 }
 189
 190
 191 // read data from a file until CR
 192 void fgetline(FILE *fp, char *str, int maxlen)
 193 {
 194 int k;
 195         str[0] = 0;
 196         fgets(str, maxlen - 1, fp);
 197
 198         // trim the CRLF that fgets appends
 199         for(k=strlen(str)-1;k>=0;k--)
 200         {
 201                 if (str[k] != 13 && str[k] != 10) break;
 202                 str[k] = 0;
 203         }
 204 }
 205
 206 int filesize(FILE *fp)
 207 {
 208 int cp, sz;
 209
 210         cp = ftell(fp);
 211         fseek(fp, 0, SEEK_END);
 212         sz = ftell(fp);
 213         fseek(fp, cp, SEEK_SET);
 214
 215         return sz;
 216 }
 217
 218 bool file_exists(const char *fname)
 219 {
 220 FILE *fp;
 221
 222         fp = fileopen(fname, "rb");
 223         if (!fp) return 0;
 224         fclose(fp);
 225         return 1;
 226 }
 227
 228 char *stprintf(const char *fmt, ...)
 229 {
 230 va_list ar;
 231 char *str = GetStaticStr();
 232
 233         va_start(ar, fmt);
 234         vsnprintf(str, 255, fmt, ar);
 235         va_end(ar);
 236
 237         return str;
 238 }
 239
 240 /*
 241 void c------------------------------() {}
 242 */
 243
 244 static uint32_t seed = 0;
 245
 246 // return a random number between min and max inclusive
 247 int random(int min, int max)
 248 {
 249 int range, val;
 250
 251         if (max < min)
 252         {
 253                 staterr("random(): warning: max < min [%d, %d]", min, max);
 254                 min ^= max;
 255                 max ^= min;
 256                 min ^= max;
 257         }
 258
 259         range = (max - min);
 260
 261         if (range >= RAND_MAX)
 262         {
 263                 staterr("random(): range > RAND_MAX", min, max);
 264                 return 0;
 265         }
 266
 267         val = getrand() % (range + 1);
 268         return val + min;
 269 }
 270
 271 uint32_t getrand()
 272 {
 273         seed = (seed * 0x343FD) + 0x269EC3;
 274         return seed;
 275 }
 276
 277 void seedrand(uint32_t newseed)
 278 {
 279         seed = newseed;
 280 }
 281
 282 /*
 283 void c------------------------------() {}
 284 */
 285
 286
 287 bool strbegin(const char *bigstr, const char *smallstr)
 288 {
 289 int i;
 290
 291         for(i=0;smallstr[i];i++)
 292                 if (bigstr[i] != smallstr[i]) return false;
 293
 294         return true;
 295 }
 296
 297 bool strcasebegin(const char *bigstr, const char *smallstr)
 298 {
 299 int i;
 300
 301         for(i=0;smallstr[i];i++)
 302                 if (toupper(bigstr[i]) != toupper(smallstr[i])) return false;
 303
 304         return true;
 305 }
 306
 307
 308 // returns how many strings are in a null-terminated array of C strings
 309 int count_string_list(const char *list[])
 310 {
 311 int i;
 312         for(i=0;list[i];i++) ;
 313         return i;
 314 }
 315
 316
 317 char *GetStaticStr(void)
 318 {
 319 static int counter = 0;
 320 static struct
 321 {
 322         char str[1024];
 323 } bufs[24];
 324
 325         if (++counter >= 24) counter = 0;
 326         return bufs[counter].str;
 327 }
 328
 329 // a strncpy that works as you might expect
 330 void maxcpy(char *dst, const char *src, int maxlen)
 331 {
 332 int len = strlen(src);
 333
 334         if (len >= maxlen)
 335         {
 336                 if (maxlen >= 2) memcpy(dst, src, maxlen - 2);
 337                 if (maxlen >= 1) dst[maxlen - 1] = 0;
 338         }
 339         else
 340         {
 341                 memcpy(dst, src, len + 1);
 342         }
 343 }
 344
 345 /*
 346 void c------------------------------() {}
 347 */
 348
 349 static int boolbyte, boolmask_r, boolmask_w;
 350
 351 // prepare for a boolean read operation
 352 void fresetboolean(void)
 353 {
 354         boolmask_r = 256;
 355         boolmask_w = 1;
 356         boolbyte = 0;
 357 }
 358
 359 // read a boolean value (a single bit) from a file
 360 char fbooleanread(FILE *fp)
 361 {
 362 char value;
 363
 364         if (boolmask_r == 256)
 365         {
 366                 boolbyte = fgetc(fp);
 367                 boolmask_r = 1;
 368         }
 369
 370         value = (boolbyte & boolmask_r) ? 1:0;
 371         boolmask_r <<= 1;
 372         return value;
 373 }
 374
 375 void fbooleanwrite(char bit, FILE *fp)
 376 {
 377         if (boolmask_w == 256)
 378         {
 379                 fputc(boolbyte, fp);
 380                 boolmask_w = 1;
 381                 boolbyte = 0;
 382         }
 383
 384         if (bit)
 385         {
 386                 boolbyte |= boolmask_w;
 387         }
 388
 389         boolmask_w <<= 1;
 390 }
 391
 392 void fbooleanflush(FILE *fp)
 393 {
 394         fputc(boolbyte, fp);
 395         boolmask_w = 1;
 396 }
 397
 398
 399