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 void *  memmove(void * , const void * , unsigned int size);
 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 memmove(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 memmove(rest, string + c, strlen(string + c) + 1);
 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 memmove(output, string + c, strlen(string + c) + 1);
 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 extern char *  strncpy(char * , const char * , int n);
 403
 404 unsigned int __ecereNameSpace__ecere__sys__SplitArchivePath(char * fileName, char * archiveName, char ** archiveFile)
 405 {
 406 if(fileName[0] == '<')
 407 {
 408 int c = strlen(fileName);
 409
 410 for(; c > 0 && fileName[c] != '>'; c--)
 411 ;
 412 if(c > 0)
 413 {
 414 strncpy(archiveName, fileName + 1, c - 1);
 415 archiveName[c - 1] = '\0';
 416 *archiveFile = fileName + c + 1;
 417 return 0x1;
 418 }
 419 }
 420 else if(fileName[0] == ':')
 421 {
 422 strcpy(archiveName, ":");
 423 *archiveFile = fileName + 1;
 424 return 0x1;
 425 }
 426 return 0x0;
 427 }
 428
 429 extern char *  strstr(char * , const char * );
 430
 431 extern int toupper(int);
 432
 433 extern char *  strcat(char * , const char * );
 434
 435 extern int sprintf(char * , char * , ...);
 436
 437 char * __ecereNameSpace__ecere__sys__PathCatSlash(char * string, char * addedPath)
 438 {
 439 unsigned int modified = 0x0;
 440
 441 if(addedPath)
 442 {
 443 char fileName[797] = "", archiveName[797] = "", * file;
 444 int c = 0;
 445 unsigned int isURL = 0x0;
 446 char * urlFileName;
 447
 448 if(__ecereNameSpace__ecere__sys__SplitArchivePath(string, archiveName, &file))
 449 strcpy(fileName, file);
 450 else
 451 {
 452 strcpy(fileName, string);
 453 }
 454 if(strstr(string, "http://") == string)
 455 {
 456 char * slash = strstr(fileName + 7, "/");
 457
 458 isURL = 0x1;
 459 if(slash)
 460 urlFileName = slash;
 461 else
 462 urlFileName = fileName + strlen(fileName);
 463 }
 464 if(strstr(addedPath, "http://") == addedPath)
 465 {
 466 strcpy(fileName, "http://");
 467 isURL = 0x1;
 468 c = 7;
 469 }
 470 else if(__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1)
 471 {
 472 if(addedPath[0] && addedPath[1] == ':' && addedPath[0] != '<')
 473 {
 474 fileName[0] = (char)toupper(addedPath[0]);
 475 fileName[1] = ':';
 476 fileName[2] = '\0';
 477 c = 2;
 478 modified = 0x1;
 479 }
 480 else if(addedPath[0] == '\\' && addedPath[1] == '\\')
 481 {
 482 fileName[0] = fileName[1] = '\\';
 483 fileName[2] = '\0';
 484 c = 2;
 485 modified = 0x1;
 486 }
 487 }
 488 if(!modified && isURL && (addedPath[0] == '\\' || addedPath[0] == '/'))
 489 {
 490 urlFileName[0] = '/';
 491 urlFileName[1] = '\0';
 492 }
 493 else if(!modified && (addedPath[0] == '\\' || addedPath[0] == '/'))
 494 {
 495 if(__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1)
 496 {
 497 if(addedPath[0] == '/' && !addedPath[1])
 498 {
 499 fileName[0] = addedPath[0];
 500 fileName[1] = '\0';
 501 modified = 0x1;
 502 }
 503 else if(fileName[0] && fileName[1] == ':')
 504 {
 505 fileName[2] = '\0';
 506 modified = 0x1;
 507 }
 508 else
 509 {
 510 fileName[0] = '\\';
 511 fileName[1] = '\0';
 512 modified = 0x1;
 513 }
 514 }
 515 else
 516 {
 517 fileName[0] = '/';
 518 fileName[1] = '\0';
 519 modified = 0x1;
 520 }
 521 c = 1;
 522 }
 523 for(; addedPath[c]; )
 524 {
 525 char directory[4384LL];
 526 int len = 0;
 527 char ch;
 528 int count;
 529
 530 for(; (ch = addedPath[c]) && (ch == '/' || ch == '\\'); c++)
 531 ;
 532 for(; (ch = addedPath[c]) && (ch != '/' && ch != '\\'); c++)
 533 {
 534 if(isURL && ch == '?')
 535 {
 536 break;
 537 }
 538 if(len < (274))
 539 directory[len++] = ch;
 540 }
 541 directory[len] = '\0';
 542 for(count = len - 1; count >= 0 && (directory[count] == ' ' || directory[count] == '\t'); count--)
 543 {
 544 directory[count] = '\0';
 545 len--;
 546 }
 547 if(len > 0)
 548 {
 549 modified = 0x1;
 550 if(strstr(directory, "..") == directory && (!directory[2] || directory[2] == ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? '\\' : '/') || directory[2] == '/'))
 551 {
 552 int strLen = strlen(fileName) - 1;
 553
 554 if(strLen > -1)
 555 {
 556 for(; (ch = fileName[strLen]) && strLen > -1 && (ch == '/' || ch == '\\'); strLen--)
 557 ;
 558 for(; (ch = fileName[strLen]) && strLen > -1 && (ch != '/' && ch != '\\' && ch != ':'); strLen--)
 559 ;
 560 for(; (ch = fileName[strLen]) && strLen > -1 && (ch == '/' || ch == '\\'); strLen--)
 561 ;
 562 if(isURL)
 563 {
 564 int __simpleStruct0;
 565
 566 strLen = (__simpleStruct0 = urlFileName - fileName, (strLen > __simpleStruct0) ? strLen : __simpleStruct0);
 567 }
 568 if(!strcmp(fileName + strLen + 1, ".."))
 569 {
 570 strcat(fileName, "/");
 571 strcat(fileName, "..");
 572 }
 573 else
 574 {
 575 if(__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1)
 576 {
 577 if(!strLen && fileName[0] == '\\' && fileName[1] == '\\')
 578 {
 579 if(!fileName[2])
 580 return (((void *)0));
 581 else
 582 {
 583 fileName[0] = '\\';
 584 fileName[1] = '\\';
 585 fileName[2] = '\0';
 586 }
 587 }
 588 else
 589 fileName[strLen + 1] = '\0';
 590 }
 591 else
 592 {
 593 fileName[strLen + 1] = '\0';
 594 if(strLen < 0)
 595 {
 596 fileName[0] = '/';
 597 fileName[1] = '\0';
 598 strLen = 2;
 599 }
 600 }
 601 }
 602 }
 603 else
 604 {
 605 strcpy(fileName, "..");
 606 }
 607 }
 608 else if(strcmp(directory, "."))
 609 {
 610 int strLen = strlen(fileName);
 611 unsigned int notZeroLen = strLen > 0;
 612
 613 if(strLen > 0 && (fileName[strLen - 1] == '/' || fileName[strLen - 1] == '\\'))
 614 strLen--;
 615 if(notZeroLen)
 616 fileName[strLen++] = '/';
 617 fileName[strLen] = '\0';
 618 if(strLen + strlen(directory) > (797) - 3)
 619 return (((void *)0));
 620 strcat(fileName, directory);
 621 }
 622 }
 623 if(isURL && ch == '/')
 624 strcat(fileName, "/");
 625 if(isURL && ch == '?')
 626 {
 627 strcat(fileName, addedPath + c);
 628 break;
 629 }
 630 }
 631 if(archiveName[0])
 632 sprintf(string, "<%s>%s", archiveName, fileName);
 633 else
 634 strcpy(string, fileName);
 635 }
 636 return modified ? string : (((void *)0));
 637 }
 638
 639 char * __ecereNameSpace__ecere__sys__PathCat(char * string, char * addedPath)
 640 {
 641 unsigned int modified = 0x0;
 642
 643 if(addedPath)
 644 {
 645 char fileName[797] = "", archiveName[797] = "", * file;
 646 int c = 0;
 647 unsigned int isURL = 0x0;
 648 char * urlFileName;
 649
 650 if(__ecereNameSpace__ecere__sys__SplitArchivePath(string, archiveName, &file))
 651 strcpy(fileName, file);
 652 else
 653 {
 654 strcpy(fileName, string);
 655 }
 656 if(strstr(string, "http://") == string)
 657 {
 658 char * slash = strstr(fileName + 7, "/");
 659
 660 isURL = 0x1;
 661 if(slash)
 662 urlFileName = slash;
 663 else
 664 urlFileName = fileName + strlen(fileName);
 665 }
 666 if(strstr(addedPath, "http://") == addedPath)
 667 {
 668 strcpy(fileName, "http://");
 669 isURL = 0x1;
 670 c = 7;
 671 }
 672 else if(runtimePlatform == 1)
 673 {
 674 if(addedPath[0] && addedPath[1] == ':' && addedPath[0] != '<')
 675 {
 676 fileName[0] = (char)toupper(addedPath[0]);
 677 fileName[1] = ':';
 678 fileName[2] = '\0';
 679 c = 2;
 680 modified = 0x1;
 681 }
 682 else if(addedPath[0] == '\\' && addedPath[1] == '\\')
 683 {
 684 fileName[0] = fileName[1] = '\\';
 685 fileName[2] = '\0';
 686 c = 2;
 687 modified = 0x1;
 688 }
 689 else if(fileName[0] == '/' && !archiveName[0] && strcmp(addedPath, "/"))
 690 return (((void *)0));
 691 }
 692 if(!modified && isURL && (addedPath[0] == '\\' || addedPath[0] == '/'))
 693 {
 694 urlFileName[0] = '/';
 695 urlFileName[1] = '\0';
 696 }
 697 else if(!modified && (addedPath[0] == '\\' || addedPath[0] == '/'))
 698 {
 699 if(runtimePlatform == 1)
 700 {
 701 if(addedPath[0] == '/' && !addedPath[1])
 702 {
 703 fileName[0] = addedPath[0];
 704 fileName[1] = '\0';
 705 modified = 0x1;
 706 }
 707 else if(fileName[0] && fileName[1] == ':')
 708 {
 709 fileName[2] = '\0';
 710 modified = 0x1;
 711 }
 712 else
 713 {
 714 fileName[0] = '\\';
 715 fileName[1] = '\0';
 716 modified = 0x1;
 717 }
 718 }
 719 else
 720 {
 721 fileName[0] = '/';
 722 fileName[1] = '\0';
 723 modified = 0x1;
 724 }
 725 c = 1;
 726 }
 727 for(; addedPath[c]; )
 728 {
 729 char directory[4384LL];
 730 int len = 0;
 731 char ch;
 732 int count;
 733
 734 for(; (ch = addedPath[c]) && (ch == '/' || ch == '\\'); c++)
 735 ;
 736 for(; (ch = addedPath[c]) && (ch != '/' && ch != '\\'); c++)
 737 {
 738 if(isURL && ch == '?')
 739 {
 740 break;
 741 }
 742 if(len < (274))
 743 directory[len++] = ch;
 744 }
 745 directory[len] = '\0';
 746 for(count = len - 1; count >= 0 && (directory[count] == ' ' || directory[count] == '\t'); count--)
 747 {
 748 directory[count] = '\0';
 749 len--;
 750 }
 751 if(len > 0)
 752 {
 753 modified = 0x1;
 754 if(strstr(directory, "..") == directory && (!directory[2] || directory[2] == ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? '\\' : '/')))
 755 {
 756 int strLen = strlen(fileName) - 1;
 757
 758 if(strLen > -1)
 759 {
 760 unsigned int separator = 0x0;
 761
 762 for(; (ch = fileName[strLen]) && strLen > -1 && (ch == '/' || ch == '\\'); strLen--)
 763 ;
 764 for(; (ch = fileName[strLen]) && strLen > -1 && (ch != '/' && ch != '\\' && ch != ':'); strLen--)
 765 ;
 766 for(; (ch = fileName[strLen]) && strLen > -1 && (ch == '/' || ch == '\\'); strLen--)
 767 separator = 0x1;
 768 if(isURL)
 769 {
 770 int __simpleStruct0;
 771
 772 strLen = (__simpleStruct0 = urlFileName - fileName, (strLen > __simpleStruct0) ? strLen : __simpleStruct0);
 773 }
 774 if(!strcmp(fileName + strLen + (separator ? 2 : 1), ".."))
 775 {
 776 strcat(fileName, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "\\" : "/"));
 777 strcat(fileName, "..");
 778 }
 779 else
 780 {
 781 if(runtimePlatform == 1)
 782 {
 783 if(!strLen && fileName[0] == '\\' && fileName[1] == '\\')
 784 {
 785 if(!fileName[2])
 786 return (((void *)0));
 787 else
 788 {
 789 fileName[0] = '\\';
 790 fileName[1] = '\\';
 791 fileName[2] = '\0';
 792 }
 793 }
 794 else
 795 fileName[strLen + 1] = '\0';
 796 }
 797 else
 798 {
 799 fileName[strLen + 1] = '\0';
 800 if(strLen < 0)
 801 {
 802 fileName[0] = '/';
 803 fileName[1] = '\0';
 804 strLen = 2;
 805 }
 806 }
 807 }
 808 }
 809 else
 810 {
 811 strcpy(fileName, "..");
 812 }
 813 }
 814 else if(strcmp(directory, "."))
 815 {
 816 int strLen = strlen(fileName);
 817 unsigned int notZeroLen = strLen > 0;
 818
 819 if(strLen > 0 && (fileName[strLen - 1] == '/' || fileName[strLen - 1] == '\\'))
 820 strLen--;
 821 if(notZeroLen)
 822 {
 823 if(isURL)
 824 fileName[strLen++] = '/';
 825 else
 826 fileName[strLen++] = ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? '\\' : '/');
 827 }
 828 fileName[strLen] = '\0';
 829 if(strLen + strlen(directory) > (797) - 3)
 830 return (((void *)0));
 831 strcat(fileName, directory);
 832 }
 833 }
 834 if(isURL && ch == '/')
 835 strcat(fileName, "/");
 836 if(isURL && ch == '?')
 837 {
 838 strcat(fileName, addedPath + c);
 839 break;
 840 }
 841 }
 842 if(archiveName[0])
 843 sprintf(string, "<%s>%s", archiveName, fileName);
 844 else
 845 strcpy(string, fileName);
 846 }
 847 return modified ? string : (((void *)0));
 848 }
 849
 850 extern int strcasecmp(const char * , const char * );
 851
 852 char * __ecereNameSpace__ecere__sys__MakePathRelative(char * path, char * to, char * destination)
 853 {
 854 if(!path[0])
 855 memmove(destination, path, strlen(path) + 1);
 856 else
 857 {
 858 char pathPart[4384LL], pathRest[797];
 859 char toPart[4384LL], toRest[797];
 860 unsigned int different = 0x0;
 861
 862 strcpy(pathRest, path);
 863 strcpy(toRest, to);
 864 destination[0] = '\0';
 865 for(; toRest[0]; )
 866 {
 867 __ecereNameSpace__ecere__sys__SplitDirectory(toRest, toPart, toRest);
 868 if(!different)
 869 __ecereNameSpace__ecere__sys__SplitDirectory(pathRest, pathPart, pathRest);
 870 if(different || ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? (strcasecmp) : strcmp)(toPart, pathPart))
 871 {
 872 different = 0x1;
 873 strcat(destination, "..");
 874 strcat(destination, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "\\" : "/"));
 875 }
 876 }
 877 if(different)
 878 __ecereNameSpace__ecere__sys__PathCat(destination, pathPart);
 879 for(; pathRest[0]; )
 880 {
 881 __ecereNameSpace__ecere__sys__SplitDirectory(pathRest, pathPart, pathRest);
 882 __ecereNameSpace__ecere__sys__PathCat(destination, pathPart);
 883 }
 884 }
 885 return destination;
 886 }
 887
 888 unsigned int __ecereNameSpace__ecere__sys__StripExtension(char * string)
 889 {
 890 int c;
 891
 892 for(c = strlen(string); c >= 0; c--)
 893 if(string[c] == '.')
 894 {
 895 string[c] = '\0';
 896 return 0x1;
 897 }
 898 else if(string[c] == '\\' || string[c] == '/')
 899 break;
 900 return 0x0;
 901 }
 902
 903 char * __ecereNameSpace__ecere__sys__ChangeExtension(char * string, char * ext, char * output)
 904 {
 905 if(string != output)
 906 strcpy(output, string);
 907 __ecereNameSpace__ecere__sys__StripExtension(output);
 908 if(ext[0])
 909 strcat(output, ".");
 910 strcat(output, ext);
 911 return output;
 912 }
 913
 914 void __ecereNameSpace__ecere__sys__PrintSize(char * string, unsigned int size, int prec)
 915 {
 916 if(size > 1024)
 917 {
 918 char format[8];
 919
 920 sprintf(format, "%%.0%df", prec);
 921 if(size > 1024 * 1024 * 1024)
 922 {
 923 sprintf(string, format, (float)size / (float)((float)(float)(1024 * 1024 * 1024)));
 924 strcat(string, " GB");
 925 }
 926 else if(size > 1024 * 1024)
 927 {
 928 sprintf(string, format, (float)size / (float)((float)(float)(1024 * 1024)));
 929 strcat(string, " MB");
 930 }
 931 else
 932 {
 933 sprintf(string, format, (float)size / (float)(float)1024);
 934 strcat(string, " KB");
 935 }
 936 }
 937 else
 938 sprintf(string, "%d B", size);
 939 }
 940
 941 void __ecereNameSpace__ecere__sys__PrintBigSize(char * string, double size, int prec)
 942 {
 943 if(size > (double)1024)
 944 {
 945 char format[8];
 946
 947 sprintf(format, "%%.0%df", prec);
 948 if(size > 1024.0 * 1024.0 * 1024.0 * 1024.0)
 949 {
 950 sprintf(string, format, size / ((double)(double)(1024 * 1024) * 1024.0 * 1024.0));
 951 strcat(string, " TB");
 952 }
 953 else if(size > 1024.0 * 1024.0 * 1024.0)
 954 {
 955 sprintf(string, format, size / (1024.0 * 1024.0 * 1024.0));
 956 strcat(string, " GB");
 957 }
 958 else if(size > 1024.0 * 1024.0)
 959 {
 960 sprintf(string, format, size / (1024.0 * 1024.0));
 961 strcat(string, " MB");
 962 }
 963 else
 964 {
 965 sprintf(string, format, size / 1024.0);
 966 strcat(string, " KB");
 967 }
 968 }
 969 else
 970 sprintf(string, "%.0f B", size);
 971 }
 972
 973 extern int strncmp(const char * , const char * , int n);
 974
 975 extern int strncasecmp(const char * , const char * , int n);
 976
 977 extern int tolower(int);
 978
 979 extern int isalnum(int c);
 980
 981 char * __ecereNameSpace__ecere__sys__SearchString(char * buffer, int start, char * subStr, unsigned int matchCase, unsigned int matchWord)
 982 {
 983 if(buffer && subStr)
 984 {
 985 char * ptr;
 986 char * strBuffer = buffer + start;
 987 int subLen = strlen(subStr);
 988 char beforeChar = start ? *(strBuffer - 1) : (char)0;
 989 int (* strcompare)(const char *, const char *, unsigned int) = matchCase ? strncmp : (strncasecmp);
 990
 991 for(ptr = strBuffer; *ptr; ptr++)
 992 {
 993 if(matchCase ? (*subStr == *ptr) : (tolower(*subStr) == tolower(*ptr)))
 994 {
 995 if(matchWord)
 996 {
 997 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)))))
 998 return ptr;
 999 }
