From 700f136a477a84d5a13fb1f8d6cb51f81e158328 Mon Sep 17 00:00:00 2001
From: kramm <kramm>
Date: Tue, 23 Dec 2008 18:47:28 +0000
Subject: [PATCH] renamed class_signature to classinfo

---
 lib/as3/registry.c  |   60 +++++++++++++++++++++++++--------------------------
 lib/as3/registry.h  |   56 ++++++++++++++++++++++++++---------------------
 lib/as3/tokenizer.h |   17 +++++++++------
 3 files changed, 72 insertions(+), 61 deletions(-)

diff --git a/lib/as3/registry.c b/lib/as3/registry.c
index 1e2482b..b43a5dd 100644
--- a/lib/as3/registry.c
+++ b/lib/as3/registry.c
@@ -30,7 +30,7 @@ static dict_t*classes=0;
 
 // ----------------------- class signature ------------------------------
 
-char class_signature_equals(class_signature_t*c1, class_signature_t*c2)
+char classinfo_equals(classinfo_t*c1, classinfo_t*c2)
 {
     if(!!c1 != !!c2)
         return 0;
@@ -41,7 +41,7 @@ char class_signature_equals(class_signature_t*c1, class_signature_t*c2)
     }
     return 0;
 }
-static unsigned int class_signature_hash(class_signature_t*c)
+static unsigned int classinfo_hash(classinfo_t*c)
 {
     unsigned int hash = 0;
     hash = crc32_add_string(hash, c->package);
@@ -50,11 +50,11 @@ static unsigned int class_signature_hash(class_signature_t*c)
 }
 
 static void* dummy_clone(void*other) {return other;}
-static void dummy_destroy(class_signature_t*c) {}
+static void dummy_destroy(classinfo_t*c) {}
 
