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