1000 else
1001 {
1002 if(!strcompare(ptr, subStr, subLen))
1003 return ptr;
1004 }
1005 }
1006 beforeChar = ptr[0];
1007 }
1008 }
1009 return (((void *)0));
1010 }
1011
1012 char * __ecereNameSpace__ecere__sys__RSearchString(char * buffer, char * subStr, int maxLen, unsigned int matchCase, unsigned int matchWord)
1013 {
1014 if(buffer && subStr)
1015 {
1016 int subLen = strlen(subStr);
1017 char * ptr1 = buffer + maxLen - subLen;
1018 char * ptr2 = buffer + maxLen - subLen - 1;
1019 int (* strcompare)(const char *, const char *, unsigned int) = matchCase ? strncmp : (strncasecmp);
1020
1021 for(; ptr1 >= buffer; ptr1--, ptr2--)
1022 {
1023 if(tolower(*subStr) == tolower(*ptr1))
1024 {
1025 if(matchWord)
1026 {
1027 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)))))
1028 return ptr1;
1029 }
1030 else
1031 {
1032 if(!strcompare(ptr1, subStr, subLen))
1033 return ptr1;
1034 }
1035 }
1036 }
1037 }
1038 return (((void *)0));
1039 }
1040
1041 int __ecereNameSpace__ecere__sys__Tokenize(char * string, int maxTokens, char * tokens[], unsigned int escapeBackSlashes)
1042 {
1043 int count = 0;
1044 unsigned int quoted = 0x0;
1045 unsigned char * start = (((void *)0));
1046 unsigned int escaped = 0x0;
1047 char * output = string;
1048
1049 for(; *string && count < maxTokens; string++, output++)
1050 {
1051 if(output != string)
1052 *output = *string;
1053 if(start)
1054 {
1055 if(escaped)
1056 {
1057 escaped = 0x0;
1058 output--;
1059 if(output != string)
1060 *output = *string;
1061 }
1062 else if(escapeBackSlashes && *string == '\\')
1063 escaped = 0x1;
1064 else if(*string == '\"')
1065 {
1066 if(quoted)
1067 {
1068 *output = '\0';
1069 quoted = 0x0;
1070 }
1071 else
1072 {
1073 memmove(start + 1, start, string - (char *)start);
1074 start++;
1075 }
1076 }
1077 else if(*string == ' ' && !quoted)
1078 {
1079 tokens[count++] = start;
1080 *output = '\0';
1081 start = (((void *)0));
1082 }
1083 }
1084 else if(*string != ' ')
1085 {
1086 if(*string == '\"')
1087 {
1088 quoted = 0x1;
1089 start = output + 1;
1090 }
1091 else
1092 {
1093 start = output;
1094 if(*string == '\\' && escapeBackSlashes)
1095 escaped = 0x1;
1096 }
1097 }
1098 }
1099 if(start && count < maxTokens)
1100 {
1101 tokens[count++] = start;
1102 *output = '\0';
1103 }
1104 return count;
1105 }
1106
1107 extern char *  strchr(char * , int);
1108
1109 int __ecereNameSpace__ecere__sys__TokenizeWith(char * string, int maxTokens, char * tokens[], char * tokenizers, unsigned int escapeBackSlashes)
1110 {
1111 int count = 0;
1112 unsigned int quoted = 0x0;
1113 unsigned char * start = (((void *)0));
1114 unsigned int escaped = 0x0;
1115 char * output = string;
1116 unsigned int quotedFromStart = 0x0;
1117
1118 for(; *string && count < maxTokens; string++, output++)
1119 {
1120 if(output != string)
1121 *output = *string;
1122 if(start)
1123 {
1124 if(escaped)
1125 {
1126 escaped = 0x0;
1127 output--;
1128 if(output != string)
1129 *output = *string;
1130 }
1131 else if(escapeBackSlashes && *string == '\\')
1132 escaped = 0x1;
1133 else if(*string == '\"')
1134 {
1135 if(quoted)
1136 {
1137 if(quotedFromStart)
1138 *output = '\0';
1139 quotedFromStart = 0x0;
1140 quoted = 0x0;
1141 }
1142 else
1143 quoted = 0x1;
1144 }
1145 else if(strchr(tokenizers, *string) && !quoted)
1146 {
1147 tokens[count++] = start;
1148 *output = '\0';
1149 start = (((void *)0));
1150 }
1151 }
1152 else if(!strchr(tokenizers, *string))
1153 {
1154 if(*string == '\"')
1155 {
1156 quotedFromStart = 0x1;
1157 quoted = 0x1;
1158 start = output + 1;
1159 }
1160 else
1161 {
1162 start = output;
1163 if(*string == '\\' && escapeBackSlashes)
1164 escaped = 0x1;
1165 }
1166 }
1167 }
1168 if(start && count < maxTokens)
1169 {
1170 tokens[count++] = start;
1171 *output = '\0';
1172 }
1173 return count;
1174 }
1175
1176 char * __ecereNameSpace__ecere__sys__TrimLSpaces(char * string, char * output)
1177 {
1178 int c;
1179
1180 for(c = 0; string[c] && string[c] == ' '; c++)
1181 ;
1182 memmove(output, string + c, strlen(string + c) + 1);
1183 return output;
1184 }
1185
1186 char * __ecereNameSpace__ecere__sys__TrimRSpaces(char * string, char * output)
1187 {
1188 int c;
1189
1190 for(c = strlen(string) - 1; c >= 0 && string[c] == ' '; c--)
1191 ;
1192 if(c >= 0)
1193 {
1194 memmove(output, string, c + 1);
1195 output[c + 1] = '\0';
1196 }
1197 else
1198 output[0] = '\0';
1199 return output;
1200 }
1201
1202 void __ecereNameSpace__ecere__sys__ChangeCh(char * string, char ch1, char ch2)
1203 {
1204 int c;
1205
1206 for(c = 0; string[c]; c++)
1207 if(string[c] == ch1)
1208 string[c] = ch2;
1209 }
1210
1211 void __ecereNameSpace__ecere__sys__RepeatCh(char * string, int count, char ch)
1212 {
1213 int c;
1214
1215 for(c = 0; c < count; c++)
1216 string[c] = ch;
1217 string[c] = (char)0;
1218 }
1219
1220 extern void *  memcpy(void * , const void * , unsigned int size);
1221
1222 char * __ecereNameSpace__ecere__sys__CopyString(char * string)
1223 {
1224 if(string)
1225 {
1226 int len = strlen(string);
1227 char * destination = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (len + 1));
1228
1229 if(destination)
1230 memcpy(destination, string, len + 1);
1231 return destination;
1232 }
1233 else
1234 return (((void *)0));
1235 }
1236
1237 unsigned int __ecereNameSpace__ecere__sys__GetString(char ** buffer, char * string, int max)
1238 {
1239 int c;
1240 char ch;
1241 unsigned int quoted = 0x0;
1242 unsigned int result = 0x1;
1243
1244 if(!* *buffer)
1245 {
1246 string[0] = (char)0;
1247 return 0x0;
1248 }
1249 for(; ; )
1250 {
1251 if(!(ch = *((*buffer)++)))
1252 result = 0x0;
1253 if((ch != '\n') && (ch != '\r') && (ch != ' ') && (ch != ',') && (ch != '\t'))
1254 break;
1255 if(!*(*buffer))
1256 break;
1257 }
1258 if(result)
1259 {
1260 for(c = 0; c < max - 1; c++)
1261 {
1262 if(!quoted && ((ch == '\n') || (ch == '\r') || (ch == ' ') || (ch == ',') || (ch == '\t')))
1263 {
1264 result = 0x1;
1265 break;
1266 }
1267 if(ch == '\"')
1268 {
1269 quoted ^= (unsigned int)1;
1270 c--;
1271 }
1272 else
1273 string[c] = ch;
1274 if(!(ch = *(*buffer)))
1275 {
1276 c++;
1277 break;
1278 }
1279 (*buffer)++;
1280 }
1281 string[c] = (char)0;
1282 }
1283 return result;
1284 }
1285
1286 extern int atoi(const char * );
1287
1288 int __ecereNameSpace__ecere__sys__GetValue(char ** buffer)
1289 {
1290 char string[20];
1291
1292 __ecereNameSpace__ecere__sys__GetString(buffer, string, 20);
1293 return atoi(string);
1294 }
1295
1296 extern unsigned long strtoul(const char *  nptr, char * *  endptr, int base);
1297
1298 unsigned int __ecereNameSpace__ecere__sys__GetHexValue(char ** buffer)
1299 {
1300 char string[20];
1301
1302 __ecereNameSpace__ecere__sys__GetString(buffer, string, 20);
1303 return strtoul(string, (((void *)0)), 16);
1304 }
1305
1306 char * __ecereNameSpace__ecere__sys__StripQuotes(char * string, char * output)
1307 {
1308 int len;
1309 char * src = (string[0] == '\"') ? (string + 1) : string;
1310
1311 memmove(output, src, strlen(src) + 1);
1312 len = strlen(output);
1313 if(len && output[len - 1] == '\"')
1314 output[len - 1] = '\0';
1315 return output;
1316 }
1317
1318 extern unsigned int isdigit(int);
1319
1320 double __ecereNameSpace__ecere__sys__FloatFromString(char * string)
1321 {
1322 int c, dig;
1323 float dec = (float)0, res = (float)0;
1324 int neg = 1;
1325 char ch;
1326
1327 for(c = 0; string[c]; c++)
1328 {
1329 ch = string[c];
1330 if(ch == ' ')
1331 continue;
1332 if(ch == '-')
1333 {
1334 if(neg == -1)
1335 break;
1336 neg = -1;
1337 }
1338 else if((ch == '.') && !dec)
1339 dec = (float)10;
1340 else if(isdigit(ch))
1341 {
1342 dig = ch - '0';
1343 if(dec)
1344 {
1345 res += (float)dig / dec;
1346 dec *= 10;
1347 }
1348 else
1349 res = res * (float)10 + (float)dig;
1350 }
1351 else
1352 break;
1353 }
1354 return (float)neg * res;
1355 }
1356
1357 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__DefinedExpression;
1358
1359 struct __ecereNameSpace__ecere__com__DefinedExpression;
1360
1361 extern struct __ecereNameSpace__ecere__com__DefinedExpression * __ecereNameSpace__ecere__com__eSystem_RegisterDefine(char *  name, char *  value, struct __ecereNameSpace__ecere__com__Instance * module, int declMode);
1362
1363 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__GlobalFunction;
1364
1365 struct __ecereNameSpace__ecere__com__GlobalFunction;
1366
1367 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);
1368
1369 void __ecereRegisterModule_String(struct __ecereNameSpace__ecere__com__Instance * module)
1370 {
1371 struct __ecereNameSpace__ecere__com__Class * class;
1372
1373 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::DIR_SEP", "(GetRuntimePlatform() == win32) ? '\\\\' : '/'", module, 4);
1374 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::DIR_SEPS", "(GetRuntimePlatform() == win32) ? \"\\\\\" : \"/\"", module, 4);
1375 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::MAX_F_STRING", "1025", module, 4);
1376 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::MAX_EXTENSION", "17", module, 4);
1377 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::MAX_FILENAME", "274", module, 4);
1378 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::MAX_DIRECTORY", "534", module, 4);
1379 __ecereNameSpace__ecere__com__eSystem_RegisterDefine("ecere::sys::MAX_LOCATION", "797", module, 4);
1380 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::GetExtension", "char * ecere::sys::GetExtension(char * string, char * output)", __ecereNameSpace__ecere__sys__GetExtension, module, 4);
1381 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::StripLastDirectory", "char * ecere::sys::StripLastDirectory(char * string, char * output)", __ecereNameSpace__ecere__sys__StripLastDirectory, module, 4);
1382 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::SplitDirectory", "char * ecere::sys::SplitDirectory(char * string, char * part, char * rest)", __ecereNameSpace__ecere__sys__SplitDirectory, module, 4);
1383 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::GetLastDirectory", "char * ecere::sys::GetLastDirectory(char * string, char * output)", __ecereNameSpace__ecere__sys__GetLastDirectory, module, 4);
1384 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::SplitArchivePath", "bool ecere::sys::SplitArchivePath(char * fileName, char * archiveName, char * * archiveFile)", __ecereNameSpace__ecere__sys__SplitArchivePath, module, 4);
1385 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::PathCatSlash", "char * ecere::sys::PathCatSlash(char * string, char * addedPath)", __ecereNameSpace__ecere__sys__PathCatSlash, module, 4);
1386 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::PathCat", "char * ecere::sys::PathCat(char * string, char * addedPath)", __ecereNameSpace__ecere__sys__PathCat, module, 4);
1387 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::MakePathRelative", "char * ecere::sys::MakePathRelative(char * path, char * to, char * destination)", __ecereNameSpace__ecere__sys__MakePathRelative, module, 4);
1388 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::StripExtension", "bool ecere::sys::StripExtension(char * string)", __ecereNameSpace__ecere__sys__StripExtension, module, 4);
1389 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::ChangeExtension", "char * ecere::sys::ChangeExtension(char * string, char * ext, char * output)", __ecereNameSpace__ecere__sys__ChangeExtension, module, 4);
1390 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::PrintSize", "void ecere::sys::PrintSize(char * string, uint size, int prec)", __ecereNameSpace__ecere__sys__PrintSize, module, 4);
1391 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::PrintBigSize", "void ecere::sys::PrintBigSize(char * string, double size, int prec)", __ecereNameSpace__ecere__sys__PrintBigSize, module, 4);
1392 __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);
1393 __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);
1394 __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);
1395 __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);
1396 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::TrimLSpaces", "char * ecere::sys::TrimLSpaces(char * string, char * output)", __ecereNameSpace__ecere__sys__TrimLSpaces, module, 4);
1397 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::TrimRSpaces", "char * ecere::sys::TrimRSpaces(char * string, char * output)", __ecereNameSpace__ecere__sys__TrimRSpaces, module, 4);
1398 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::ChangeCh", "void ecere::sys::ChangeCh(char * string, char ch1, char ch2)", __ecereNameSpace__ecere__sys__ChangeCh, module, 4);
1399 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::RepeatCh", "void ecere::sys::RepeatCh(char * string, int count, char ch)", __ecereNameSpace__ecere__sys__RepeatCh, module, 4);
1400 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::CopyString", "char * ecere::sys::CopyString(char * string)", __ecereNameSpace__ecere__sys__CopyString, module, 4);
1401 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::GetString", "bool ecere::sys::GetString(char * * buffer, char * string, int max)", __ecereNameSpace__ecere__sys__GetString, module, 4);
1402 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::GetValue", "int ecere::sys::GetValue(char * * buffer)", __ecereNameSpace__ecere__sys__GetValue, module, 4);
1403 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::GetHexValue", "uint ecere::sys::GetHexValue(char * * buffer)", __ecereNameSpace__ecere__sys__GetHexValue, module, 4);
1404 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::StripQuotes", "char * ecere::sys::StripQuotes(char * string, char * output)", __ecereNameSpace__ecere__sys__StripQuotes, module, 4);
1405 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ecere::sys::FloatFromString", "double ecere::sys::FloatFromString(char * string)", __ecereNameSpace__ecere__sys__FloatFromString, module, 4);
1406 }
1407
1408 void __ecereUnregisterModule_String(struct __ecereNameSpace__ecere__com__Instance * module)
1409 {
1410
1411 }
1412