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