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