-type_t class_signature_type = {
-    hash: (hash_func)class_signature_hash,
-    equals: (equals_func)class_signature_equals,
+type_t classinfo_type = {
+    hash: (hash_func)classinfo_hash,
+    equals: (equals_func)classinfo_equals,
     /* all signatures are static */
     dup: (dup_func)dummy_clone,
     free: (free_func)dummy_destroy,
@@ -62,17 +62,17 @@ type_t class_signature_type = {
 
 // ----------------------- function signature ------------------------------
 
-static char function_signature_equals(function_signature_t*f1, function_signature_t*f2)
+static char memberinfo_equals(memberinfo_t*f1, memberinfo_t*f2)
 {
     return !strcmp(f1->name, f2->name);
 }
-static unsigned int function_signature_hash(function_signature_t*f)
+static unsigned int memberinfo_hash(memberinfo_t*f)
 {
     return crc32_add_string(0, f->name);
 }
-type_t function_signature_type = {
-    hash: (hash_func)function_signature_hash,
-    equals: (equals_func)function_signature_equals,
+type_t memberinfo_type = {
+    hash: (hash_func)memberinfo_hash,
+    equals: (equals_func)memberinfo_equals,
     /* all signatures are static */
     dup: (dup_func)dummy_clone,
     free: (free_func)dummy_destroy,
@@ -80,9 +80,9 @@ type_t function_signature_type = {
 
 // ------------------------- constructors --------------------------------
 
-class_signature_t* class_signature_register(int access, char*package, char*name)
+classinfo_t* classinfo_register(int access, char*package, char*name)
 {
-    NEW(class_signature_t,c);
+    NEW(classinfo_t,c);
     c->access = access;
     c->package = package;
     c->name = name;
@@ -96,24 +96,24 @@ void registry_init()
 {
     classes = builtin_getclasses();
 }
-class_signature_t* registry_safefindclass(const char*package, const char*name)
+classinfo_t* registry_safefindclass(const char*package, const char*name)
 {
-    class_signature_t*c = registry_findclass(package, name);
+    classinfo_t*c = registry_findclass(package, name);
     assert(c);
     return c;
 }
-class_signature_t* registry_findclass(const char*package, const char*name)
+classinfo_t* registry_findclass(const char*package, const char*name)
 {
     assert(classes);
-    class_signature_t tmp;
+    classinfo_t tmp;
     tmp.package = package;
     tmp.name = name;
-    class_signature_t* c = (class_signature_t*)dict_lookup(classes, &tmp);
+    classinfo_t* c = (classinfo_t*)dict_lookup(classes, &tmp);
     /*if(c)
         printf("%s.%s->%08x (%s.%s)\n", package, name, c, c->package, c->name);*/
     return c;
 }
-void registry_fill_multiname(multiname_t*m, namespace_t*n, class_signature_t*c)
+void registry_fill_multiname(multiname_t*m, namespace_t*n, classinfo_t*c)
 {
     m->type = QNAME;
     m->ns = n;
@@ -122,7 +122,7 @@ void registry_fill_multiname(multiname_t*m, namespace_t*n, class_signature_t*c)
     m->name = c->name;
     m->namespace_set = 0;
 }
-multiname_t* class_signature_to_multiname(class_signature_t*cls)
+multiname_t* classinfo_to_multiname(classinfo_t*cls)
 {
     if(!cls)
         return 0;
@@ -132,21 +132,21 @@ multiname_t* class_signature_to_multiname(class_signature_t*cls)
 }
 
 // ----------------------- builtin types ------------------------------
-class_signature_t* registry_getanytype() {return 0;/*FIXME*/}
+classinfo_t* registry_getanytype() {return 0;/*FIXME*/}
 
-class_signature_t* registry_getobjectclass() {return registry_safefindclass("", "Object");}
-class_signature_t* registry_getstringclass() {return registry_safefindclass("", "String");}
-class_signature_t* registry_getintclass() {return registry_safefindclass("", "int");}
-class_signature_t* registry_getuintclass() {return registry_safefindclass("", "uint");}
-class_signature_t* registry_getbooleanclass() {return registry_safefindclass("", "Boolean");}
-class_signature_t* registry_getnumberclass() {return registry_safefindclass("", "Number");}
-class_signature_t* registry_getMovieClip() {return registry_safefindclass("flash.display", "MovieClip");}
+classinfo_t* registry_getobjectclass() {return registry_safefindclass("", "Object");}
+classinfo_t* registry_getstringclass() {return registry_safefindclass("", "String");}
+classinfo_t* registry_getintclass() {return registry_safefindclass("", "int");}
+classinfo_t* registry_getuintclass() {return registry_safefindclass("", "uint");}
+classinfo_t* registry_getbooleanclass() {return registry_safefindclass("", "Boolean");}
+classinfo_t* registry_getnumberclass() {return registry_safefindclass("", "Number");}
+classinfo_t* registry_getMovieClip() {return registry_safefindclass("flash.display", "MovieClip");}
 
 // ----------------------- builtin dummy types -------------------------
-class_signature_t nullclass = {
+classinfo_t nullclass = {
     ACCESS_PACKAGE, 0, "", "null", 0, 0, 0,
 };
-class_signature_t* registry_getnullclass() {
+classinfo_t* registry_getnullclass() {
     return &nullclass;
 }
 
diff --git a/lib/as3/registry.h b/lib/as3/registry.h
index 859331a..9b70655 100644
--- a/lib/as3/registry.h
+++ b/lib/as3/registry.h
@@ -26,52 +26,60 @@
 
 #include "pool.h"
 
-DECLARE(class_signature);
-DECLARE_LIST(class_signature);
-DECLARE(function_signature);
+DECLARE(classinfo);
+DECLARE_LIST(classinfo);
+DECLARE(memberinfo);
 
-struct _class_signature {
+struct _classinfo {
     /* this is very similar to a QNAME */
     U8 access;
     U8 flags;
     const char*package;
     const char*name;
 
-    class_signature_t*superclass;
+    classinfo_t*superclass;
     dict_t members;
-    class_signature_t*interfaces[];
+    classinfo_t*interfaces[];
 };
-char class_signature_equals(class_signature_t*c1, class_signature_t*c2);
-extern type_t class_signature_type;
+char classinfo_equals(classinfo_t*c1, classinfo_t*c2);
 
-struct _function_signature {
+#define MEMBER_SLOT 1
+#define MEMBER_METHOD 2
+struct _memberinfo {
+    U8 type;
     const char*name;
-    class_signature_list_t*params;
+    union {
+        classinfo_t*returnvalue;
+        classinfo_t*type;
+    };
+    classinfo_list_t*params;
 };
+
+extern type_t classinfo_type;
 extern type_t function_signature_type;
 
 void registry_init();
         
-class_signature_t* class_signature_register(int access, char*package, char*name);
+classinfo_t* classinfo_register(int access, char*package, char*name);
 
 // static multinames
-class_signature_t* registry_getanytype();
-class_signature_t* registry_getobjectclass();
-class_signature_t* registry_getnumberclass();
-class_signature_t* registry_getstringclass();
-class_signature_t* registry_getintclass();
-class_signature_t* registry_getuintclass();
-class_signature_t* registry_getnullclass();
-class_signature_t* registry_getbooleanclass();
-class_signature_t* registry_getMovieClip();
+classinfo_t* registry_getanytype();
+classinfo_t* registry_getobjectclass();
+classinfo_t* registry_getnumberclass();
+classinfo_t* registry_getstringclass();
+classinfo_t* registry_getintclass();
+classinfo_t* registry_getuintclass();
+classinfo_t* registry_getnullclass();
+classinfo_t* registry_getbooleanclass();
+classinfo_t* registry_getMovieClip();
 
-class_signature_t* registry_findclass(const char*package, const char*name);
+classinfo_t* registry_findclass(const char*package, const char*name);
 
-void registry_fill_multiname(multiname_t*m, namespace_t*n, class_signature_t*c);
-multiname_t* class_signature_to_multiname(class_signature_t*cls);
+void registry_fill_multiname(multiname_t*m, namespace_t*n, classinfo_t*c);
+multiname_t* classinfo_to_multiname(classinfo_t*cls);
 
 /* convenience functions */
-#define sig2mname(x) class_signature_to_multiname(x)
+#define sig2mname(x) classinfo_to_multiname(x)
 #define TYPE_ANY                  registry_getanytype()
 #define TYPE_IS_ANY(t)    ((t) == registry_getanytype())
 #define TYPE_INT                  registry_getintclass()
diff --git a/lib/as3/tokenizer.h b/lib/as3/tokenizer.h
index 57026ca..b080ded 100644
--- a/lib/as3/tokenizer.h
+++ b/lib/as3/tokenizer.h
@@ -30,8 +30,10 @@
 
 DECLARE(token);
 DECLARE_LIST(token);
+DECLARE(param);
+DECLARE_LIST(param);
 DECLARE(typedcode);
-DECLARE(typedcode_list);
+DECLARE_LIST(typedcode);
 
 struct _token {
     int type;
@@ -42,16 +44,17 @@ struct _token {
 typedef struct _writeable {
     code_t*write;
     code_t*read;
-    class_signature_t*type;
+    classinfo_t*type;
 } writeable_t;
 
+struct _param {
+    char*name;
+    classinfo_t*type;
+};
+
 struct _typedcode {
     code_t*c;
-    class_signature_t*t;
-};
-struct _typedcode_list {
-    struct _typedcode typedcode;
-    struct _typedcode_list*nxt;
+    classinfo_t*t;
 };
 
 extern char start_of_expression;
-- 
1.7.10.4