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