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