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

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