lib/as3/mklib.c

   1 /* mklib.c
   2
   3    File to generate builtin.c
   4
   5    Copyright (c) 2008,2009 Matthias Kramm <kramm@quiss.org>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  20
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <unistd.h>
  24 #include <memory.h>
  25 #include "../rfxswf.h"
  26 #include "../os.h"
  27 #include "../q.h"
  28 #include "pool.h"
  29 #include "files.h"
  30 #include "tokenizer.h"
  31 #include "parser.tab.h"
  32 #include "parser.h"
  33 #include "import.h"
  34
  35 void fixstring(char*s)
  36 {
  37     char first=1;
  38     for(;*s;s++) {
  39         if(!((*s>='a' && *s<='z') || (*s>='A' && *s<='Z') ||
  40                     (*s>='0' && *s<='9' && !first))) {
  41             *s = '_';
  42         }
  43         first = 0;
  44     }
  45 }
  46
  47 static char* mkpid(const char*package)
  48 {
  49     char*id = malloc(strlen(package)+20);
  50     strcpy(id, "package_");
  51     if(!*package)
  52         strcat(id, "global");
  53     else
  54         strcat(id, package);
  55     fixstring(id);
  56     return id;
  57 }
  58 static char* mkcid(const char*package, const char*name)
  59 {
  60     char*id = malloc(strlen(package)+strlen(name)+10);
  61     strcpy(id, package);
  62     strcat(id, "_");
  63     strcat(id, name);
  64     fixstring(id);
  65     return id;
  66 }
  67 static char* mkptr2(const char*package, const char*name)
  68 {
  69     if(!package[0] && !strcmp(name, "void")) {
  70         return "&voidclass";
  71     }
  72     char*id = malloc(strlen(package)+strlen(name)+10);
  73     strcpy(id, "&");
  74     strcat(id, package);
  75     strcat(id, "_");
  76     strcat(id, name);
  77     fixstring(id+1);
  78     return id;
  79 }
  80 static char* mkid2(const char*cls, const char*member)
  81 {
  82     char*id = malloc(strlen(cls)+strlen(member)+10);
  83     strcpy(id, cls);
  84     strcat(id, "_");
  85     strcat(id, member);
  86     fixstring(id);
  87     return id;
  88 }
  89 #define mkid(s) ((s)?mkcid((s)->package, (s)->name):"0")
  90 #define mkptr(s) ((s)?mkptr2((s)->package, (s)->name):"0")
  91
  92 static array_t*tosort=0;
  93 static int compare_classes(const void*v1, const void*v2)
  94 {
  95     int x1 = *(int*)v1;
  96     int x2 = *(int*)v2;
  97     abc_class_t*c1 = array_getvalue(tosort, x1);
  98     abc_class_t*c2 = array_getvalue(tosort, x2);
  99     int i = strcmp(c1->classname->ns->name, c2->classname->ns->name);
 100     if(i)
 101         return i;
 102     return strcmp(c1->classname->name, c2->classname->name);
 103 }
 104
 105 static int compare_traits(const void*v1, const void*v2)
 106 {
 107     trait_t* x1 = *(trait_t**)v1;
 108     trait_t* x2 = *(trait_t**)v2;
 109     int i = strcmp(x1->name->ns->name, x2->name->ns->name);
 110     if(i)
 111         return i;
 112     return strcmp(x1->name->name, x2->name->name);
 113 }
 114
 115 dict_t* builtin_getclasses()
 116 {
 117     return dict_new2(&slotinfo_type);
 118 }
 119
 120 extern dict_t*registry_classes;
 121
 122 char*mktype(slotinfo_t*s)
 123 {
 124     if(s->kind == INFOTYPE_CLASS) {
 125         return "classinfo_t";
 126     } else if(s->kind == INFOTYPE_METHOD) {
 127         return "methodinfo_t";
 128     } else if(s->kind == INFOTYPE_VAR) {
 129         return "varinfo_t";
 130     }
 131     return "**ERROR**";
 132 }
 133
 134 void write_slotinfo(FILE*fi, slotinfo_t*s, char*id, char*prefix);
 135
 136 void write_slotinfo_decl(FILE*fi, slotinfo_t*s, char*prefix)
 137 {
 138     fprintf(fi, "%s", prefix);
 139     char*id = mkid(s);
 140     fprintf(fi, "static %s %s;\n", mktype(s), id);
 141
 142     if(s->kind == INFOTYPE_CLASS) {
 143         classinfo_t*c = (classinfo_t*)s;
 144         dict_t*d = &c->members;
 145         DICT_ITERATE_DATA(d, slotinfo_t*, s1) {
 146             fprintf(fi, "static %s %s;\n", mktype(s1), mkid2(id, s1->name));
 147         }
 148         DICT_ITERATE_DATA(d, slotinfo_t*, s2) {
 149             fprintf(fi, "static %s %s;\n", mktype(s2), mkid2(id, s2->name));
 150         }
 151     }
 152 }
 153 void write_initinfo(FILE*fi, slotinfo_t*s, char*prefix)
 154 {
 155     if(s->kind == INFOTYPE_CLASS) {
 156         classinfo_t*c = (classinfo_t*)s;
 157         char*id = mkid(c);
 158         dict_t*d1 = &c->members;
 159         dict_t*d2 = &c->static_members;
 160         fprintf(fi, "%s", prefix);
 161         fprintf(fi, "dict_init2(&%s.members, &memberinfo_type, %d);\n", id, d1->hashsize);
 162         fprintf(fi, "%s", prefix);
 163         fprintf(fi, "dict_init2(&%s.static_members, &memberinfo_type, %d);\n", id, d2->hashsize);
 164         int t;
 165         DICT_ITERATE_DATA(d1,slotinfo_t*,s1) {
 166            fprintf(fi, "%s", prefix);
 167            char*id2 = mkid2(id, s1->name);
 168            fprintf(fi, "dict_put(&%s.members, &%s, &%s);\n", id, id2, id2);
 169         }
 170         DICT_ITERATE_DATA(d2,slotinfo_t*,s2) {
 171            fprintf(fi, "%s", prefix);
 172            char*id2 = mkid2(id, s2->name);
 173            fprintf(fi, "dict_put(&%s.static_members, &%s, &%s);\n", id, id2, id2);
 174         }
 175     }
 176 }
 177
 178 void write_constant(FILE*fi, constant_t*value, char*id, char*prefix)
 179 {
 180     if(NS_TYPE(value->type)) {
 181         fprintf(fi, "%s", prefix);
 182         fprintf(fi, "static namespace_t %s_constant_ns = {0x%02x, \"%s\"};\n", id, value->ns->access, value->ns->name);
 183     } else if(value->type == CONSTANT_STRING) {
 184         fprintf(fi, "%s", prefix);
 185         fprintf(fi, "static string_t %s_constant_s = {\"%s\", %d};\n", id, value->s->str, value->s->len);
 186     }
 187     fprintf(fi, "%s", prefix);
 188     fprintf(fi, "static constant_t %s_constant = ", id);
 189     fprintf(fi, "{type: %d", value->type);
 190     if(NS_TYPE(value->type)) {
 191         fprintf(fi, ", &%s_constant_ns", id);
 192     } else if(value->type == CONSTANT_INT) {
 193         fprintf(fi, ",i: %d,", value->type);
 194     } else if(value->type == CONSTANT_UINT) {
 195         fprintf(fi, ",u: %u", value->u);
 196     } else if(value->type == CONSTANT_FLOAT) {
 197         if(!isnan(value->f) && !isinf(value->f))
 198             fprintf(fi, ", %f", value->f);
 199     } else if(value->type == CONSTANT_STRING) {
 200         fprintf(fi, ", &%s_constant_s", id);
 201     }
 202     fprintf(fi, "};\n");
 203 }
 204
 205 void write_slotinfo(FILE*fi, slotinfo_t*s, char*id, char*prefix)
 206 {
 207     if(s->kind == INFOTYPE_VAR) {
 208         varinfo_t*v = (varinfo_t*)s;
 209         if(v->value) {
 210             write_constant(fi, v->value, id, prefix);
 211         }
 212     }
 213     fprintf(fi, "%s", prefix);
 214     fprintf(fi, "static %s %s = {", mktype(s), id);
 215     fprintf(fi, "0x%02x, 0x%02x, 0x%02x, 0x%02x, ", s->kind, s->subtype, s->flags, s->access);
 216     if(s->package)
 217         fprintf(fi, "\"%s\", ", s->package);
 218     else
 219         fprintf(fi, "0, ");
 220
 221     if(s->name)
 222         fprintf(fi, "\"%s\", ", s->name);
 223     else
 224         fprintf(fi, "0, ");
 225
 226     fprintf(fi, "%d, ", s->slot);
 227
 228     if(s->kind == INFOTYPE_CLASS) {
 229         classinfo_t*c = (classinfo_t*)s;
 230         fprintf(fi, "%s, ", mkptr(c->superclass));
 231         fprintf(fi, "interfaces: {");
 232         int t;
 233         for(t=0;c->interfaces[t];t++) {
 234             fprintf(fi, "%s", mkptr(c->interfaces[t]));
 235             fprintf(fi, ", ");
 236         }
 237         fprintf(fi, "0}};\n");
 238     }
 239     if(s->kind == INFOTYPE_METHOD) {
 240         methodinfo_t*m = (methodinfo_t*)s;
 241         fprintf(fi, "%s, ", mkptr(m->return_type));
 242         fprintf(fi, "%s, ", mkptr(m->parent));
 243         fprintf(fi, "0"); // params TODO
 244         fprintf(fi, "};\n");
 245     }
 246     if(s->kind == INFOTYPE_VAR) {
 247         varinfo_t*m = (varinfo_t*)s;
 248         fprintf(fi, "%s, ", mkptr(m->type));
 249         fprintf(fi, "%s, ", mkptr(m->parent));
 250         if(!m->value) fprintf(fi, "0");
 251         else          fprintf(fi, "&%s_constant", id);
 252         fprintf(fi, "};\n");
 253     }
 254
 255     if(s->kind == INFOTYPE_CLASS) {
 256         classinfo_t*c = (classinfo_t*)s;
 257         dict_t*d = &c->members;
 258         DICT_ITERATE_DATA(d, slotinfo_t*, s1) {
 259             write_slotinfo(fi, s1, mkid2(id,s1->name), prefix);
 260         }
 261         d = &c->static_members;
 262         DICT_ITERATE_DATA(d, slotinfo_t*, s2) {
 263             write_slotinfo(fi, s2, mkid2(id,s2->name), prefix);
 264         }
 265     }
 266 }
 267
 268 int main()
 269 {
 270     registry_classes = builtin_getclasses();
 271
 272     as3_import_abc("builtin.abc");
 273     as3_import_abc("playerglobal.abc");
 274
 275     FILE*fi = fopen("builtin.c", "wb");
 276
 277     int t;
 278     int pass;
 279
 280
 281     for(pass=1;pass<=3;pass++) {
 282         if(pass==1) {
 283             fprintf(fi, "#include \"builtin.h\"\n");
 284             fprintf(fi, "\n");
 285         }
 286         if(pass==3) {
 287             fprintf(fi, "dict_t* builtin_getclasses()\n");
 288             fprintf(fi, "{\n");
 289             fprintf(fi, "    dict_t*d = dict_new2(&slotinfo_type);\n");
 290         }
 291         for(t=0;t<registry_classes->hashsize;t++) {
 292             dictentry_t*l = registry_classes->slots[t];
 293             while(l) {
 294                 slotinfo_t*s = (slotinfo_t*)l->key;
 295                 //printf("%08x %s %s\n", s, s->package, s->name);
 296                 char*id = mkid(s);
 297                 if(pass==1) {
 298                     write_slotinfo_decl(fi, s, "");
 299                 }
 300                 if(pass==2) {
 301                     write_slotinfo(fi, s, mkid(s), "");
 302                 }
 303                 if(pass==3) {
 304                     fprintf(fi, "    dict_put(d, &%s, &%s);\n", id, id);
 305                     write_initinfo(fi, s, "    ");
 306                 }
 307                 l = l->next;
 308             }
 309         }
 310     }
 311     fprintf(fi, "    _NaN_constant.f =  __builtin_nan(\"\");\n");
 312     fprintf(fi, "    _Infinity_constant.f = __builtin_inf();\n");
 313     fprintf(fi, "    return d;\n");
 314     fprintf(fi, "}\n");
 315     return 0;
 316 }