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

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