The Ecere SDK - sdk/blob - compiler/bootstrap/ecere/bootstrap/String.c

   1 #if defined(__GNUC__)
   2 typedef long long int64;
   3 typedef unsigned long long uint64;
   4 #elif defined(__TINYC__)
   5 #include <stdarg.h>
   6 #define __builtin_va_list va_list
   7 #define __builtin_va_start va_start
   8 #define __builtin_va_end va_end
   9 #ifdef _WIN32
  10 #define strcasecmp stricmp
  11 #define strncasecmp strnicmp
  12 #define __declspec(x) __attribute__((x))
  13 #endif
  14 typedef long long int64;
  15 typedef unsigned long long uint64;
  16 #else
  17 typedef __int64 int64;
  18 typedef unsigned __int64 uint64;
  19 #endif
  20 #ifdef __BIG_ENDIAN__
  21 #define __ENDIAN_PAD(x) (8 - (x))
  22 #else
  23 #define __ENDIAN_PAD(x) 0
  24 #endif
  25 #include <stdint.h>
  26 extern void *  __ecereNameSpace__ecere__com__eSystem_New(unsigned int size);
  27
  28 extern void *  __ecereNameSpace__ecere__com__eSystem_New0(unsigned int size);
  29
  30 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew(void *  memory, unsigned int size);
  31
  32 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew0(void *  memory, unsigned int size);
  33
  34 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BTNode;
  35
  36 struct __ecereNameSpace__ecere__sys__BTNode;
  37
  38 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BinaryTree;
  39
  40 struct __ecereNameSpace__ecere__sys__BinaryTree
  41 {
  42 struct __ecereNameSpace__ecere__sys__BTNode * root;
  43 int count;
  44 int (*  CompareKey)(struct __ecereNameSpace__ecere__sys__BinaryTree * tree, uintptr_t a, uintptr_t b);
  45 void (*  FreeKey)(void *  key);
  46 } __attribute__ ((gcc_struct));
  47
  48 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__OldList;
  49
  50 struct __ecereNameSpace__ecere__sys__OldList
  51 {
  52 void *  first;
  53 void *  last;
  54 int count;
  55 unsigned int offset;
  56 unsigned int circ;
  57 } __attribute__ ((gcc_struct));
  58
  59 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Class;
  60
  61 struct __ecereNameSpace__ecere__com__Class
  62 {
  63 struct __ecereNameSpace__ecere__com__Class * prev;
  64 struct __ecereNameSpace__ecere__com__Class * next;
  65 char *  name;
  66 int offset;
  67 int structSize;
  68 int (* *  _vTbl)();
  69 int vTblSize;
  70 int (*  Constructor)(struct __ecereNameSpace__ecere__com__Instance *);
  71 void (*  Destructor)(struct __ecereNameSpace__ecere__com__Instance *);
  72 int offsetClass;
  73 int sizeClass;
  74 struct __ecereNameSpace__ecere__com__Class * base;
  75 struct __ecereNameSpace__ecere__sys__BinaryTree methods;
  76 struct __ecereNameSpace__ecere__sys__BinaryTree members;
  77 struct __ecereNameSpace__ecere__sys__BinaryTree prop;
  78 struct __ecereNameSpace__ecere__sys__OldList membersAndProperties;
  79 struct __ecereNameSpace__ecere__sys__BinaryTree classProperties;
  80 struct __ecereNameSpace__ecere__sys__OldList derivatives;
  81 int memberID;
  82 int startMemberID;
  83 int type;
  84 struct __ecereNameSpace__ecere__com__Instance * module;
  85 struct __ecereNameSpace__ecere__com__NameSpace *  nameSpace;
  86 char *  dataTypeString;
  87 struct __ecereNameSpace__ecere__com__Instance * dataType;
  88 int typeSize;
  89 int defaultAlignment;
  90 void (*  Initialize)();
  91 int memberOffset;
  92 struct __ecereNameSpace__ecere__sys__OldList selfWatchers;
  93 char *  designerClass;
  94 unsigned int noExpansion;
  95 char *  defaultProperty;
  96 unsigned int comRedefinition;
  97 int count;
  98 unsigned int isRemote;
  99 unsigned int internalDecl;
 100 void *  data;
 101 unsigned int computeSize;
 102 int structAlignment;
 103 int destructionWatchOffset;
 104 unsigned int fixed;
 105 struct __ecereNameSpace__ecere__sys__OldList delayedCPValues;
 106 int inheritanceAccess;
 107 char *  fullName;
 108 void *  symbol;
 109 struct __ecereNameSpace__ecere__sys__OldList conversions;
 110 struct __ecereNameSpace__ecere__sys__OldList templateParams;
 111 struct __ecereNameSpace__ecere__com__ClassTemplateArgument *  templateArgs;
 112 struct __ecereNameSpace__ecere__com__Class * templateClass;
 113 struct __ecereNameSpace__ecere__sys__OldList templatized;
 114 int numParams;
 115 } __attribute__ ((gcc_struct));
 116
 117 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 118
 119 struct __ecereNameSpace__ecere__com__Instance
 120 {
 121 int (* *  _vTbl)();
 122 struct __ecereNameSpace__ecere__com__Class * _class;
 123 int _refCount;
 124 } __attribute__ ((gcc_struct));
 125
 126 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Property;
 127
 128 struct __ecereNameSpace__ecere__com__Property
 129 {
 130 struct __ecereNameSpace__ecere__com__Property * prev;
 131 struct __ecereNameSpace__ecere__com__Property * next;
 132 char *  name;
 133 unsigned int isProperty;
 134 int memberAccess;
 135 int id;
 136 struct __ecereNameSpace__ecere__com__Class * _class;
 137 char *  dataTypeString;
 138 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 139 struct __ecereNameSpace__ecere__com__Instance * dataType;
 140 void (*  Set)();
 141 int (*  Get)();
 142 unsigned int (*  IsSet)();
 143 void *  data;
 144 void *  symbol;
 145 int vid;
 146 unsigned int conversion;
 147 unsigned int watcherOffset;
 148 char *  category;
 149 unsigned int compiled;
 150 unsigned int selfWatchable;
 151 unsigned int isWatchable;
 152 } __attribute__ ((gcc_struct));
 153
 154 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataMember;
 155
 156 struct __ecereNameSpace__ecere__com__DataMember
 157 {
 158 struct __ecereNameSpace__ecere__com__DataMember * prev;
 159 struct __ecereNameSpace__ecere__com__DataMember * next;
 160 char *  name;
 161 unsigned int isProperty;
 162 int memberAccess;
 163 int id;
 164 struct __ecereNameSpace__ecere__com__Class * _class;
 165 char *  dataTypeString;
 166 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 167 struct __ecereNameSpace__ecere__com__Instance * dataType;
 168 int type;
 169 int offset;
 170 int memberID;
 171 struct __ecereNameSpace__ecere__sys__OldList members;
 172 struct __ecereNameSpace__ecere__sys__BinaryTree membersAlpha;
 173 int memberOffset;
 174 int structAlignment;
 175 } __attribute__ ((gcc_struct));
 176
 177 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Method;
 178
 179 struct __ecereNameSpace__ecere__com__Method
 180 {
 181 char *  name;
 182 struct __ecereNameSpace__ecere__com__Method * parent;
 183 struct __ecereNameSpace__ecere__com__Method * left;
 184 struct __ecereNameSpace__ecere__com__Method * right;
 185 int depth;
 186 int (*  function)();
 187 int vid;
 188 int type;
 189 struct __ecereNameSpace__ecere__com__Class * _class;
 190 void *  symbol;
 191 char *  dataTypeString;
 192 struct __ecereNameSpace__ecere__com__Instance * dataType;
 193 int memberAccess;
 194 } __attribute__ ((gcc_struct));
 195
 196 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__SerialBuffer;
 197
 198 struct __ecereNameSpace__ecere__com__SerialBuffer
 199 {
 200 unsigned char *  _buffer;
 201 unsigned int count;
 202 unsigned int _size;
 203 unsigned int pos;
 204 } __attribute__ ((gcc_struct));
 205
 206 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DataValue;
 207
 208 struct __ecereNameSpace__ecere__com__DataValue
 209 {
 210 union
 211 {
 212 char c;
 213 unsigned char uc;
 214 short s;
 215 unsigned short us;
 216 int i;
 217 unsigned int ui;
 218 void *  p;
 219 float f;
 220 double d;
 221 long long i64;
 222 uint64 ui64;
 223 } __attribute__ ((gcc_struct));
 224 } __attribute__ ((gcc_struct));
 225
 226 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__ClassTemplateArgument;
 227
 228 struct __ecereNameSpace__ecere__com__ClassTemplateArgument
 229 {
 230 union
 231 {
 232 struct
 233 {
 234 char *  dataTypeString;
 235 struct __ecereNameSpace__ecere__com__Class * dataTypeClass;
 236 } __attribute__ ((gcc_struct));
 237 struct __ecereNameSpace__ecere__com__DataValue expression;
 238 struct
 239 {
 240 char *  memberString;
 241 union
 242 {
 243 struct __ecereNameSpace__ecere__com__DataMember * member;
 244 struct __ecereNameSpace__ecere__com__Property * prop;
 245 struct __ecereNameSpace__ecere__com__Method * method;
 246 } __attribute__ ((gcc_struct));
 247 } __attribute__ ((gcc_struct));
 248 } __attribute__ ((gcc_struct));
 249 } __attribute__ ((gcc_struct));
 250
 251 typedef unsigned int size_t;
 252
 253 void exit(int status);
 254
 255 void * calloc(size_t nmemb, size_t size);
 256
 257 void free(void * ptr);
 258
 259 void * malloc(size_t size);
 260
 261 void * realloc(void * ptr, size_t size);
 262
 263 long int strtol(const char * nptr, char ** endptr, int base);
 264
 265 long long int strtoll(const char * nptr, char ** endptr, int base);
 266
 267 unsigned long long int strtoull(const char * nptr, char ** endptr, int base);
 268
 269 extern int runtimePlatform;
 270
 271
 272
 273
 274
 275
 276
 277
 278 extern int strlen(const char * );
 279
 280 extern char *  strcpy(char * , const char * );
 281
 282 char * __ecereNameSpace__ecere__sys__GetExtension(char * string, char * output)
 283 {
 284 int __simpleStruct0;
 285 int c;
 286 int len = strlen(string);
 287 int limit = (__simpleStruct0 = len - (17), (0 > __simpleStruct0) ? 0 : __simpleStruct0);
 288
 289 output[0] = '\0';
 290 for(c = len; c >= limit; c--)
 291 {
 292 char ch = string[c];
 293
 294 if(ch == '.')
 295 {
 296 strcpy(output, string + c + 1);
 297 break;
 298 }
 299 else if(ch == '/' || ch == '\\')
 300 break;
 301 }
 302 return output;
 303 }
 304
 305 extern int strcmp(const char * , const char * );
 306
 307 extern void *  memmove(void * , const void * , unsigned int size);
 308
 309 extern int __ecereNameSpace__ecere__com__GetRuntimePlatform(void);
 310
 311 char * __ecereNameSpace__ecere__sys__StripLastDirectory(char * string, char * output)
 312 {
 313 int c;
 314
 315 if(runtimePlatform == 1 && !strcmp(string, "\\\\"))
 316 {
 317 strcpy(output, "/");
 318 return output;
 319 }
 320 else
 321 {
 322 int len = strlen(string);
 323
 324 for(c = len - 2; c >= 0; c--)
 325 if(string[c] == '/' || string[c] == '\\')
 326 break;
 327 else if(string[c] == '>' || (string[c] == ':' && c == 0))
 328 {
 329 c++;
 330 break;
 331 }
 332 if((runtimePlatform == 1) ? (c >= 0) : (c > 0))
 333 {
 334 memmove(output, string, c);
 335 if(c > 0)
 336 {
 337 if(runtimePlatform == 1 && c == 1 && output[0] == '\\' && output[1] == '\\')
 338 output[2] = '\0';
 339 else
 340 output[c] = '\0';
 341 }
 342 else
 343 strcpy(output, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "\\" : "/"));
 344 return output;
 345 }
 346 else
 347 {
 348 if(c == 0)
 349 {
 350 strcpy(output, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "\\" : "/"));
 351 return output;
 352 }
 353 else
 354 {
 355 strcpy(output, "");
 356 return (((void *)0));
 357 }
 358 }
 359 }
 360 }
 361
 362 char * __ecereNameSpace__ecere__sys__SplitDirectory(const char * string, char * part, char * rest)
 363 {
 364 int len = 0;
 365 char ch;
 366 int c = 0;
 367
 368 for(; (ch = string[c]) && (ch == '/' || ch == '\\'); c++)
 369 ;
 370 if(c)
 371 part[len++] = ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? '\\' : '/');
 372 else
 373 {
 374 for(; (ch = string[c]) && (ch != '/' && ch != '\\'); c++)
 375 {
 376 if(len < (274))
 377 part[len++] = ch;
 378 }
 379 }
 380 for(; (ch = string[c]) && (ch == '/' || ch == '\\'); c++)
 381 ;
 382 memmove(rest, string + c, strlen(string + c) + 1);
 383 for(c = strlen(rest); c >= 0; c--)
 384 if(ch != '/' && ch != '\\')
 385 break;
 386 if(c > 0)
 387 rest[c] = '\0';
 388 part[len] = '\0';
 389 return rest;
 390 }
 391
 392 char * __ecereNameSpace__ecere__sys__GetLastDirectory(char * string, char * output)
 393 {
 394 int c;
 395 int len = string ? strlen(string) : 0;
 396
 397 for(c = len - 2; c >= 0; c--)
 398 if(string[c] == '/' || string[c] == '\\' || string[c] == ':' || string[c] == '>')
 399 break;
 400 c++;
 401 if(c >= 0)
 402 memmove(output, string + c, strlen(string + c) + 1);
 403 else
 404 output[0] = '\0';
 405 len = strlen(output);
 406 if(len > 1 && (output[len - 1] == '\\' || output[len - 1] == '/'))
 407 output[len - 1] = '\0';
 408 return output;
 409 }
 410
 411 extern char *  strncpy(char * , const char * , int n);
 412
 413 unsigned int __ecereNameSpace__ecere__sys__SplitArchivePath(char * fileName, char * archiveName, char ** archiveFile)
 414 {
 415 if(fileName[0] == '<')
 416 {
 417 int c = strlen(fileName);
 418
 419 for(; c > 0 && fileName[c] != '>'; c--)
 420 ;
 421 if(c > 0)
 422 {
 423 strncpy(archiveName, fileName + 1, c - 1);
 424 archiveName[c - 1] = '\0';
 425 *archiveFile = fileName + c + 1;
 426 return 0x1;
 427 }
 428 }
 429 else if(fileName[0] == ':')
 430 {
 431 strcpy(archiveName, ":");
 432 *archiveFile = fileName + 1;
 433 return 0x1;
 434 }
 435 return 0x0;
 436 }
 437
 438 extern char *  strstr(char * , const char * );
 439
 440 extern int toupper(int);
 441
 442 extern char *  strcat(char * , const char * );
 443
 444 extern int sprintf(char * , char * , ...);
 445
 446 char * __ecereNameSpace__ecere__sys__PathCatSlash(char * string, char * addedPath)
 447 {
 448 unsigned int modified = 0x0;
 449
 450 if(addedPath)
 451 {
 452 char fileName[797] = "", archiveName[797] = "", * file;
 453 int c = 0;
 454 unsigned int isURL = 0x0;
 455 char * urlFileName;
 456
 457 if(__ecereNameSpace__ecere__sys__SplitArchivePath(string, archiveName, &file))
 458 strcpy(fileName, file);
 459 else
 460 {
 461 strcpy(fileName, string);
 462 }
 463 if(strstr(string, "http://") == string)
 464 {
 465 char * slash = strstr(fileName + 7, "/");
 466
 467 isURL = 0x1;
 468 if(slash)
 469 urlFileName = slash;
 470 else
 471 urlFileName = fileName + strlen(fileName);
 472 }
 473 if(strstr(addedPath, "http://") == addedPath)
 474 {
 475 strcpy(fileName, "http://");
 476 isURL = 0x1;
 477 c = 7;
 478 }
 479 else if(__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1)
 480 {
 481 if(addedPath[0] && addedPath[1] == ':' && addedPath[0] != '<')
 482 {
 483 fileName[0] = (char)toupper(addedPath[0]);
 484 fileName[1] = ':';
 485 fileName[2] = '\0';
 486 c = 2;
 487 modified = 0x1;
 488 }
 489 else if(addedPath[0] == '\\' && addedPath[1] == '\\')
 490 {
 491 fileName[0] = fileName[1] = '\\';
 492 fileName[2] = '\0';
 493 c = 2;
 494 modified = 0x1;
 495 }
 496 }
 497 if(!modified && isURL && (addedPath[0] == '\\' || addedPath[0] == '/'))
 498 {
 499 urlFileName[0] = '/';
 500 urlFileName[1] = '\0';
 501 }
 502 else if(!modified && (addedPath[0] == '\\' || addedPath[0] == '/'))
 503 {
 504 if(__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1)
 505 {
 506 if(addedPath[0] == '/' && !addedPath[1])
 507 {
 508 fileName[0] = addedPath[0];
 509 fileName[1] = '\0';
 510 modified = 0x1;
 511 }
 512 else if(fileName[0] && fileName[1] == ':')
 513 {
 514 fileName[2] = '\0';
 515 modified = 0x1;
 516 }
 517 else
 518 {
 519 fileName[0] = '\\';
 520 fileName[1] = '\0';
 521 modified = 0x1;
 522 }
 523 }
 524 else
 525 {
 526 fileName[0] = '/';
 527 fileName[1] = '\0';
 528 modified = 0x1;
 529 }
 530 c = 1;
 531 }
 532 for(; addedPath[c]; )
 533 {
 534 char directory[4384LL];
 535 int len = 0;
 536 char ch;
 537 int count;
 538
 539 for(; (ch = addedPath[c]) && (ch == '/' || ch == '\\'); c++)
 540 ;
 541 for(; (ch = addedPath[c]) && (ch != '/' && ch != '\\'); c++)
 542 {
 543 if(isURL && ch == '?')
 544 {
 545 break;
 546 }
 547 if(len < (274))
 548 directory[len++] = ch;
 549 }
 550 directory[len] = '\0';
 551 for(count = len - 1; count >= 0 && (directory[count] == ' ' || directory[count] == '\t'); count--)
 552 {
 553 directory[count] = '\0';
 554 len--;
 555 }
 556 if(len > 0)
 557 {
 558 modified = 0x1;
 559 if(strstr(directory, "..") == directory && (!directory[2] || directory[2] == ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? '\\' : '/') || directory[2] == '/'))
 560 {
 561 int strLen = strlen(fileName) - 1;
 562
 563 if(strLen > -1)
 564 {
 565 for(; (ch = fileName[strLen]) && strLen > -1 && (ch == '/' || ch == '\\'); strLen--)
 566 ;
 567 for(; (ch = fileName[strLen]) && strLen > -1 && (ch != '/' && ch != '\\' && ch != ':'); strLen--)
 568 ;
 569 for(; (ch = fileName[strLen]) && strLen > -1 && (ch == '/' || ch == '\\'); strLen--)
 570 ;
 571 if(isURL)
 572 {
 573 int __simpleStruct0;
 574
 575 strLen = (__simpleStruct0 = urlFileName - fileName, (strLen > __simpleStruct0) ? strLen : __simpleStruct0);
 576 }
 577 if(!strcmp(fileName + strLen + 1, ".."))
 578 {
 579 strcat(fileName, "/");
 580 strcat(fileName, "..");
 581 }
 582 else
 583 {
 584 if(__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1)
 585 {
 586 if(!strLen && fileName[0] == '\\' && fileName[1] == '\\')
 587 {
 588 if(!fileName[2])
 589 return (((void *)0));
 590 else
 591 {
 592 fileName[0] = '\\';
 593 fileName[1] = '\\';
 594 fileName[2] = '\0';
 595 }
 596 }
 597 else
 598 fileName[strLen + 1] = '\0';
 599 }
 600 else
 601 {
 602 fileName[strLen + 1] = '\0';
 603 if(strLen < 0)
 604 {
 605 fileName[0] = '/';
 606 fileName[1] = '\0';
 607 strLen = 2;
 608 }
 609 }
 610 }
 611 }
 612 else
 613 {
 614 strcpy(fileName, "..");
 615 }
 616 }
 617 else if(strcmp(directory, "."))
 618 {
 619 int strLen = strlen(fileName);
 620 unsigned int notZeroLen = strLen > 0;
 621
 622 if(strLen > 0 && (fileName[strLen - 1] == '/' || fileName[strLen - 1] == '\\'))
 623 strLen--;
 624 if(notZeroLen)
 625 fileName[strLen++] = '/';
 626 fileName[strLen] = '\0';
 627 if(strLen + strlen(directory) > (797) - 3)
 628 return (((void *)0));
 629 strcat(fileName, directory);
 630 }
 631 }
 632 if(isURL && ch == '/')
 633 strcat(fileName, "/");
 634 if(isURL && ch == '?')
 635 {
 636 strcat(fileName, addedPath + c);
 637 break;
 638 }
 639 }
 640 if(archiveName[0])
 641 sprintf(string, "<%s>%s", archiveName, fileName);
 642 else
 643 strcpy(string, fileName);
 644 }
 645 return modified ? string : (((void *)0));
 646 }
 647
 648 char * __ecereNameSpace__ecere__sys__PathCat(char * string, char * addedPath)
 649 {
 650 unsigned int modified = 0x0;
 651
 652 if(addedPath)
 653 {
 654 char fileName[797] = "", archiveName[797] = "", * file;
 655 int c = 0;
 656 unsigned int isURL = 0x0;
 657 char * urlFileName;
 658
 659 if(__ecereNameSpace__ecere__sys__SplitArchivePath(string, archiveName, &file))
 660 strcpy(fileName, file);
 661 else
 662 {
 663 strcpy(fileName, string);
 664 }
 665 if(strstr(string, "http://") == string)
 666 {
 667 char * slash = strstr(fileName + 7, "/");
 668
 669 isURL = 0x1;
 670 if(slash)
 671 urlFileName = slash;
 672 else
 673 urlFileName = fileName + strlen(fileName);
 674 }
 675 if(strstr(addedPath, "http://") == addedPath)
 676 {
 677 strcpy(fileName, "http://");
 678 isURL = 0x1;
 679 c = 7;
 680 }
 681 else if(runtimePlatform == 1)
 682 {
 683 if(addedPath[0] && addedPath[1] == ':' && addedPath[0] != '<')
 684 {
 685 fileName[0] = (char)toupper(addedPath[0]);
 686 fileName[1] = ':';
 687 fileName[2] = '\0';
 688 c = 2;
 689 modified = 0x1;
 690 }
 691 else if(addedPath[0] == '\\' && addedPath[1] == '\\')
 692 {
 693 fileName[0] = fileName[1] = '\\';
 694 fileName[2] = '\0';
 695 c = 2;
 696 modified = 0x1;
 697 }
 698 else if(fileName[0] == '/' && !archiveName[0] && strcmp(addedPath, "/"))
 699 return (((void *)0));
 700 }
 701 if(!modified && isURL && (addedPath[0] == '\\' || addedPath[0] == '/'))
 702 {
 703 urlFileName[0] = '/';
 704 urlFileName[1] = '\0';
 705 }
 706 else if(!modified && (addedPath[0] == '\\' || addedPath[0] == '/'))
 707 {
 708 if(runtimePlatform == 1)
 709 {
 710 if(addedPath[0] == '/' && !addedPath[1])
 711 {
 712 fileName[0] = addedPath[0];
 713 fileName[1] = '\0';
 714 modified = 0x1;
 715 }
 716 else if(fileName[0] && fileName[1] == ':')
 717 {
 718 fileName[2] = '\0';
 719 modified = 0x1;
 720 }
 721 else
 722 {
 723 fileName[0] = '\\';
 724 fileName[1] = '\0';
 725 modified = 0x1;
 726 }
 727 }
 728 else
 729 {
 730 fileName[0] = '/';
 731 fileName[1] = '\0';
 732 modified = 0x1;
 733 }
 734 c = 1;
 735 }
 736 for(; addedPath[c]; )
 737 {
 738 char directory[4384LL];
 739 int len = 0;
 740 char ch;
 741 int count;
 742
 743 for(; (ch = addedPath[c]) && (ch == '/' || ch == '\\'); c++)
 744 ;
 745 for(; (ch = addedPath[c]) && (ch != '/' && ch != '\\'); c++)
 746 {
 747 if(isURL && ch == '?')
 748 {
 749 break;
 750 }
 751 if(len < (274))
 752 directory[len++] = ch;
 753 }
 754 directory[len] = '\0';
 755 for(count = len - 1; count >= 0 && (directory[count] == ' ' || directory[count] == '\t'); count--)
 756 {
 757 directory[count] = '\0';
 758 len--;
 759 }
 760 if(len > 0)
 761 {
 762 modified = 0x1;
 763 if(strstr(directory, "..") == directory && (!directory[2] || directory[2] == ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? '\\' : '/')))
 764 {
 765 int strLen = strlen(fileName) - 1;
 766
 767 if(strLen > -1)
 768 {
 769 unsigned int separator = 0x0;
 770
 771 for(; (ch = fileName[strLen]) && strLen > -1 && (ch == '/' || ch == '\\'); strLen--)
 772 ;
 773 for(; (ch = fileName[strLen]) && strLen > -1 && (ch != '/' && ch != '\\' && ch != ':'); strLen--)
 774 ;
 775 for(; (ch = fileName[strLen]) && strLen > -1 && (ch == '/' || ch == '\\'); strLen--)
 776 separator = 0x1;
 777 if(isURL)
 778 {
 779 int __simpleStruct0;
 780
 781 strLen = (__simpleStruct0 = urlFileName - fileName, (strLen > __simpleStruct0) ? strLen : __simpleStruct0);
 782 }
 783 if(!strcmp(fileName + strLen + (separator ? 2 : 1), ".."))
 784 {
 785 strcat(fileName, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "\\" : "/"));
 786 strcat(fileName, "..");
 787 }
 788 else
 789 {
 790 if(runtimePlatform == 1)
 791 {
 792 if(!strLen && fileName[0] == '\\' && fileName[1] == '\\')
 793 {
 794 if(!fileName[2])
 795 return (((void *)0));
 796 else
 797 {
 798 fileName[0] = '\\';
 799 fileName[1] = '\\';
 800 fileName[2] = '\0';
 801 }
 802 }
 803 else
 804 fileName[strLen + 1] = '\0';
 805 }
 806 else
 807 {
 808 fileName[strLen + 1] = '\0';
 809 if(strLen < 0)
 810 {
 811 fileName[0] = '/';
 812 fileName[1] = '\0';
 813 strLen = 2;
 814 }
 815 }
 816 }
 817 }
 818 else
 819 {
 820 strcpy(fileName, "..");
 821 }
 822 }
 823 else if(strcmp(directory, "."))
 824 {
 825 int strLen = strlen(fileName);
 826 unsigned int notZeroLen = strLen > 0;
 827
 828 if(strLen > 0 && (fileName[strLen - 1] == '/' || fileName[strLen - 1] == '\\'))
 829 strLen--;
 830 if(notZeroLen)
 831 {
 832 if(isURL)
 833 fileName[strLen++] = '/';
 834 else
 835 fileName[strLen++] = ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? '\\' : '/');
 836 }
 837 fileName[strLen] = '\0';
 838 if(strLen + strlen(directory) > (797) - 3)
 839 return (((void *)0));
 840 strcat(fileName, directory);
 841 }
 842 }
 843 if(isURL && ch == '/')
 844 strcat(fileName, "/");
 845 if(isURL && ch == '?')
 846 {
 847 strcat(fileName, addedPath + c);
 848 break;
 849 }
 850 }
 851 if(archiveName[0])
 852 sprintf(string, "<%s>%s", archiveName, fileName);
 853 else
 854 strcpy(string, fileName);
 855 }
 856 return modified ? string : (((void *)0));
 857 }
 858
 859 extern int strcasecmp(const char * , const char * );
 860
 861 char * __ecereNameSpace__ecere__sys__MakePathRelative(char * path, char * to, char * destination)
 862 {
 863 if(!path[0])
 864 memmove(destination, path, strlen(path) + 1);
 865 else
 866 {
 867 char pathPart[4384LL], pathRest[797];
 868 char toPart[4384LL], toRest[797];
 869 unsigned int different = 0x0;
 870
 871 strcpy(pathRest, path);
 872 strcpy(toRest, to);
 873 destination[0] = '\0';
 874 for(; toRest[0]; )
 875 {
 876 __ecereNameSpace__ecere__sys__SplitDirectory(toRest, toPart, toRest);
 877 if(!different)
 878 __ecereNameSpace__ecere__sys__SplitDirectory(pathRest, pathPart, pathRest);
 879 if(different || ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? (strcasecmp) : strcmp)(toPart, pathPart))
 880 {
 881 different = 0x1;
 882 strcat(destination, "..");
 883 strcat(destination, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "\\" : "/"));
 884 }
 885 }
 886 if(different)
 887 __ecereNameSpace__ecere__sys__PathCat(destination, pathPart);
 888 for(; pathRest[0]; )
 889 {
 890 __ecereNameSpace__ecere__sys__SplitDirectory(pathRest, pathPart, pathRest);
 891 __ecereNameSpace__ecere__sys__PathCat(destination, pathPart);
 892 }
 893 }
 894 return destination;
 895 }
 896
 897 unsigned int __ecereNameSpace__ecere__sys__StripExtension(char * string)
 898 {
 899 int c;
 900
 901 for(c = strlen(string); c >= 0; c--)
 902 if(string[c] == '.')
 903 {
 904 string[c] = '\0';
 905 return 0x1;
 906 }
 907 else if(string[c] == '\\' || string[c] == '/')
 908 break;
 909 return 0x0;
 910 }
 911
 912 char * __ecereNameSpace__ecere__sys__ChangeExtension(char * string, char * ext, char * output)
 913 {
 914 if(string != output)
 915 strcpy(output, string);
 916 __ecereNameSpace__ecere__sys__StripExtension(output);
 917 if(ext[0])
 918 strcat(output, ".");
 919 strcat(output, ext);
 920 return output;
 921 }
 922
 923 void __ecereNameSpace__ecere__sys__PrintSize(char * string, unsigned int size, int prec)
 924 {
 925 if(size > 1024)
 926 {
 927 char format[8];
 928
 929 sprintf(format, "%%.0%df", prec);
 930 if(size > 1024 * 1024 * 1024)
 931 {
 932 sprintf(string, format, (float)size / (float)((float)(float)(1024 * 1024 * 1024)));
 933 strcat(string, " GB");
 934 }
 935 else if(size > 1024 * 1024)
 936 {
 937 sprintf(string, format, (float)size / (float)((float)(float)(1024 * 1024)));
 938 strcat(string, " MB");
 939 }
 940 else
 941 {
 942 sprintf(string, format, (float)size / (float)(float)1024);
 943 strcat(string, " KB");
 944 }
 945 }
 946 else
 947 sprintf(string, "%d B", size);
 948 }
 949
 950 void __ecereNameSpace__ecere__sys__PrintBigSize(char * string, double size, int prec)
 951 {
 952 if(size > (double)1024)
 953 {
 954 char format[8];
 955
 956 sprintf(format, "%%.0%df", prec);
 957 if(size > 1024.0 * 1024.0 * 1024.0 * 1024.0)
 958 {
 959 sprintf(string, format, size / ((double)(double)(1024 * 1024) * 1024.0 * 1024.0));
 960 strcat(string, " TB");
 961 }
 962 else if(size > 1024.0 * 1024.0 * 1024.0)
 963 {
 964 sprintf(string, format, size / (1024.0 * 1024.0 * 1024.0));
 965 strcat(string, " GB");
 966 }
 967 else if(size > 1024.0 * 1024.0)
 968 {
 969 sprintf(string, format, size / (1024.0 * 1024.0));
 970 strcat(string, " MB");
 971 }
 972 else
 973 {
 974 sprintf(string, format, size / 1024.0);
 975 strcat(string, " KB");
 976 }
 977 }
 978 else
 979 sprintf(string, "%.0f B", size);
 980 }
 981
 982 extern int strncmp(const char * , const char * , int n);
 983
 984 extern int strncasecmp(const char * , const char * , int n);
 985
 986 extern int tolower(int);
 987
 988 extern int isalnum(int c);
 989
 990 char * __ecereNameSpace__ecere__sys__SearchString(char * buffer, int start, char * subStr, unsigned int matchCase, unsigned int matchWord)
 991 {
 992 if(buffer && subStr)
 993 {
 994 char * ptr;
 995 char * strBuffer = buffer + start;
 996 int subLen = strlen(subStr);
 997 char beforeChar = start ? *(strBuffer - 1) : (char)0;
 998 int (* strcompare)(const char *, const char *, unsigned int) = matchCase ? strncmp : (strncasecmp);
 999
1000 for(ptr = strBuffer; *ptr; ptr++)
1001 {
1002 if(matchCase ? (*subStr == *ptr) : (tolower(*subStr) == tolower(*ptr)))
1003 {
1004 if(matchWord)
1005 {
1006 if(!strcompare(ptr, subStr, subLen) && (!((subStr[subLen - 1]) == '_' || isalnum((subStr[subLen - 1]))) || !((ptr[subLen]) == '_' || isalnum((ptr[subLen])))) && (!((subStr[0]) == '_' || isalnum((subStr[0]))) || !((beforeChar) == '_' || isalnum((beforeChar)))))
1007 return ptr;
1008 }
1009 else
1010 {
1011 if(!strcompare(ptr, subStr, subLen))
1012 return ptr;
1013 }
1014 }
1015 beforeChar = ptr[0];
1016 }
1017 }
1018 return (((void *)0));
1019 }
1020
1021 char * __ecereNameSpace__ecere__sys__RSearchString(char * buffer, char * subStr, int maxLen, unsigned int matchCase, unsigned int matchWord)
1022 {
1023 if(buffer && subStr)
1024 {
1025 int subLen = strlen(subStr);
1026 char * ptr1 = buffer + maxLen - subLen;
1027 char * ptr2 = buffer + maxLen - subLen - 1;
1028 int (* strcompare)(const char *, const char *, unsigned int) = matchCase ? strncmp : (strncasecmp);
1029
1030 for(; ptr1 >= buffer; ptr1--, ptr2--)
1031 {
1032 if(tolower(*subStr) == tolower(*ptr1))
1033 {
1034 if(matchWord)
1035 {
1036 if(!strcompare(ptr1, subStr, subLen) && (!((subStr[subLen - 1]) == '_' || isalnum((subStr[subLen - 1]))) || !((ptr1[subLen]) == '_' || isalnum((ptr1[subLen])))) && (!((subStr[0]) == '_' || isalnum((subStr[0]))) || !((*ptr2) == '_' || isalnum((*ptr2)))))
1037 return ptr1;
1038 }
1039 else
1040 {
1041 if(!strcompare(ptr1, subStr, subLen))
1042 return ptr1;
1043 }
1044 }
1045 }
1046 }
1047 return (((void *)0));
1048 }
1049
1050 int __ecereNameSpace__ecere__sys__Tokenize(char * string, int maxTokens, char * tokens[], unsigned int escapeBackSlashes)
1051 {
1052 int count = 0;
1053 unsigned int quoted = 0x0;
1054 unsigned char * start = (((void *)0));
1055 unsigned int escaped = 0x0;
1056 char * output = string;
1057
1058 for(; *string && count < maxTokens; string++, output++)
1059 {
1060 if(output != string)
1061 *output = *string;
1062 if(start)
1063 {
1064 if(escaped)
1065 {
1066 escaped = 0x0;
1067 output--;
1068 if(output != string)
1069 *output = *string;
1070 }
1071 else if(escapeBackSlashes && *string == '\\')
1072 escaped = 0x1;
1073 else if(*string == '\"')
1074 {
1075 if(quoted)
1076 {
1077 *output = '\0';
1078 quoted = 0x0;
1079 }
1080 else
1081 {
1082 memmove(start + 1, start, string - (char *)start);
1083 start++;
1084 }
1085 }
1086 else if(*string == ' ' && !quoted)
1087 {
1088 tokens[count++] = start;
1089 *output = '\0';
1090 start = (((void *)0));
1091 }
1092 }
1093 else if(*string != ' ')
1094 {
1095 if(*string == '\"')
1096 {
1097 quoted = 0x1;
1098 start = output + 1;
1099 }
1100 else
1101 {
1102 start = output;
1103 if(*string == '\\' && escapeBackSlashes)
1104 escaped = 0x1;
1105 }
1106 }
1107 }
1108 if(start && count < maxTokens)
1109 {
1110 tokens[count++] = start;
1111 *output = '\0';
1112 }
1113 return count;
1114 }
1115
1116 extern char *  strchr(char * , int);
1117
1118 int __ecereNameSpace__ecere__sys__TokenizeWith(char * string, int maxTokens, char * tokens[], char * tokenizers, unsigned int escapeBackSlashes)
1119 {
1120 int count = 0;
1121 unsigned int quoted = 0x0;
1122 unsigned char * start = (((void *)0));
1123 unsigned int escaped = 0x0;
1124 char * output = string;
1125 unsigned int quotedFromStart = 0x0;
1126
1127 for(; *string && count < maxTokens; string++, output++)
1128 {
1129 if(output != string)
1130 *output = *string;
1131 if(start)
1132 {
1133 if(escaped)
1134 {
1135 escaped = 0x0;
1136 output--;
1137 if(output != string)
1138 *output = *string;
1139 }
1140 else if(escapeBackSlashes && *string == '\\')
1141 escaped = 0x1;
1142 else if(*string == '\"')
1143 {
1144 if(quoted)
1145 {
1146 if(quotedFromStart)
1147 *output = '\0';
1148 quotedFromStart = 0x0;
1149 quoted = 0x0;
1150 }
1151 else
1152 quoted = 0x1;
1153 }
1154 else if(strchr(tokenizers, *string) && !quoted)
1155 {
1156 tokens[count++] = start;
1157 *output = '\0';
1158 start = (((void *)0));
1159 }
1160 }
1161 else if(!strchr(tokenizers, *string))
1162 {
1163 if(*string == '\"')
1164 {
1165 quotedFromStart = 0x1;
1166 quoted = 0x1;
1167 start = output + 1;
1168 }
1169 else
1170 {
1171 start = output;
1172 if(*string == '\\' && escapeBackSlashes)
1173 escaped = 0x1;
1174 }
1175 }
1176 }
1177 if(start && count < maxTokens)
1178 {
1179 tokens[count++] = start;
1180 *output = '\0';
1181 }
1182 return count;
1183 }
1184
1185 char * __ecereNameSpace__ecere__sys__TrimLSpaces(char * string, char * output)
1186 {
1187 int c;
1188
1189 for(c = 0; string[c] && string[c] == ' '; c++)
1190 ;
1191 memmove(output, string + c, strlen(string + c) + 1);
1192 return output;
1193 }
1194
1195 char * __ecereNameSpace__ecere__sys__TrimRSpaces(char * string, char * output)
1196 {
1197 int c;
1198
1199 for(c = strlen(string) - 1; c >= 0 && string[c] == ' '; c--)
1200 ;
1201 if(c >= 0)
1202 {
1203 memmove(output, string, c + 1);
1204 output[c + 1] = '\0';
1205 }
1206 else
1207 output[0] = '\0';
1208 return output;
1209 }
1210
1211 void __ecereNameSpace__ecere__sys__ChangeCh(char * string, char ch1, char ch2)
1212 {
1213 int c;
1214
1215 for(c = 0; string[c]; c++)
1216 if(string[c] == ch1)
1217 string[c] = ch2;
1218 }
1219
1220 void __ecereNameSpace__ecere__sys__RepeatCh(char * string, int count, char ch)
1221 {
1222 int c;
1223
1224 for(c = 0; c < count; c++)
1225 string[c] = ch;
1226 string[c] = (char)0;
1227 }
1228
1229 extern void *  memcpy(void * , const void * , unsigned int size);
1230
1231 char * __ecereNameSpace__ecere__sys__CopyString(char * string)
1232 {
1233 if(string)
1234 {
1235 int len = strlen(string);
1236 char * destination = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (len + 1));
1237
1238 if(destination)
1239 memcpy(destination, string, len + 1);
1240 return destination;
1241 }
1242 else
1243 return (((void *)0));
1244 }
1245
1246 unsigned int __ecereNameSpace__ecere__sys__GetString(char ** buffer, char * string, int max)
1247 {
1248 int c;
1249 char ch;
1250 unsigned int quoted = 0x0;
1251 unsigned int result = 0x1;
1252
1253 if(!* *buffer)
1254 {
1255 string[0] = (char)0;
1256 return 0x0;
1257 }
1258 for(; ; )
1259 {
1260 if(!(ch = *((*buffer)++)))
1261 result = 0x0;
1262 if((ch != '\n') && (ch != '\r') && (ch != ' ') && (ch != ',') && (ch != '\t'))
1263 break;
1264 if(!*(*buffer))
1265 break;
1266 }
1267 if(result)
1268 {
1269 for(c = 0; c < max - 1; c++)
1270 {
1271 if(!quoted && ((ch == '\n') || (ch == '\r') || (ch == ' ') || (ch == ',') || (ch == '\t')))
1272 {
1273 result = 0x1;
1274 break;
1275 }
1276 if(ch == '\"')
1277 {
1278 quoted ^= (unsigned int)1;
1279 c--;
1280 }
1281 else
1282 string[c] = ch;
1283 if(!(ch = *(*buffer)))
1284 {
1285 c++;
1286 break;
1287 }
1288 (*buffer)++;
1289 }
1290 string[c] = (char)0;
1291 }
1292 return result;
1293 }
1294
1295 extern int atoi(const char * );
1296
1297 int __ecereNameSpace__ecere__sys__GetValue(char ** buffer)
1298 {
1299 char string[20];
1300
1301 __ecereNameSpace__ecere__sys__GetString(buffer, string, 20);
1302 return atoi(string);
1303 }
1304
1305 extern unsigned long strtoul(const char *  nptr, char * *  endptr, int base);
1306
1307 unsigned int __ecereNameSpace__ecere__sys__GetHexValue(char ** buffer)
1308 {
1309 char string[20];
1310
1311 __ecereNameSpace__ecere__sys__GetString(buffer, string, 20);
1312 return strtoul(string, (((void *)0)), 16);
1313 }
1314
1315 char * __ecereNameSpace__ecere__sys__StripQuotes(char * string, char * output)
1316 {
1317 int len;
1318 char * src = (string[0] == '\"') ? (string + 1) : string;
1319
1320 memmove(output, src, strlen(src) + 1);
1321 len = strlen(output);
1322 if(len && output[len - 1] == '\"')
1323 output[len - 1] = '\0';
1324 return output;
1325 }
1326
1327 extern unsigned int isdigit(int);
1328
1329 double __ecereNameSpace__ecere__sys__FloatFromString(char * string)
1330 {
1331 int c, dig;
1332 float dec = (float)0, res = (float)0;
1333 int neg = 1;
1334 char ch;
1335
1336 for(c = 0; string[c]; c++)
1337 {
1338 ch = string[c];
1339 if(ch == ' ')
1340 continue;
1341 if(ch == '-')
1342 {
1343 if(neg == -1)
1344 break;
1345 neg = -1;
1346 }
1347 else if((ch == '.') && !dec)
1348 dec = (float)10;
1349 else if(isdigit(ch))
1350 {
1351 dig = ch - '0';
1352 if(dec)
1353 {
1354 res += (float)dig / dec;
1355 dec *= 10;
1356 }
1357 else
1358 res = res * (float)10 + (float)dig;
1359 }
1360 else
1361 break;
1362 }
1363 return (float)neg * res;
1364 }
1365
1366 unsigned int __ecereNameSpace__ecere__sys__IsPathInsideOf(char * path, char * of)
1367 {
1368 if(!path[0] || !of[0])
1369 return 0x0;
1370 else
1371 {
1372 char ofPart[274], ofRest[797];
1373 char pathPart[274], pathRest[797];
1374
1375 strcpy(ofRest, of);
1376 strcpy(pathRest, path);
1377 for(; ofRest[0] && pathRest[0]; )
1378 {
1379 __ecereNameSpace__ecere__sys__SplitDirectory(ofRest, ofPart, ofRest);
1380 __ecereNameSpace__ecere__sys__SplitDirectory(pathRest, pathPart, pathRest);
1381 if(((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? (strcasecmp) : strcmp)(pathPart, ofPart))
1382 return 0x0;
1383 }
1384 if(!ofRest[0] && !pathRest[0])
1385 return 0x0;
1386 else if(!pathRest[0])
1387 return 0x0;
1388 return 0x1;
1389 }
1390 }
1391
1392 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DefinedExpression;
1393
1394 struct __ecereNameSpace__ecere__com__DefinedExpression;
1395
1396 extern struct __ecereNameSpace__ecere__com__DefinedExpression * __ecereNameSpace__ecere__com__eSystem_RegisterDefine(char *  name, char *  value, struct __ecereNameSpace__ecere__com__Instance * module, int declMode);
1397
1398 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
1399
1400 struct __ecereNameSpace__ecere__com__GlobalFunction;
1401
1402 extern struct __ecereNameSpace__ecere__com__GlobalFunction * __ecereNameSpace__ecere__com__eSystem_RegisterFunction(char *  name, char *  type, void *  func, struct __ecereNameSpace__ecere__com__Instance * module, int declMode);
1403
1404 void __ecereRegisterModule_String(struct __ecereNameSpace__ecere__com__Instance * module)
1405 {
1406 struct __ecereNameSpace__ecere__com__Class * class;
1407
1408 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::DIR_SEP", "(GetRuntimePlatform() == win32) ? '\\\\' : '/'", module, 4);
1409 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::DIR_SEPS", "(GetRuntimePlatform() == win32) ? \"\\\\\" : \"/\"", module, 4);
1410 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::MAX_F_STRING", "1025", module, 4);
1411 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::MAX_EXTENSION", "17", module, 4);
1412 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::MAX_FILENAME", "274", module, 4);
1413 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::MAX_DIRECTORY", "534", module, 4);
1414 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::MAX_LOCATION", "797", module, 4);
1415 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::GetExtension", "char * ecere::sys::GetExtension(char * string, char * output)", __ecereNameSpace__ecere__sys__GetExtension, module, 4);
1416 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::StripLastDirectory", "char * ecere::sys::StripLastDirectory(char * string, char * output)", __ecereNameSpace__ecere__sys__StripLastDirectory, module, 4);
1417 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::SplitDirectory", "char * ecere::sys::SplitDirectory(char * string, char * part, char * rest)", __ecereNameSpace__ecere__sys__SplitDirectory, module, 4);
1418 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::GetLastDirectory", "char * ecere::sys::GetLastDirectory(char * string, char * output)", __ecereNameSpace__ecere__sys__GetLastDirectory, module, 4);
1419 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::SplitArchivePath", "bool ecere::sys::SplitArchivePath(char * fileName, char * archiveName, char * * archiveFile)", __ecereNameSpace__ecere__sys__SplitArchivePath, module, 4);
1420 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::PathCatSlash", "char * ecere::sys::PathCatSlash(char * string, char * addedPath)", __ecereNameSpace__ecere__sys__PathCatSlash, module, 4);
1421 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::PathCat", "char * ecere::sys::PathCat(char * string, char * addedPath)", __ecereNameSpace__ecere__sys__PathCat, module, 4);
1422 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::MakePathRelative", "char * ecere::sys::MakePathRelative(char * path, char * to, char * destination)", __ecereNameSpace__ecere__sys__MakePathRelative, module, 4);
1423 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::StripExtension", "bool ecere::sys::StripExtension(char * string)", __ecereNameSpace__ecere__sys__StripExtension, module, 4);
1424 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::ChangeExtension", "char * ecere::sys::ChangeExtension(char * string, char * ext, char * output)", __ecereNameSpace__ecere__sys__ChangeExtension, module, 4);
1425 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::PrintSize", "void ecere::sys::PrintSize(char * string, uint size, int prec)", __ecereNameSpace__ecere__sys__PrintSize, module, 4);
1426 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::PrintBigSize", "void ecere::sys::PrintBigSize(char * string, double size, int prec)", __ecereNameSpace__ecere__sys__PrintBigSize, module, 4);
1427 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::SearchString", "char * ecere::sys::SearchString(char * buffer, int start, char * subStr, bool matchCase, bool matchWord)", __ecereNameSpace__ecere__sys__SearchString, module, 4);
1428 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::RSearchString", "char * ecere::sys::RSearchString(char * buffer, char * subStr, int maxLen, bool matchCase, bool matchWord)", __ecereNameSpace__ecere__sys__RSearchString, module, 4);
1429 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::Tokenize", "int ecere::sys::Tokenize(char * string, int maxTokens, char * tokens[], bool escapeBackSlashes)", __ecereNameSpace__ecere__sys__Tokenize, module, 4);
1430 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::TokenizeWith", "int ecere::sys::TokenizeWith(char * string, int maxTokens, char * tokens[], char * tokenizers, bool escapeBackSlashes)", __ecereNameSpace__ecere__sys__TokenizeWith, module, 4);
1431 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::TrimLSpaces", "char * ecere::sys::TrimLSpaces(char * string, char * output)", __ecereNameSpace__ecere__sys__TrimLSpaces, module, 4);
1432 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::TrimRSpaces", "char * ecere::sys::TrimRSpaces(char * string, char * output)", __ecereNameSpace__ecere__sys__TrimRSpaces, module, 4);
1433 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::ChangeCh", "void ecere::sys::ChangeCh(char * string, char ch1, char ch2)", __ecereNameSpace__ecere__sys__ChangeCh, module, 4);
1434 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::RepeatCh", "void ecere::sys::RepeatCh(char * string, int count, char ch)", __ecereNameSpace__ecere__sys__RepeatCh, module, 4);
1435 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::CopyString", "char * ecere::sys::CopyString(char * string)", __ecereNameSpace__ecere__sys__CopyString, module, 4);
1436 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::GetString", "bool ecere::sys::GetString(char * * buffer, char * string, int max)", __ecereNameSpace__ecere__sys__GetString, module, 4);
1437 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::GetValue", "int ecere::sys::GetValue(char * * buffer)", __ecereNameSpace__ecere__sys__GetValue, module, 4);
1438 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::GetHexValue", "uint ecere::sys::GetHexValue(char * * buffer)", __ecereNameSpace__ecere__sys__GetHexValue, module, 4);
1439 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::StripQuotes", "char * ecere::sys::StripQuotes(char * string, char * output)", __ecereNameSpace__ecere__sys__StripQuotes, module, 4);
1440 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::FloatFromString", "double ecere::sys::FloatFromString(char * string)", __ecereNameSpace__ecere__sys__FloatFromString, module, 4);
1441 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::IsPathInsideOf", "bool ecere::sys::IsPathInsideOf(char * path, char * of)", __ecereNameSpace__ecere__sys__IsPathInsideOf, module, 4);
1442 }
1443
1444 void __ecereUnregisterModule_String(struct __ecereNameSpace__ecere__com__Instance * module)
1445 {
1446
1447 }
1448