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