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