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