lib/as3/pool.c

   1 /* pool.c
   2
   3    Routines for handling Flash2 AVM2 ABC contantpool entries.
   4
   5    Extension module for the rfxswf library.
   6    Part of the swftools package.
   7
   8    Copyright (c) 2008 Matthias Kramm <kramm@quiss.org>
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  23
  24 #include <assert.h>
  25 #include "pool.h"
  26
  27
  28 // ----------------------------- float ----------------------------------
  29
  30 void* float_clone(const void*_v) {
  31     if(_v==0)
  32         return 0;
  33     const double*v1=_v;
  34     double*v2 = malloc(sizeof(double));
  35     *v2 = *v1;
  36     return v2;
  37 }
  38 unsigned int float_hash(const void*_v) {
  39     if(!_v)
  40         return 0;
  41     const unsigned char*b=_v;
  42     unsigned int h=0;
  43     int t;
  44     for(t=0;t<8;t++)
  45         h = crc32_add_byte(h, b[t]);
  46     return h;
  47 }
  48 void float_destroy(void*_v) {
  49     double*v = (double*)_v;
  50     if(v)
  51         free(v);
  52 }
  53 char float_equals(const void*_v1, const void*_v2) {
  54     const double*v1=_v1;
  55     const double*v2=_v2;
  56     if(!v1 || !v2)
  57         return v1==v2;
  58     return *v1==*v2;
  59 }
  60
  61 type_t float_type = {
  62     dup: float_clone,
  63     hash: float_hash,
  64     free: float_destroy,
  65     equals: float_equals
  66 };
  67
  68 // ----------------------------- uint ----------------------------------
  69
  70 unsigned int undefined_uint = 0;
  71
  72 void*uint_clone(const void*_v) {
  73     if(!_v)
  74         return 0;
  75     const unsigned int*v1=_v;
  76     unsigned int*v2 = malloc(sizeof(unsigned int));
  77     *v2 = *v1;
  78     return v2;
  79 }
  80 unsigned int uint_hash(const void*_v) {
  81     if(!_v)
  82         return 0;
  83     const unsigned int*v=_v;
  84     return *v;
  85 }
  86 void uint_destroy(void*_v) {
  87     unsigned int*v = (unsigned int*)_v;
  88     if(v)
  89         free(v);
  90 }
  91 char uint_equals(const void*_v1, const void*_v2) {
  92     const unsigned int*v1=_v1;
  93     const unsigned int*v2=_v2;
  94     if(!v1 || !v2)
  95         return v1==v2;
  96     return *v1==*v2;
  97 }
  98
  99 type_t uint_type = {
 100     dup: (dup_func)uint_clone,
 101     hash: (hash_func)uint_hash,
 102     free: (free_func)uint_destroy,
 103     equals: (equals_func)uint_equals
 104 };
 105
 106 // ----------------------------- namespace ----------------------------------
 107
 108 unsigned int namespace_hash(namespace_t*n)
 109 {
 110     if(!n)
 111         return 0;
 112     unsigned int hash = 0;
 113     hash = crc32_add_byte(hash, n->access);
 114     hash = crc32_add_string(hash, n->name);
 115     return hash;
 116 }
 117
 118 unsigned char namespace_equals(const namespace_t*n1, const namespace_t*n2)
 119 {
 120     if(!n1 || !n2)
 121         return n1==n2;
 122     if(n1->access != n2->access)
 123         return 0;
 124     if(!(n1->name) != !(n2->name))
 125         return 0;
 126     if(n1->name && n2->name && strcmp(n1->name, n2->name))
 127         return 0;
 128     return 1;
 129 }
 130
 131 char*escape_string(const char*str)
 132 {
 133     if(!str)
 134         return strdup("NULL");
 135     int len=0;
 136     unsigned const char*s=str;
 137     while(*s) {
 138         if(*s<10) {
 139             len+=2; // \d
 140         } else if(*s<32) {
 141             len+=3; // \dd
 142         } else if(*s<127) {
 143             len++;
 144         } else {
 145             len+=4; // \xhh
 146         }
 147         s++;
 148     }
 149     char*newstr = malloc(len+1);
 150     char*dest = newstr;
 151     s=str;
 152     while(*s) {
 153         if(*s<9) {
 154             dest+=sprintf(dest, "\\%d", *s);
 155         } else if(*s<32) {
 156             if(*s==13)
 157                 dest+=sprintf(dest, "\\r");
 158             else if(*s==10)
 159                 dest+=sprintf(dest, "\\n");
 160             else if(*s==9)
 161                 dest+=sprintf(dest, "\\t");
 162             else
 163                 dest+=sprintf(dest, "\\%2o", *s);
 164         } else if(*s<127) {
 165             *dest++=*s;
 166         } else {
 167             dest+=sprintf(dest, "\\x%02x", *s);
 168         }
 169         s++;
 170     }
 171     *dest = 0;
 172     return newstr;
 173 }
 174
 175 char* namespace_tostring(namespace_t*ns)
 176 {
 177     if(!ns)
 178         return strdup("NULL");
 179     char*access = 0;
 180     U8 type = ns->access;
 181     access = access2str(type);
 182     char*s = escape_string(ns->name);
 183     char*string = (char*)malloc(strlen(access)+strlen(s)+7);
 184     if(!s)
 185         sprintf(string, "[%s]NULL", access, s);
 186     else if(!*s)
 187         sprintf(string, "[%s]\"\"", access, s);
 188     else
 189         sprintf(string, "[%s]", access, s);
 190
 191     free(s);
 192     return string;
 193 }
 194
 195 namespace_t* namespace_clone(namespace_t*other)
 196 {
 197     if(!other)
 198         return 0;
 199     NEW(namespace_t,n);
 200     n->access = other->access;
 201     n->name = other->name?strdup(other->name):0;
 202     return n;
 203 }
 204
 205 namespace_t* namespace_fromstring(const char*name)
 206 {
 207     namespace_t*ns = malloc(sizeof(namespace_t));
 208     memset(ns, 0, sizeof(namespace_t));
 209     if(name[0] == '[') {
 210         U8 access;
 211         char*n = strdup(name);
 212         char*bracket = strchr(n, ']');
 213         if(bracket) {
 214             *bracket = 0;
 215             char*a = n+1;
 216             name += (bracket-n)+1;
 217             if(!strcmp(a, "")) access=0x16;
 218             else if(!strcmp(a, "undefined")) access=0x08; // public??
 219             else if(!strcmp(a, "package")) access=0x16;
 220             else if(!strcmp(a, "public")) access=0x16;
 221             else if(!strcmp(a, "packageinternal")) access=0x17;
 222             else if(!strcmp(a, "protected")) access=0x18;
 223             else if(!strcmp(a, "explicit")) access=0x19;
 224             else if(!strcmp(a, "staticprotected")) access=0x1a;
 225             else if(!strcmp(a, "private")) access=0x05;
 226             else {
 227                 fprintf(stderr, "Undefined access level: [%s]\n", a);
 228                 free(n);
 229                 return 0;
 230             }
 231         }
 232         ns->access = access;
 233         ns->name = strdup(name);
 234         free(n);
 235         return ns;
 236     } else {
 237         ns->access = 0x16;
 238         ns->name = strdup(name);
 239         return ns;
 240     }
 241 }
 242
 243 namespace_t* namespace_new(U8 access, const char*name)
 244 {
 245     namespace_t*ns = malloc(sizeof(namespace_t));
 246     ns->access = access;
 247     /* not sure what namespaces with empty strings are good for, but they *do* exist */
 248     ns->name = name?strdup(name):0;
 249     return ns;
 250 }
 251 namespace_t* namespace_new_undefined(const char*name) {
 252     return namespace_new(0x08, name); // public?
 253 }
 254 namespace_t* namespace_new_package(const char*name) {
 255     return namespace_new(0x16 , name);
 256 }
 257 namespace_t* namespace_new_packageinternal(const char*name) {
 258     return namespace_new(0x17, name);
 259 }
 260 namespace_t* namespace_new_protected(const char*name) {
 261     return namespace_new(0x18, name);
 262 }
 263 namespace_t* namespace_new_explicit(const char*name) {
 264     return namespace_new(0x19, name);
 265 }
 266 namespace_t* namespace_new_staticprotected(const char*name) {
 267     return namespace_new(0x1a, name);
 268 }
 269 namespace_t* namespace_new_private(const char*name) {
 270     return namespace_new(0x05, name);
 271 }
 272
 273 void namespace_destroy(namespace_t*n)
 274 {
 275     if(n) {
 276         free(n->name);n->name=0;
 277         n->access=0x00;
 278         free(n);
 279     }
 280 }
 281
 282 type_t namespace_type = {
 283     dup: (dup_func)namespace_clone,
 284     hash: (hash_func)namespace_hash,
 285     free: (free_func)namespace_destroy,
 286     equals: (equals_func)namespace_equals
 287 };
 288
 289 // ---------------------------namespace sets --------------------------------
 290
 291 unsigned int namespace_set_hash(namespace_set_t*set)
 292 {
 293     if(!set)
 294         return 0;
 295     namespace_list_t*l = set->namespaces;
 296     unsigned int hash = 0;
 297     while(l) {
 298         hash = crc32_add_byte(hash, l->namespace->access);
 299         hash = crc32_add_string(hash, l->namespace->name);
 300         l = l->next;
 301     }
 302     return hash;
 303 }
 304
 305 int namespace_set_equals(namespace_set_t*m1, namespace_set_t*m2)
 306 {
 307     if(!m1 || !m2)
 308         return m1==m2;
 309     namespace_list_t*l1 = m1->namespaces;
 310     namespace_list_t*l2 = m2->namespaces;
 311     while(l1 && l2) {
 312         if(l1->namespace->access != l2->namespace->access)
 313             return 0;
 314         if(!(l1->namespace->name) != !(l2->namespace->name))
 315             return 0;
 316         if(l1->namespace->name && l2->namespace->name && strcmp(l1->namespace->name, l2->namespace->name))
 317             return 0;
 318         l1 = l1->next;
 319         l2 = l2->next;
 320     }
 321     if(l1||l2)
 322         return 0;
 323     return 1;
 324 }
 325
 326 namespace_set_t* namespace_set_clone(namespace_set_t*other)
 327 {
 328     if(!other)
 329         return 0;
 330     NEW(namespace_set_t,set);
 331     set->namespaces = list_new();
 332     namespace_list_t*l = other->namespaces;
 333     while(l) {
 334         list_append(set->namespaces, namespace_clone(l->namespace));
 335         l = l->next;
 336     }
 337     return set;
 338 }
 339 namespace_set_t* namespace_set_new()
 340 {
 341     NEW(namespace_set_t,set);
 342     set->namespaces = list_new();
 343     return set;
 344 }
 345 char* namespace_set_tostring(namespace_set_t*set)
 346 {
 347     if(!set)
 348         return strdup("NULL");
 349     /* TODO: is the order of the namespaces important (does it
 350        change the lookup order?). E.g. flex freely shuffles namespaces
 351        around.
 352        If the order is not important, we can optimize constant pools by sorting
 353        the namespaces.
 354     */
 355     int l = 0;
 356     namespace_list_t*lns = set->namespaces;
 357     while(lns) {
 358         char*s = namespace_tostring(lns->namespace);
 359         l += strlen(s)+1;
 360         free(s);
 361         lns = lns->next;
 362     }
 363     char*desc = malloc(l+16);
 364     strcpy(desc, "{");
 365     lns = set->namespaces;
 366     while(lns) {
 367         char*s = namespace_tostring(lns->namespace);
 368         strcat(desc, s);
 369         free(s);
 370         lns = lns->next;
 371         if(lns)
 372             strcat(desc, ",");
 373     }
 374     strcat(desc, "}");
 375     return desc;
 376 }
 377
 378 void namespace_set_destroy(namespace_set_t*set)
 379 {
 380     if(set) {
 381         namespace_list_t*l = set->namespaces;
 382         while(l) {
 383             namespace_destroy(l->namespace);l->namespace=0;
 384             l = l->next;
 385         }
 386         list_free(set->namespaces);
 387         free(set);
 388     }
 389 }
 390
 391 type_t namespace_set_type = {
 392     dup: (dup_func)namespace_set_clone,
 393     hash: (hash_func)namespace_set_hash,
 394     free: (free_func)namespace_set_destroy,
 395     equals: (equals_func)namespace_set_equals
 396 };
 397
 398 // ----------------------------- multiname ----------------------------------
 399
 400 unsigned int multiname_hash(multiname_t*m)
 401 {
 402     if(!m)
 403         return 0;
 404     unsigned int hash = crc32_add_byte(0, m->type);
 405     if(m->name) {
 406         hash = crc32_add_string(hash, m->name);
 407     }
 408     if(m->ns) {
 409         hash = crc32_add_byte(hash, m->ns->access);
 410         hash = crc32_add_string(hash, m->ns->name);
 411     }
 412     if(m->namespace_set) {
 413         namespace_list_t*l = m->namespace_set->namespaces;
 414         while(l) {
 415             hash = crc32_add_byte(hash, l->namespace->access);
 416             hash = crc32_add_string(hash, l->namespace->name);
 417             l = l->next;
 418         }
 419     }
 420     return hash;
 421 }
 422
 423 int multiname_equals(multiname_t*m1, multiname_t*m2)
 424 {
 425     if(!m1 || !m2)
 426         return m1==m2;
 427     if(m1->type!=m2->type)
 428         return 0;
 429
 430     if((!m1->name) != (!m2->name))
 431         return 0;
 432     if((!m1->ns) != (!m2->ns))
 433         return 0;
 434     if((!m1->namespace_set) != (!m2->namespace_set))
 435         return 0;
 436
 437     if(m1->name && m2->name && strcmp(m1->name,m2->name))
 438         return 0;
 439     if(m1->ns && m2->ns) {
 440         if(!namespace_equals(m1->ns, m2->ns))
 441             return 0;
 442     }
 443     if(m1->namespace_set && m2->namespace_set) {
 444         if(!namespace_set_equals(m1->namespace_set, m2->namespace_set))
 445             return 0;
 446     }
 447     return 1;
 448 }
 449
 450 multiname_t* multiname_new(namespace_t*ns, const char*name)
 451 {
 452     NEW(multiname_t,m);
 453     m->type = QNAME;
 454     if(!ns) {
 455         m->ns = namespace_new_packageinternal("");
 456     } else {
 457         m->ns = namespace_clone(ns);
 458     }
 459     m->name = strdup(name);
 460     return m;
 461 }
 462
 463 multiname_t* multiname_clone(multiname_t*other)
 464 {
 465     if(!other)
 466         return 0;
 467     NEW(multiname_t,m);
 468     m->type = other->type;
 469     if(other->ns)
 470         m->ns = namespace_clone(other->ns);
 471     if(other->namespace_set)
 472         m->namespace_set = namespace_set_clone(other->namespace_set);
 473     if(other->name)
 474         m->name = strdup(other->name);
 475     return m;
 476 }
 477
 478
 479 char* access2str(int type)
 480 {
 481     if(type==0x08) return "namespace";
 482     else if(type==0x16) return "public";
 483     else if(type==0x17) return "packageinternal";
 484     else if(type==0x18) return "protected";
 485     else if(type==0x19) return "explicit";
 486     else if(type==0x1A) return "staticprotected";
 487     else if(type==0x05) return "private";
 488     else {
 489         fprintf(stderr, "Undefined access type %02x\n", type);
 490         return "undefined";
 491     }
 492 }
 493
 494
 495 char multiname_late_namespace(multiname_t*m)
 496 {
 497     if(!m)
 498         return 0;
 499     return (m->type==RTQNAME || m->type==RTQNAMEA ||
 500             m->type==RTQNAMEL || m->type==RTQNAMELA);
 501 }
 502
 503 char multiname_late_name(multiname_t*m)
 504 {
 505     if(!m)
 506         return 0;
 507     return m->type==RTQNAMEL || m->type==RTQNAMELA ||
 508            m->type==MULTINAMEL || m->type==MULTINAMELA;
 509 }
 510
 511 char* multiname_tostring(multiname_t*m)
 512 {
 513     char*mname = 0;
 514     if(!m)
 515         return strdup("NULL");
 516     if(m->type==0xff)
 517         return strdup("--<MULTINAME 0xff>--");
 518
 519     char*name = m->name?escape_string(m->name):strdup("*");
 520     int namelen = strlen(name);
 521
 522     if(m->type==QNAME || m->type==QNAMEA) {
 523         char*nsname = escape_string(m->ns->name);
 524         mname = malloc(strlen(nsname)+namelen+32);
 525         strcpy(mname, "<q");
 526         if(m->type == QNAMEA)
 527             strcat(mname, ",attr");
 528         strcat(mname, ">[");
 529         strcat(mname,access2str(m->ns->access));
 530         strcat(mname, "]");
 531         strcat(mname, nsname);
 532         free(nsname);
 533         strcat(mname, "::");
 534         strcat(mname, name);
 535     } else if(m->type==RTQNAME || m->type==RTQNAMEA) {
 536         mname = malloc(namelen+32);
 537         strcpy(mname, "<rt");
 538         if(m->type == RTQNAMEA)
 539             strcat(mname, ",attr");
 540         strcat(mname, ">");
 541         strcat(mname, name);
 542     } else if(m->type==RTQNAMEL) {
 543         mname = strdup("<rt,l>");
 544     } else if(m->type==RTQNAMELA) {
 545         mname = strdup("<rt,l,attr>");
 546     } else if(m->type==MULTINAME || m->type==MULTINAMEA) {
 547         char*s = namespace_set_tostring(m->namespace_set);
 548         mname = malloc(strlen(s)+namelen+16);
 549         if(m->type == MULTINAME)
 550             strcpy(mname,"<multi>");
 551         else //MULTINAMEA
 552             strcpy(mname,"<multi,attr>");
 553         strcat(mname, s);
 554         strcat(mname, "::");
 555         strcat(mname, name);
 556         free(s);
 557     } else if(m->type==MULTINAMEL || m->type==MULTINAMELA) {
 558         char*s = namespace_set_tostring(m->namespace_set);
 559         mname = malloc(strlen(s)+16);
 560         if(m->type == MULTINAMEL)
 561             strcpy(mname,"<l,multi>");
 562         else //MULTINAMELA
 563             strcpy(mname,"<l,multi,attr>");
 564         strcat(mname,s);
 565         free(s);
 566     } else {
 567         fprintf(stderr, "Invalid multiname type: %02x\n", m->type);
 568     }
 569     free(name);
 570     return mname;
 571 }
 572
 573 multiname_t* multiname_fromstring(const char*name2)
 574 {
 575     if(!name2)
 576         return 0;
 577     char*n = strdup(name2);
 578     char*p = strstr(n, "::");
 579     char*namespace=0,*name=0;
 580     if(!p) {
 581         if(strchr(n, ':')) {
 582             fprintf(stderr, "Error: single ':' in name\n");
 583         }
 584         namespace = "";
 585         name = n;
 586     } else {
 587         *p = 0;
 588         namespace = n;
 589         name = p+2;
 590         if(strchr(namespace, ':')) {
 591             fprintf(stderr, "Error: single ':' in namespace\n");
 592         }
 593         if(strchr(name, ':')) {
 594             fprintf(stderr, "Error: single ':' in qualified name\n");
 595         }
 596     }
 597
 598     multiname_t*m = malloc(sizeof(multiname_t));
 599     memset(m, 0, sizeof(multiname_t));
 600     m->type = QNAME;
 601     m->namespace_set = 0;
 602     m->ns = namespace_fromstring(namespace);
 603     m->name = name?strdup(name):0;
 604     free(n);
 605     return m;
 606 }
 607
 608 void multiname_destroy(multiname_t*m)
 609 {
 610     if(m) {
 611         if(m->name) {
 612             free((void*)m->name);m->name = 0;
 613         }
 614         if(m->ns) {
 615             namespace_destroy(m->ns);m->ns = 0;
 616         }
 617         if(m->namespace_set) {
 618             namespace_set_destroy(m->namespace_set);m->namespace_set = 0;
 619         }
 620         m->type=0;
 621         free(m);
 622     }
 623 }
 624
 625 type_t multiname_type = {
 626     dup: (dup_func)multiname_clone,
 627     hash: (hash_func)multiname_hash,
 628     free: (free_func)multiname_destroy,
 629     equals: (equals_func)multiname_equals
 630 };
 631
 632
 633 // ------------------------------- constants -------------------------------------
 634
 635 #define NS_TYPE(x) ((x) == 0x08 || (x) == 0x16 || (x) == 0x17 || (x) == 0x18 ||  \
 636                                    (x) == 0x19 || (x) == 0x1a || (x) == 0x05)
 637
 638 #define UNIQUE_CONSTANT(x) ((x) == CONSTANT_TRUE || (x) == CONSTANT_FALSE || (x) == CONSTANT_NULL || (x) == CONSTANT_UNDEFINED)
 639
 640 constant_t* constant_new_int(int i)
 641 {
 642     NEW(constant_t,c);
 643     c->i = i;
 644     c->type = CONSTANT_INT;
 645     return c;
 646 }
 647 constant_t* constant_new_uint(unsigned int u)
 648 {
 649     NEW(constant_t,c);
 650     c->u = u;
 651     c->type = CONSTANT_UINT;
 652     return c;
 653 }
 654 constant_t* constant_new_float(double f)
 655 {
 656     NEW(constant_t,c);
 657     c->f = f;
 658     c->type = CONSTANT_FLOAT;
 659     return c;
 660 }
 661 constant_t* constant_new_string(char*s)
 662 {
 663     NEW(constant_t,c);
 664     c->s = string_new4(s);
 665     c->type = CONSTANT_STRING;
 666     return c;
 667 }
 668 constant_t* constant_new_string2(const char*s, int len)
 669 {
 670     NEW(constant_t,c);
 671     c->s = string_new3(s, len);
 672     c->type = CONSTANT_STRING;
 673     return c;
 674 }
 675 constant_t* constant_new_namespace(namespace_t*ns)
 676 {
 677     NEW(constant_t,c);
 678     c->ns = namespace_clone(ns);
 679     c->type = ns->access;
 680     assert(NS_TYPE(c->type));
 681     return c;
 682 }
 683 constant_t* constant_new_true()
 684 {
 685     NEW(constant_t,c);
 686     c->type = CONSTANT_TRUE;
 687     return c;
 688 }
 689 constant_t* constant_new_false()
 690 {
 691     NEW(constant_t,c);
 692     c->type = CONSTANT_FALSE;
 693     return c;
 694 }
 695 constant_t* constant_new_null()
 696 {
 697     NEW(constant_t,c);
 698     c->type = CONSTANT_NULL;
 699     return c;
 700 }
 701 constant_t* constant_new_undefined()
 702 {
 703     NEW(constant_t,c);
 704     c->type = CONSTANT_UNDEFINED;
 705     return c;
 706 }
 707 constant_t* constant_fromindex(pool_t*pool, int index, int type)
 708 {
 709     if(!index) {
 710         /* even for nonvalued constants (like TRUE/FALSE etc.), a nonzero
 711            index is present to indicate that a type is coming */
 712         return 0;
 713     }
 714     NEW(constant_t,c);
 715     c->type = type;
 716     if(NS_TYPE(c->type)) {
 717         c->ns = namespace_clone(pool_lookup_namespace(pool, index));
 718     } else if(c->type == CONSTANT_INT) {
 719         c->i = pool_lookup_int(pool, index);
 720     } else if(c->type == CONSTANT_UINT) {
 721         c->u = pool_lookup_uint(pool, index);
 722     } else if(c->type == CONSTANT_FLOAT) {
 723         c->f = pool_lookup_float(pool, index);
 724     } else if(c->type == CONSTANT_STRING) {
 725         string_t s = pool_lookup_string2(pool, index);
 726         c->s = string_dup3(&s);
 727     } else if(UNIQUE_CONSTANT(c->type)) {
 728         // ok
 729     } else {
 730         fprintf(stderr, "invalid constant type %02x\n", c->type);
 731     }
 732     return c;
 733 }
 734 char* constant_tostring(constant_t*c)
 735 {
 736     if(!c)
 737         return strdup("NULL");
 738     char buf[32];
 739     if(NS_TYPE(c->type)) {
 740         return namespace_tostring(c->ns);
 741     } else if(c->type == CONSTANT_INT) {
 742         sprintf(buf, "%d", c->i);
 743         return strdup(buf);
 744     } else if(c->type == CONSTANT_UINT) {
 745         sprintf(buf, "%u", c->u);
 746         return strdup(buf);
 747     } else if(c->type == CONSTANT_FLOAT) {
 748         char buf[1024];
 749         sprintf(buf, "%f", c->f);
 750         return strdup(buf);
 751     } else if(c->type == CONSTANT_STRING) {
 752         /* should we escape the string? \0 bytes won't be printed */
 753         return strdup_n(c->s->str,c->s->len);
 754     } else if(c->type == CONSTANT_TRUE) {
 755         return strdup("true");
 756     } else if(c->type == CONSTANT_FALSE) {
 757         return strdup("false");
 758     } else if(c->type == CONSTANT_NULL) {
 759         return strdup("null");
 760     } else if(c->type == CONSTANT_UNDEFINED) {
 761         return strdup("undefined");
 762     } else {
 763         fprintf(stderr, "invalid constant type %02x\n", c->type);
 764         return 0;
 765     }
 766 }
 767 char constant_has_index(constant_t*c)
 768 {
 769     if(!c)
 770         return 0;
 771     return !UNIQUE_CONSTANT(c->type);
 772 }
 773 int constant_get_index(pool_t*pool, constant_t*c)
 774 {
 775     if(!c)
 776         return 0;
 777     if(NS_TYPE(c->type)) {
 778         assert(c->ns);
 779         /*if(c->type!=c->ns->access) {
 780             printf("%02x<->%02x\n", c->type, c->ns->access);
 781         }*/
 782         assert(c->type == c->ns->access);
 783         return pool_register_namespace(pool, c->ns);
 784     } else if(c->type == CONSTANT_INT) {
 785         return pool_register_int(pool, c->i);
 786     } else if(c->type == CONSTANT_UINT) {
 787         return pool_register_uint(pool, c->u);
 788     } else if(c->type == CONSTANT_FLOAT) {
 789         return pool_register_float(pool, c->f);
 790     } else if(c->type == CONSTANT_STRING) {
 791         return pool_register_string2(pool, c->s);
 792     } else if(!constant_has_index(c)) {
 793         return 1;
 794     } else {
 795         fprintf(stderr, "invalid constant type %02x\n", c->type);
 796         return 0;
 797     }
 798 }
 799 void constant_free(constant_t*c)
 800 {
 801     if(!c)
 802         return;
 803     if(c->type == CONSTANT_STRING) {
 804         string_free(c->s);
 805     } else if (NS_TYPE(c->type)) {
 806         namespace_destroy(c->ns);c->ns=0;
 807     }
 808     free(c);
 809 }
 810 // ------------------------------- pool -------------------------------------
 811
 812 int pool_register_uint(pool_t*p, unsigned int i)
 813 {
 814     int pos = array_append_if_new(p->x_uints, &i, 0);
 815     assert(pos!=0);
 816     return pos;
 817 }
 818 int pool_register_int(pool_t*p, int i)
 819 {
 820     int pos = array_append_if_new(p->x_ints, &i, 0);
 821     assert(pos!=0);
 822     return pos;
 823 }
 824 int pool_register_float(pool_t*p, double d)
 825 {
 826     int pos = array_append_if_new(p->x_floats, &d, 0);
 827     assert(pos!=0);
 828     return pos;
 829 }
 830 int pool_register_string(pool_t*pool, const char*str)
 831 {
 832     if(!str) return 0;
 833     string_t s = string_new2(str);
 834     int pos = array_append_if_new(pool->x_strings, &s, 0);
 835     assert(pos!=0);
 836     return pos;
 837 }
 838 int pool_register_string2(pool_t*pool, string_t*s)
 839 {
 840     if(!s || !s->str) return 0;
 841     int pos = array_append_if_new(pool->x_strings, s, 0);
 842     assert(pos!=0);
 843     return pos;
 844 }
 845 int pool_register_namespace(pool_t*pool, namespace_t*ns)
 846 {
 847     if(!ns) return 0;
 848     int pos = array_append_if_new(pool->x_namespaces, ns, 0);
 849     assert(pos!=0);
 850     return pos;
 851 }
 852 int pool_register_namespace_set(pool_t*pool, namespace_set_t*set)
 853 {
 854     if(!set) return 0;
 855     int pos = array_append_if_new(pool->x_namespace_sets, set, 0);
 856     assert(pos!=0);
 857     return pos;
 858 }
 859 int pool_register_multiname(pool_t*pool, multiname_t*n)
 860 {
 861     if(!n) return 0;
 862     int pos = array_append_if_new(pool->x_multinames, n, 0);
 863     assert(pos!=0);
 864     return pos;
 865 }
 866 int pool_register_multiname2(pool_t*pool, char*name)
 867 {
 868     if(!name) return 0;
 869     multiname_t*n = multiname_fromstring(name);
 870     int pos = array_append_if_new(pool->x_multinames, n, 0);
 871     multiname_destroy(n);
 872     assert(pos!=0);
 873     return pos;
 874 }
 875
 876
 877 int pool_find_uint(pool_t*pool, unsigned int x)
 878 {
 879     int i = array_find(pool->x_uints, &x);
 880     if(i<=0) {
 881         fprintf(stderr, "Couldn't find uint \"%d\" in constant pool\n", x);
 882         return 0;
 883     }
 884     return i;
 885 }
 886 int pool_find_int(pool_t*pool, int x)
 887 {
 888     int i = array_find(pool->x_ints, &x);
 889     if(i<=0) {
 890         fprintf(stderr, "Couldn't find int \"%d\" in constant pool\n", x);
 891         return 0;
 892     }
 893     return i;
 894 }
 895 int pool_find_float(pool_t*pool, double x)
 896 {
 897     int i = array_find(pool->x_ints, &x);
 898     if(i<=0) {
 899         fprintf(stderr, "Couldn't find int \"%d\" in constant pool\n", x);
 900         return 0;
 901     }
 902     return i;
 903 }
 904 int pool_find_namespace(pool_t*pool, namespace_t*ns)
 905 {
 906     if(!ns)
 907         return 0;
 908     int i = array_find(pool->x_namespaces, ns);
 909     if(i<=0) {
 910         char*s = namespace_tostring(ns);
 911         fprintf(stderr, "Couldn't find namespace \"%s\" %08x in constant pool\n", s, ns);
 912         free(s);
 913         return 0;
 914     }
 915     return i;
 916 }
 917 int pool_find_namespace_set(pool_t*pool, namespace_set_t*set)
 918 {
 919     if(!set)
 920         return 0;
 921     int i = array_find(pool->x_namespace_sets, set);
 922     if(i<=0) {
 923         char*s = namespace_set_tostring(set);
 924         fprintf(stderr, "Couldn't find namespace_set \"%s\" in constant pool\n", s);
 925         free(s);
 926         return 0;
 927     }
 928     return i;
 929 }
 930 int pool_find_string(pool_t*pool, const char*str)
 931 {
 932     if(!str)
 933         return 0;
 934     string_t s = string_new2(str);
 935     int i = array_find(pool->x_strings, &s);
 936     if(i<=0) {
 937         fprintf(stderr, "Couldn't find string \"%s\" in constant pool\n", s);
 938         return 0;
 939     }
 940     return i;
 941 }
 942 int pool_find_multiname(pool_t*pool, multiname_t*name)
 943 {
 944     if(!name)
 945         return 0;
 946     int i = array_find(pool->x_multinames, name);
 947     if(i<=0) {
 948         char*s = multiname_tostring(name);
 949         fprintf(stderr, "Couldn't find multiname \"%s\" in constant pool\n", s);
 950         free(s);
 951         return 0;
 952     }
 953     return i;
 954 }
 955
 956 int pool_lookup_int(pool_t*pool, int i)
 957 {
 958     if(!i) return 0;
 959     return *(int*)array_getkey(pool->x_ints, i);
 960 }
 961 unsigned int pool_lookup_uint(pool_t*pool, int i)
 962 {
 963     if(!i) return 0;
 964     return *(unsigned int*)array_getkey(pool->x_uints, i);
 965 }
 966 double pool_lookup_float(pool_t*pool, int i)
 967 {
 968     if(!i) return __builtin_nan("");
 969     return *(double*)array_getkey(pool->x_floats, i);
 970 }
 971 const char*pool_lookup_string(pool_t*pool, int i)
 972 {
 973     string_t*s = array_getkey(pool->x_strings, i);
 974     if(!s) return 0;
 975     return s->str;
 976 }
 977 string_t pool_lookup_string2(pool_t*pool, int i)
 978 {
 979     string_t*s = array_getkey(pool->x_strings, i);
 980     return *s;
 981 }
 982 namespace_t*pool_lookup_namespace(pool_t*pool, int i)
 983 {
 984     return (namespace_t*)array_getkey(pool->x_namespaces, i);
 985 }
 986 namespace_set_t*pool_lookup_namespace_set(pool_t*pool, int i)
 987 {
 988     return (namespace_set_t*)array_getkey(pool->x_namespace_sets, i);
 989 }
 990 multiname_t*pool_lookup_multiname(pool_t*pool, int i)
 991 {
 992     return (multiname_t*)array_getkey(pool->x_multinames, i);
 993 }
 994
 995 pool_t*pool_new()
 996 {
 997     NEW(pool_t, p);
 998
 999     p->x_ints = array_new2(&uint_type);
1000     p->x_uints = array_new2(&uint_type);
1001     p->x_floats = array_new2(&float_type);
1002     p->x_strings = array_new2(&stringstruct_type);
1003     p->x_namespaces = array_new2(&namespace_type);
1004     p->x_namespace_sets = array_new2(&namespace_set_type);
1005     p->x_multinames = array_new2(&multiname_type);
1006
1007     /* add a zero-index entry in each list */
1008
1009     array_append(p->x_ints, 0, 0);
1010     array_append(p->x_uints, 0, 0);
1011     array_append(p->x_floats, 0, 0);
1012     array_append(p->x_strings, 0, 0);
1013     array_append(p->x_namespaces, 0, 0);
1014     array_append(p->x_namespace_sets, 0, 0);
1015     array_append(p->x_multinames, 0, 0);
1016     return p;
1017 }
1018
1019 #define DEBUG if(0)
1020 //#define DEBUG
1021
1022 void pool_read(pool_t*pool, TAG*tag)
1023 {
1024     int num_ints = swf_GetU30(tag);
1025     DEBUG printf("%d ints\n", num_ints);
1026     int t;
1027     for(t=1;t<num_ints;t++) {
1028         S32 v = swf_GetABCS32(tag);
1029         DEBUG printf("int %d) %d\n", t, v);
1030         array_append(pool->x_ints, &v, 0);
1031     }
1032
1033     int num_uints = swf_GetU30(tag);
1034     DEBUG printf("%d uints\n", num_uints);
1035     for(t=1;t<num_uints;t++) {
1036         U32 v = swf_GetABCU32(tag);
1037         DEBUG printf("uint %d) %d\n", t, v);
1038         array_append(pool->x_uints, &v, 0);
1039     }
1040
1041     int num_floats = swf_GetU30(tag);
1042     DEBUG printf("%d floats\n", num_floats);
1043     for(t=1;t<num_floats;t++) {
1044         double d = swf_GetD64(tag);
1045         DEBUG printf("float %d) %f\n", t, d);
1046         array_append(pool->x_floats, &d, 0);
1047     }
1048
1049     int num_strings = swf_GetU30(tag);
1050     DEBUG printf("%d strings\n", num_strings);
1051     for(t=1;t<num_strings;t++) {
1052         int len = swf_GetU30(tag);
1053         string_t s = string_new(&tag->data[tag->pos], len);
1054         swf_GetBlock(tag, 0, len);
1055         array_append(pool->x_strings, &s, 0);
1056         DEBUG printf("%d) \"%s\"\n", t, ((string_t*)array_getkey(pool->x_strings, t))->str);
1057     }
1058     int num_namespaces = swf_GetU30(tag);
1059     DEBUG printf("%d namespaces\n", num_namespaces);
1060     for(t=1;t<num_namespaces;t++) {
1061         U8 type = swf_GetU8(tag);
1062         int namenr = swf_GetU30(tag);
1063         const char*name = 0;
1064         if(namenr)
1065             name = pool_lookup_string(pool, namenr);
1066         namespace_t*ns = namespace_new(type, name);
1067         array_append(pool->x_namespaces, ns, 0);
1068         DEBUG printf("%d) %02x \"%s\"\n", t, type, namespace_tostring(ns));
1069         namespace_destroy(ns);
1070     }
1071     int num_sets = swf_GetU30(tag);
1072     DEBUG printf("%d namespace sets\n", num_sets);
1073     for(t=1;t<num_sets;t++) {
1074         int count = swf_GetU30(tag);
1075         int s;
1076
1077         NEW(namespace_set_t, nsset);
1078         for(s=0;s<count;s++) {
1079             int nsnr = swf_GetU30(tag);
1080             if(!nsnr)
1081                 fprintf(stderr, "Zero entry in namespace set\n");
1082             namespace_t*ns = (namespace_t*)array_getkey(pool->x_namespaces, nsnr);
1083             list_append(nsset->namespaces, namespace_clone(ns));
1084         }
1085         array_append(pool->x_namespace_sets, nsset, 0);
1086         DEBUG printf("set %d) %s\n", t, namespace_set_tostring(nsset));
1087         namespace_set_destroy(nsset);
1088     }
1089
1090     int num_multinames = swf_GetU30(tag);
1091     DEBUG printf("%d multinames\n", num_multinames);
1092     for(t=1;t<num_multinames;t++) {
1093         multiname_t m;
1094         memset(&m, 0, sizeof(multiname_t));
1095         m.type = swf_GetU8(tag);
1096         if(m.type==0x07 || m.type==0x0d) {
1097             int namespace_index = swf_GetU30(tag);
1098             m.ns = (namespace_t*)array_getkey(pool->x_namespaces, namespace_index);
1099             int name_index = swf_GetU30(tag);
1100             if(name_index) // 0 = '*' (any)
1101                 m.name = pool_lookup_string(pool, name_index);
1102         } else if(m.type==0x0f || m.type==0x10) {
1103             int name_index = swf_GetU30(tag);
1104             if(name_index) // 0 = '*' (any name)
1105                 m.name = pool_lookup_string(pool, name_index);
1106         } else if(m.type==0x11 || m.type==0x12) {
1107         } else if(m.type==0x09 || m.type==0x0e) {
1108             int name_index = swf_GetU30(tag);
1109             int namespace_set_index = swf_GetU30(tag);
1110             if(name_index)
1111                 m.name = pool_lookup_string(pool, name_index);
1112             m.namespace_set = (namespace_set_t*)array_getkey(pool->x_namespace_sets, namespace_set_index);
1113         } else if(m.type==0x1b || m.type==0x1c) {
1114             int namespace_set_index = swf_GetU30(tag);
1115             m.namespace_set = (namespace_set_t*)array_getkey(pool->x_namespace_sets, namespace_set_index);
1116         } else {
1117             printf("can't parse type %d multinames yet\n", m.type);
1118         }
1119         DEBUG printf("multiname %d) %s\n", t, multiname_tostring(&m));
1120         array_append(pool->x_multinames, &m, 0);
1121     }
1122 }
1123
1124 void pool_dump(pool_t*pool, FILE*fo)
1125 {
1126     int t;
1127     fprintf(fo, "%d integers:\n", pool->x_ints->num);
1128     for(t=1;t<pool->x_ints->num;t++) {
1129         S32 val = *(int*)array_getkey(pool->x_ints, t);
1130         fprintf(fo, "%d) %d\n", t, val);
1131     }
1132     fprintf(fo, "%d integers:\n", pool->x_uints->num);
1133     for(t=1;t<pool->x_uints->num;t++) {
1134         U32 val = *(unsigned int*)array_getkey(pool->x_uints, t);
1135         fprintf(fo, "%d) %d\n", t, val);
1136     }
1137     fprintf(fo, "%d floats:\n", pool->x_floats->num);
1138     for(t=1;t<pool->x_floats->num;t++) {
1139         double d = pool_lookup_float(pool, t);
1140         fprintf(fo, "%d) %f\n", t, d);
1141     }
1142     fprintf(fo, "%d strings:\n", pool->x_strings->num);
1143     for(t=1;t<pool->x_strings->num;t++) {
1144         string_t str = pool_lookup_string2(pool, t);
1145         fprintf(fo, "%d) ", t);
1146         fwrite(str.str, str.len, 1, fo);
1147         fprintf(fo, "\n", t);
1148     }
1149     fprintf(fo, "%d namespaces:\n", pool->x_namespaces->num);
1150     for(t=1;t<pool->x_namespaces->num;t++) {
1151         namespace_t*ns= (namespace_t*)array_getkey(pool->x_namespaces, t);
1152         char*s = namespace_tostring(ns);
1153         fprintf(fo, "%d) %s\n", t, s);
1154         free(s);
1155     }
1156     fprintf(fo, "%d namespace sets:\n", pool->x_namespace_sets->num);
1157     for(t=1;t<pool->x_namespace_sets->num;t++) {
1158         namespace_set_t*set = (namespace_set_t*)array_getkey(pool->x_namespace_sets, t);
1159         char*s = namespace_set_tostring(set);
1160         fprintf(fo, "%d) %s\n", t, s);
1161         free(s);
1162     }
1163
1164     fprintf(fo, "%d multinames:\n", pool->x_multinames->num);
1165     for(t=1;t<pool->x_multinames->num;t++) {
1166         multiname_t*m = (multiname_t*)array_getkey(pool->x_multinames, t);
1167         char*s = multiname_tostring(m);
1168         fprintf(fo, "%d) %s\n", t, s);
1169         free(s);
1170     }
1171 }
1172
1173 void pool_write(pool_t*pool, TAG*tag)
1174 {
1175     int t;
1176
1177     /* make sure that all namespaces used by multinames / namespace sets
1178        and all strings used by namespaces exist */
1179
1180     for(t=1;t<pool->x_multinames->num;t++) {
1181         multiname_t*m = (multiname_t*)array_getkey(pool->x_multinames, t);
1182         if(m->ns) {
1183             pool_register_namespace(pool, m->ns);
1184         }
1185         if(m->namespace_set) {
1186             pool_register_namespace_set(pool, m->namespace_set);
1187         }
1188         if(m->name) {
1189             pool_register_string(pool, m->name);
1190         }
1191     }
1192     for(t=1;t<pool->x_namespace_sets->num;t++) {
1193         namespace_set_t*set = (namespace_set_t*)array_getkey(pool->x_namespace_sets, t);
1194         namespace_list_t*i = set->namespaces;
1195         while(i) {
1196             pool_register_namespace(pool, i->namespace);
1197             i = i->next;
1198         }
1199     }
1200     for(t=1;t<pool->x_namespaces->num;t++) {
1201         namespace_t*ns= (namespace_t*)array_getkey(pool->x_namespaces, t);
1202         /*  The spec says (page 22): "a value of zero denotes an empty string".
1203             However when actually using zero strings as empty namespaces, the
1204             flash player breaks.*/
1205         //if(ns->name && ns->name[0])
1206         pool_register_string(pool, ns->name);
1207     }
1208
1209     //pool_register_int(pool, 15);
1210     //pool_register_int(pool, 1);
1211     //pool_register_int(pool, 0);
1212
1213     /* write data */
1214     swf_SetU30(tag, pool->x_ints->num>1?pool->x_ints->num:0);
1215     for(t=1;t<pool->x_ints->num;t++) {
1216         S32 val = *(int*)array_getkey(pool->x_ints, t);
1217         swf_SetABCS32(tag, val);
1218     }
1219     swf_SetU30(tag, pool->x_uints->num>1?pool->x_uints->num:0);
1220     for(t=1;t<pool->x_uints->num;t++) {
1221         swf_SetABCU32(tag, *(unsigned int*)array_getkey(pool->x_uints, t));
1222     }
1223     swf_SetU30(tag, pool->x_floats->num>1?pool->x_floats->num:0);
1224     for(t=1;t<pool->x_floats->num;t++) {
1225         double d = pool_lookup_float(pool, t);
1226         swf_SetD64(tag, d);
1227     }
1228     swf_SetU30(tag, pool->x_strings->num>1?pool->x_strings->num:0);
1229     for(t=1;t<pool->x_strings->num;t++) {
1230         string_t str = pool_lookup_string2(pool, t);
1231         swf_SetU30String(tag, str.str, str.len);
1232     }
1233     swf_SetU30(tag, pool->x_namespaces->num>1?pool->x_namespaces->num:0);
1234     for(t=1;t<pool->x_namespaces->num;t++) {
1235         namespace_t*ns= (namespace_t*)array_getkey(pool->x_namespaces, t);
1236         swf_SetU8(tag, ns->access);
1237         const char*name = ns->name;
1238         int i = 0;
1239
1240         //if(name && name[0])
1241         i = pool_find_string(pool, name);
1242
1243         swf_SetU30(tag, i);
1244     }
1245     swf_SetU30(tag, pool->x_namespace_sets->num>1?pool->x_namespace_sets->num:0);
1246     for(t=1;t<pool->x_namespace_sets->num;t++) {
1247         namespace_set_t*set = (namespace_set_t*)array_getkey(pool->x_namespace_sets, t);
1248         namespace_list_t*i = set->namespaces;
1249         int len = list_length(i);
1250         swf_SetU30(tag, len);
1251         while(i) {
1252             int index = pool_find_namespace(pool, i->namespace);
1253             swf_SetU30(tag, index);
1254             i = i->next;
1255         }
1256     }
1257
1258     swf_SetU30(tag, pool->x_multinames->num>1?pool->x_multinames->num:0);
1259     for(t=1;t<pool->x_multinames->num;t++) {
1260         multiname_t*m = (multiname_t*)array_getkey(pool->x_multinames, t);
1261         swf_SetU8(tag, m->type);
1262
1263         if(m->ns) {
1264             assert(m->type==0x07 || m->type==0x0d);
1265             int i = pool_find_namespace(pool, m->ns);
1266             if(i<0) fprintf(stderr, "internal error: unregistered namespace %02x %s %s\n", m->ns->access, access2str(m->ns->access), m->ns->name);
1267             swf_SetU30(tag, i);
1268         } else {
1269             assert(m->type!=0x07 && m->type!=0x0d);
1270         }
1271         if(m->name) {
1272             assert(m->type==0x09 || m->type==0x0e || m->type==0x07 || m->type==0x0d || m->type==0x0f || m->type==0x10);
1273             int i = pool_find_string(pool, m->name);
1274             if(i<0) fprintf(stderr, "internal error: unregistered name\n");
1275             swf_SetU30(tag, i);
1276         } else {
1277             assert(m->type!=0x09 && m->type!=0x0e && m->type!=0x07 && m->type!=0x0d && m->type!=0x0f && m->type!=0x10);
1278         }
1279         if(m->namespace_set) {
1280             assert(m->type==0x09 || m->type==0x0e || m->type==0x1c || m->type==0x1b);
1281             int i = pool_find_namespace_set(pool, m->namespace_set);
1282             if(i<0) fprintf(stderr, "internal error: unregistered namespace set\n");
1283             swf_SetU30(tag, i);
1284         } else {
1285             assert(m->type!=0x09 && m->type!=0x0e && m->type!=0x1c && m->type!=0x1b);
1286         }
1287     }
1288 }
1289
1290
1291 void pool_destroy(pool_t*pool)
1292 {
1293     int t;
1294     array_free(pool->x_ints);
1295     array_free(pool->x_uints);
1296     array_free(pool->x_floats);
1297     array_free(pool->x_strings);
1298     array_free(pool->x_namespaces);
1299     array_free(pool->x_namespace_sets);
1300     array_free(pool->x_multinames);
1301     free(pool);
1302 }