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

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