hyung-hwan/qse
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

*** empty log message ***

Browse Source
This commit is contained in:
hyung-hwan 2005-05-18 04:01:51 +00:00
parent 40de9dfb00
commit b9e52b5104
12 changed files with 249 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ase/stx/context.c
View File

@ -1,11 +1,11 @@
/*
* $Id: context.c,v 1.2 2005-05-16 14:14:34 bacon Exp $
* $Id: context.c,v 1.3 2005-05-18 04:01:51 bacon Exp $
*/
#include <xp/stx/context.h>
#include <xp/stx/object.h>
#define XP_STX_CONTEXT_DIMENSION 4
#define XP_STX_CONTEXT_SIZE 4
#define XP_STX_CONTEXT_IP 0
#define XP_STX_CONTEXT_METHOD 1
#define XP_STX_CONTEXT_ARGUMENTS 2
@ -16,7 +16,7 @@ xp_stx_word_t xp_stx_new_context (xp_stx_t* stx,
{
xp_stx_word_t context;
context = xp_stx_alloc_object(stx,XP_STX_CONTEXT_DIMENSION);
context = xp_stx_alloc_object(stx,XP_STX_CONTEXT_SIZE);
XP_STX_CLASS(stx,context) = stx->class_context;
XP_STX_AT(stx,context,XP_STX_CONTEXT_IP) = XP_STX_TO_SMALLINT(0);
XP_STX_AT(stx,context,XP_STX_CONTEXT_METHOD) = method;

77
ase/stx/hash.c
View File

@ -1,5 +1,5 @@
/*
* $Id: hash.c,v 1.11 2005-05-17 16:18:56 bacon Exp $
* $Id: hash.c,v 1.12 2005-05-18 04:01:51 bacon Exp $
*/
#include <xp/stx/hash.h>
@ -7,21 +7,16 @@
#include <xp/stx/misc.h>
#include <xp/bas/assert.h>
#define PLINK_DIMENSION 3
#define PLINK_LINK 0
#define PLINK_KEY 1
#define PLINK_VALUE 2
xp_stx_word_t xp_stx_new_plink (
xp_stx_word_t xp_stx_new_pairlink (
xp_stx_t* stx, xp_stx_word_t key, xp_stx_word_t value)
{
xp_stx_word_t x;
x = xp_stx_alloc_object (stx, PLINK_DIMENSION);
XP_STX_CLASS(stx,x) = stx->class_symbol_plink;
/* XP_STX_AT(stx,x,PLINK_LINK) = stx->nil; */
XP_STX_AT(stx,x,PLINK_KEY) = key;
XP_STX_AT(stx,x,PLINK_VALUE) = value;
x = xp_stx_alloc_object (stx, XP_STX_PAIRLINK_SIZE);
XP_STX_CLASS(stx,x) = stx->class_pairlink;
/* XP_STX_AT(stx,x,XP_STX_PAIRLINK_LINK) = stx->nil; */
XP_STX_AT(stx,x,XP_STX_PAIRLINK_KEY) = key;
XP_STX_AT(stx,x,XP_STX_PAIRLINK_VALUE) = value;
return x;
}
@ -39,8 +34,8 @@ xp_stx_word_t xp_stx_hash_lookup (
link = XP_STX_AT(stx,table,hash);
while (link != stx->nil) {
if (XP_STX_AT(stx,link,PLINK_KEY) == key) return link;
link = XP_STX_AT(stx,link,PLINK_LINK);
if (XP_STX_AT(stx,link,XP_STX_PAIRLINK_KEY) == key) return link;
link = XP_STX_AT(stx,link,XP_STX_PAIRLINK_LINK);
}
return stx->nil; /* not found */
@ -58,7 +53,7 @@ xp_stx_word_t xp_stx_hash_lookup_symbol (
link = XP_STX_AT(stx,table,hash);
while (link != stx->nil) {
key = XP_STX_AT(stx,link,PLINK_KEY);
key = XP_STX_AT(stx,link,XP_STX_PAIRLINK_KEY);
if (XP_STX_CLASS(stx,key) == stx->class_symbol &&
xp_stx_strxcmp (
@ -66,7 +61,7 @@ xp_stx_word_t xp_stx_hash_lookup_symbol (
XP_STX_SIZE(stx,key), key_str) == 0) {
return link;
}
link = XP_STX_AT(stx,link,PLINK_LINK);
link = XP_STX_AT(stx,link,XP_STX_PAIRLINK_LINK);
}
return stx->nil; /* not found */
@ -85,19 +80,19 @@ void xp_stx_hash_insert (
if (link == stx->nil) {
XP_STX_AT(stx,table,hash) =
xp_stx_new_plink (stx, key, value);
xp_stx_new_pairlink (stx, key, value);
}
else {
for (;;) {
if (XP_STX_AT(stx,link,1) == key) {
XP_STX_AT(stx,link,PLINK_VALUE) = value;
XP_STX_AT(stx,link,XP_STX_PAIRLINK_VALUE) = value;
break;
}
next = XP_STX_AT(stx,link,PLINK_LINK);
next = XP_STX_AT(stx,link,XP_STX_PAIRLINK_LINK);
if (next == stx->nil) {
XP_STX_AT(stx,link,PLINK_LINK) =
xp_stx_new_plink (stx, key, value);
XP_STX_AT(stx,link,XP_STX_PAIRLINK_LINK) =
xp_stx_new_pairlink (stx, key, value);
break;
}
@ -118,46 +113,8 @@ void xp_stx_hash_traverse (
while (link != stx->nil) {
func (stx,link);
link = XP_STX_AT(stx,link,PLINK_LINK);
link = XP_STX_AT(stx,link,XP_STX_PAIRLINK_LINK);
}
}
}
/*
xp_stx_word_t xp_stx_new_symbol (
xp_stx_t* stx, const xp_stx_char_t* name)
{
xp_stx_word_t x, hash;
hash = xp_stx_strhash(name);
x = xp_stx_hash_lookup_symbol(stx, stx->symbol_table, hash, name);
if (x == stx->nil) {
x = xp_stx_alloc_string_object (stx, name);
XP_STX_CLASS(stx,x) = stx->class_symbol;
xp_stx_hash_insert (stx, stx->symbol_table, hash, x, stx->nil);
}
else x = XP_STX_AT(stx,x,PLINK_KEY);
return x;
}
xp_stx_word_t xp_stx_new_symbol_pp (
xp_stx_t* stx, const xp_stx_char_t* name,
const xp_stx_char_t* prefix, const xp_stx_char_t* postfix)
{
xp_stx_word_t x, hash;
hash = xp_stx_strhash(name);
x = xp_stx_hash_lookup_symbol(stx, stx->symbol_table, hash, name);
if (x == stx->nil) {
x = xp_stx_allocn_string_object (stx, prefix, name, postfix, XP_NULL);
XP_STX_CLASS(stx,x) = stx->class_symbol;
xp_stx_hash_insert (stx, stx->symbol_table, hash, x, stx->nil);
}
else x = XP_STX_AT(stx,x,PLINK_KEY);
return x;
}
*/

15
ase/stx/hash.h
View File

@ -1,5 +1,5 @@
/*
* $Id: hash.h,v 1.5 2005-05-16 14:14:34 bacon Exp $
* $Id: hash.h,v 1.6 2005-05-18 04:01:51 bacon Exp $
*/
#ifndef _XP_STX_HASH_H_
@ -7,12 +7,17 @@
#include <xp/stx/stx.h>
#define XP_STX_PAIRLINK_SIZE 3
#define XP_STX_PAIRLINK_LINK 0
#define XP_STX_PAIRLINK_KEY 1
#define XP_STX_PAIRLINK_VALUE 2
#ifdef __cplusplus
extern "C"
#endif
/* hash table manipulation */
xp_stx_word_t xp_stx_new_symbol_link (
xp_stx_word_t xp_stx_new_plink (
xp_stx_t* stx, xp_stx_word_t key, xp_stx_word_t value);
xp_stx_word_t xp_stx_hash_lookup (
xp_stx_t* stx, xp_stx_word_t table,
@ -27,12 +32,6 @@ void xp_stx_hash_traverse (
xp_stx_t* stx, xp_stx_word_t table,
void (*func) (xp_stx_t*,xp_stx_word_t));
xp_stx_word_t xp_stx_new_symbol (
xp_stx_t* stx, const xp_stx_char_t* name);
xp_stx_word_t xp_stx_new_symbol_pp (
xp_stx_t* stx, const xp_stx_char_t* name,
const xp_stx_char_t* prefix, const xp_stx_char_t* postfix);
#ifdef __cplusplus
}
#endif

12
ase/stx/interp.c
View File

@ -1,15 +1,15 @@
/*
* $Id: interp.c,v 1.2 2005-05-15 18:37:00 bacon Exp $
* $Id: interp.c,v 1.3 2005-05-18 04:01:51 bacon Exp $
*/
#include <xp/stx/interp.h>
#define XP_STX_PROCESS_DIMENSION 3
#define XP_STX_PROCESS_SIZE 3
#define XP_STX_PROCESS_STACK 0
#define XP_STX_PROCESS_STACK_TOP 1
#define XP_STX_PROCESS_LINK 2
#define XP_STX_CONTEXT_DIMENSION 6
#define XP_STX_CONTEXT_SIZE 6
#define XP_STX_PROCESS_LINK 0
#define XP_STX_PROCESS_METHOD 1
#define XP_STX_PROCESS_ARGUMENTS 2
@ -39,7 +39,7 @@ static byte_code_func_t byte_code_funcs[] =
xp_stx_word_t xp_stx_new_method (xp_stx_t* stx)
{
xp_stx_word_t method;
method = xp_stx_alloc_object(XP_STX_METHOD_DIMENSION);
method = xp_stx_alloc_object(XP_STX_METHOD_SIZE);
return method;
}
@ -49,7 +49,7 @@ xp_stx_word_t xp_stx_new_context (xp_stx_t* stx,
{
xp_stx_word_t context;
context = xp_stx_alloc_object(XP_STX_CONTEXT_DIMENSION);
context = xp_stx_alloc_object(XP_STX_CONTEXT_SIZE);
XP_STX_CLASS(stx,context) = stx->class_context;
XP_STX_AT(stx,context,XP_STX_CONTEXT_METHOD) = method;
XP_STX_AT(stx,context,XP_STX_CONTEXT_ARGUMENTS) = args;
@ -62,7 +62,7 @@ xp_stx_word_t xp_stx_new_process (xp_stx_t* stx, xp_stx_word_t method)
{
xp_stx_word_t process, stx;
process = xp_stx_alloc_object(XP_STX_PROCESS_DIMENSION);
process = xp_stx_alloc_object(XP_STX_PROCESS_SIZE);
stack = xp_new_array(stx,50);
XP_STX_CLASS(stx,process) = stx->class_process;

2
ase/stx/makefile.in
View File

@ -1,4 +1,4 @@
SRCS = stx.c memory.c object.c hash.c misc.c context.c
SRCS = stx.c memory.c object.c symbol.c hash.c misc.c context.c
OBJS = $(SRCS:.c=.o)
OUT = libxpstx.a

19
ase/stx/object.c
View File

@ -1,9 +1,10 @@
/*
* $Id: object.c,v 1.14 2005-05-17 16:18:56 bacon Exp $
* $Id: object.c,v 1.15 2005-05-18 04:01:51 bacon Exp $
*/
#include <xp/stx/object.h>
#include <xp/stx/memory.h>
#include <xp/stx/symbol.h>
#include <xp/stx/hash.h>
#include <xp/stx/misc.h>
#include <xp/bas/assert.h>
@ -107,25 +108,29 @@ xp_stx_word_t xp_stx_hash_string_object (xp_stx_t* stx, xp_stx_word_t idx)
xp_stx_word_t xp_stx_new_class (xp_stx_t* stx, const xp_stx_char_t* name)
{
xp_stx_word_t meta, class;
xp_stx_word_t meta_name, class_name;
xp_stx_word_t /*meta_name,*/ class_name;
meta = xp_stx_alloc_object (stx, XP_STX_CLASS_DIMENSION);
meta = xp_stx_alloc_object (stx, XP_STX_CLASS_SIZE);
XP_STX_CLASS(stx,meta) = stx->class_metaclass;
XP_STX_AT(stx,meta,XP_STX_CLASS_SIZE) =
XP_STX_TO_SMALLINT(XP_STX_CLASS_DIMENSION);
XP_STX_TO_SMALLINT(XP_STX_CLASS_SIZE);
class = xp_stx_alloc_object (stx, XP_STX_CLASS_DIMENSION);
class = xp_stx_alloc_object (stx, XP_STX_CLASS_SIZE);
XP_STX_CLASS(stx,class) = meta;
/*
meta_name = xp_stx_new_symbol_pp (
stx, name, XP_STX_TEXT(""), XP_STX_TEXT(" class"));
XP_STX_AT(stx,meta,XP_STX_CLASS_NAME) = meta_name;
*/
class_name = xp_stx_new_symbol (stx, name);
XP_STX_AT(stx,class,XP_STX_CLASS_NAME) = class_name;
/*
xp_stx_hash_insert (stx, stx->smalltalk,
xp_stx_hash_string_object(stx, meta_name),
meta_name, meta);
*/
xp_stx_hash_insert (stx, stx->smalltalk,
xp_stx_hash_string_object(stx, class_name),
class_name, class);
@ -140,10 +145,10 @@ int xp_stx_lookup_global (
// TODO: maybe xp_stx_hash_object is required instead of
// xp_stx_hash_string_object.
link = xp_stx_hash_lookup (stx, stx->symbol_table,
link = xp_stx_hash_lookup (stx, stx->smalltalk,
xp_stx_hash_string_object(stx,key), key);
if (link == stx->nil) return -1;
*value = XP_STX_AT(stx,link,2);
*value = XP_STX_AT(stx,link,XP_STX_PAIRLINK_VALUE);
return 0;
}

6
ase/stx/object.h
View File

@ -1,5 +1,5 @@
/*
* $Id: object.h,v 1.11 2005-05-15 18:37:00 bacon Exp $
* $Id: object.h,v 1.12 2005-05-18 04:01:51 bacon Exp $
*/
#ifndef _XP_STX_OBJECT_H_
@ -12,9 +12,9 @@
#define XP_STX_FROM_SMALLINT(x) ((x) >> 1)
/* definitions for common objects */
#define XP_STX_CLASS_DIMENSION 8
#define XP_STX_CLASS_SIZE 8
#define XP_STX_CLASS_NAME 0
#define XP_STX_CLASS_SIZE 1
#define XP_STX_CLASS_SPEC 1
#define XP_STX_CLASS_METHODS 2
#define XP_STX_CLASS_SUPERCLASS 3
#define XP_STX_CLASS_VARIABLES 4

288
ase/stx/stx.c
View File

@ -1,5 +1,5 @@
/*
* $Id: stx.c,v 1.15 2005-05-17 16:18:56 bacon Exp $
* $Id: stx.c,v 1.16 2005-05-18 04:01:51 bacon Exp $
*/
#include <xp/stx/stx.h>
@ -10,6 +10,8 @@
#include <xp/bas/memory.h>
#include <xp/bas/assert.h>
static void __create_initial_objects (xp_stx_t* stx);
xp_stx_t* xp_stx_open (xp_stx_t* stx, xp_stx_word_t capacity)
{
if (stx == XP_NULL) {
@ -31,9 +33,10 @@ xp_stx_t* xp_stx_open (xp_stx_t* stx, xp_stx_word_t capacity)
stx->symbol_table = XP_STX_NIL;
stx->smalltalk = XP_STX_NIL;
stx->class_symbol_link = XP_STX_NIL;
stx->class_symlink = XP_STX_NIL;
stx->class_symbol = XP_STX_NIL;
stx->class_metaclass = XP_STX_NIL;
stx->class_pairlink = XP_STX_NIL;
stx->class_method = XP_STX_NIL;
stx->class_context = XP_STX_NIL;
@ -48,19 +51,9 @@ void xp_stx_close (xp_stx_t* stx)
if (stx->__malloced) xp_free (stx);
}
static void __reset_symbol_link_class (xp_stx_t* stx, xp_stx_word_t idx)
{
XP_STX_CLASS(stx,idx) = stx->class_symbol_link;
}
int xp_stx_bootstrap (xp_stx_t* stx)
{
xp_stx_word_t symtab, symbol_Smalltalk;
xp_stx_word_t symbol_nil, symbol_true, symbol_false;
xp_stx_word_t symbol_Symbol, symbol_SymbolMeta;
xp_stx_word_t symbol_Metaclass, symbol_MetaclassMeta;
xp_stx_word_t class_Symbol, class_SymbolMeta;
xp_stx_word_t class_Metaclass, class_MetaclassMeta;
xp_stx_word_t symbol_Smalltalk, symbol_nil, symbol_true, symbol_false;
xp_stx_word_t class_Object, class_Class;
xp_stx_word_t tmp;
@ -79,154 +72,25 @@ int xp_stx_bootstrap (xp_stx_t* stx)
/* build a system dictionary */
stx->smalltalk = xp_stx_alloc_object (stx, 2000);
/* create classes to make xp_stx_new_symbol work */
stx->class_symbol_link =
xp_stx_alloc_object(stx,XP_STX_CLASS_DIMENSION);
stx->class_symbol =
xp_stx_alloc_object(stx,XP_STX_CLASS_DIMENSION);
/* initial system objects */
__create_initial_objects (stx);
symbol_SymbolLink =
xp_stx_new_symbol (XP_STX_TEXT("SymbolLink"));
symbol_SymbolLinkMeta
xp_stx_new_symbol (XP_STX_TEXT("SymbolLink class"));
symbol_Symbol =
xp_stx_new_symbol (XP_STX_TEXT("Symbol"));
symbol_SymbolMeta =
xp_stx_new_symbol (XP_STX_TEXT("Symbol class"));
XP_STX_AT(stx,stx->class_symbol_link,XP_STX_CLASS_NAME) = symbol_SymbolLinkMeta;
XP_STX_AT(stx,stx->class_symbol,XP_STX_CLASS_NAME) = symbol_SymbolLink;
/* more initialization */
XP_STX_CLASS(stx,stx->symbol_table) =
xp_stx_new_class (stx, XP_STX_TEXT("SymbolTable"));
XP_STX_CLASS(stx,stx->smalltalk) =
xp_stx_new_class (stx, XP_STX_TEXT("SystemDictionary"));
symbol_Smalltalk = xp_stx_new_symbol (stx, XP_STX_TEXT("Smalltalk"));
xp_stx_hash_insert (stx, stx->smalltalk,
xp_stx_hash_string_object(stx, symbol_SymbolLink),
symbol_SymbolLink, stx->class_symbol);
xp_stx_hash_insert (stx, stx->smalltalk,
xp_stx_hash_string_object(stx, symbol_Symbol),
symbol_Symbol, stx->class_symbol);
/* class_metaclass to make xp_stx_new_class to work */
stx->class_metaclass =
xp_stx_alloc_object(stx,XP_STX_CLASS_DIMENSION);
symbol_Meaclass =
xp_stx_new_symbol (XP_STX_TEXT("Metaclass"));
symbol_MeaclassMeta =
xp_stx_new_symbol (XP_STX_TEXT("Metaclass class"));
XP_STX_AT(stx->class_metaclass,XP_STX_CLASS_NAME) = symbol_Metaclass;
xp_stx_hash_insert (stx, stx->smalltalk,
xp_stx_hash_string_object(stx, symbol_Metaclass),
symbol_Metaclass, stx->class_metaclass);
/* .............. */
symbol->Metaclass = xp_stx_new_symbol (XP_STX_TEXT("Metaclass"));
class_Metaclass =
xp_stx_alloc_object(stx,XP_STX_CLASS_DIMENSION);
xp_stx_hash_insert (stx, stx->smalltalk,
xp_stx_hash_string_object(stx, symbol_Metaclass),
symbol_Metaclass, class_Metaclass);
stx->class_metaclass = class_Metaclass;
class_Metaclass = xp_stx_new_class (stx, XP_STX_TEXT("Metaclass"));
class_Symbol = xp_stx_new_class (stx, XP_STX_TEXT("Symbol"));
symbol_Symbol =
xp_stx_new_symbol (XP_STX_TEXT("Symbol"));
symbol_SymbolMeta =
xp_stx_new_symbol (XP_STX_TEXT("Symbol class"));
symbol_Metaclass =
xp_stx_new_symbol (XP_STX_TEXT("Metaclass"));
symbol_MetaclassMeta =
xp_stx_new_symbol (XP_STX_TEXT("Metaclass class"));
/* tweak the initial object structure */
/*
class_Metaclass = xp_stx_alloc_object(stx, XP_STX_CLASS_DIMENSION);
class_MetaclassMeta = xp_stx_alloc_object(stx, XP_STX_CLASS_DIMENSION);
class_Symbol = xp_stx_alloc_object(stx, XP_STX_CLASS_DIMENSION);
class_SymbolMeta = xp_stx_alloc_object(stx, XP_STX_CLASS_DIMENSION);
symbol_Symbol =
xp_stx_alloc_string_object(stx, XP_STX_TEXT("Symbol"));
symbol_SymbolMeta =
xp_stx_alloc_string_object(stx,XP_STX_TEXT("Symbol class"));
symbol_Metaclass =
xp_stx_alloc_string_object(stx, XP_STX_TEXT("Metaclass"));
symbol_MetaclassMeta =
xp_stx_alloc_string_object(stx, XP_STX_TEXT("Metaclass class"));
XP_STX_CLASS(stx,symbol_SymbolMeta) = class_Symbol;
XP_STX_CLASS(stx,symbol_Metaclass) = class_Symbol;
XP_STX_CLASS(stx,symbol_MetaclassMeta) = class_Symbol;
XP_STX_CLASS(stx,class_Symbol) = class_SymbolMeta;
XP_STX_CLASS(stx,class_SymbolMeta) = class_Metaclass;
XP_STX_CLASS(stx,class_Metaclass) = class_MetaclassMeta;
XP_STX_CLASS(stx,class_MetaclassMeta) = class_Metaclass;
*/
/*
xp_stx_hash_insert (stx, symtab,
xp_stx_hash_string_object(stx, symbol_Symbol),
symbol_Symbol, class_Symbol);
xp_stx_hash_insert (stx, symtab,
xp_stx_hash_string_object(stx, symbol_SymbolMeta),
symbol_SymbolMeta, class_SymbolMeta);
xp_stx_hash_insert (stx, symtab,
xp_stx_hash_string_object(stx, symbol_Metaclass),
symbol_Metaclass, class_Metaclass);
xp_stx_hash_insert (stx, symtab,
xp_stx_hash_string_object(stx, symbol_MetaclassMeta),
symbol_MetaclassMeta, class_MetaclassMeta);
*/
/* now ready to use new_symbol & new_class */
/*
stx->symbol_table = symtab;
stx->class_symbol = class_Symbol;
stx->class_metaclass = class_Metaclass;
*/
/* more initialization for symbol table */
/*
stx->class_symbol_link =
xp_stx_new_class (stx, XP_STX_TEXT("SymbolLink"));
xp_stx_hash_traverse (stx, symtab, __reset_symbol_link_class);
XP_STX_CLASS(stx,symtab) =
xp_stx_new_class (stx, XP_STX_TEXT("Array"));
symbol_Smalltalk =
xp_stx_new_symbol (stx, XP_STX_TEXT("Smalltalk"));
xp_stx_hash_insert (stx, symtab,
xp_stx_hash_string_object(stx, symbol_Smalltalk),
symbol_Smalltalk, symtab);
*/
xp_stx_hash_string_object(stx,symbol_Smalltalk),
symbol_Smalltalk, stx->smalltalk);
/* more initialization for nil, true, false */
/*
// nil, true, false must be treated specially by the compiler....
// so it doesn't have to be registered into the system dictionary....
symbol_nil = xp_stx_new_symbol (stx, XP_STX_TEXT("nil"));
symbol_true = xp_stx_new_symbol (stx, XP_STX_TEXT("true"));
symbol_false = xp_stx_new_symbol (stx, XP_STX_TEXT("false"));
xp_stx_hash_insert (stx, symtab,
xp_stx_hash_string_object(stx, symbol_nil),
symbol_nil, stx->nil);
xp_stx_hash_insert (stx, symtab,
xp_stx_hash_string_object(stx, symbol_true),
symbol_true, stx->true);
xp_stx_hash_insert (stx, symtab,
xp_stx_hash_string_object(stx, symbol_false),
symbol_false, stx->false);
*/
XP_STX_CLASS(stx,stx->nil) =
xp_stx_new_class (stx, XP_STX_TEXT("UndefinedObject"));
XP_STX_CLASS(stx,stx->true) =
@ -246,3 +110,123 @@ int xp_stx_bootstrap (xp_stx_t* stx)
return 0;
}
static void __create_initial_objects (xp_stx_t* stx)
{
xp_stx_word_t class_SymlinkMeta;
xp_stx_word_t class_SymbolMeta;
xp_stx_word_t class_MetaclassMeta;
xp_stx_word_t class_PairlinkMeta;
xp_stx_word_t symbol_Symlink;
xp_stx_word_t symbol_Symbol;
xp_stx_word_t symbol_Metaclass;
xp_stx_word_t symbol_Pairlink;
stx->class_symlink = /* Symlink */
xp_stx_alloc_object(stx,XP_STX_CLASS_SIZE);
stx->class_symbol = /* Symbol */
xp_stx_alloc_object(stx,XP_STX_CLASS_SIZE);
stx->class_metaclass = /* Metaclass */
xp_stx_alloc_object(stx,XP_STX_CLASS_SIZE);
stx->class_pairlink = /* Pairlink */
xp_stx_alloc_object(stx,XP_STX_CLASS_SIZE);
class_SymlinkMeta = /* Symlink class */
xp_stx_alloc_object(stx,XP_STX_CLASS_SIZE);
class_SymbolMeta = /* Symbol class */
xp_stx_alloc_object(stx,XP_STX_CLASS_SIZE);
class_MetaclassMeta = /* Metaclass class */
xp_stx_alloc_object(stx,XP_STX_CLASS_SIZE);
class_PairlinkMeta = /* Pairlink class */
xp_stx_alloc_object(stx,XP_STX_CLASS_SIZE);
/* (Symlink class) setClass: Metaclass */
XP_STX_CLASS(stx,class_SymlinkMeta) = stx->class_metaclass;
/* (Symbol class) setClass: Metaclass */
XP_STX_CLASS(stx,class_SymbolMeta) = stx->class_metaclass;
/* (Metaclass class) setClass: Metaclass */
XP_STX_CLASS(stx,class_MetaclassMeta) = stx->class_metaclass;
/* (Pairlink class) setClass: Metaclass */
XP_STX_CLASS(stx,class_PairlinkMeta) = stx->class_metaclass;
/* Symlink setClass: (Symlink class) */
XP_STX_CLASS(stx,stx->class_symlink) = class_SymlinkMeta;
/* Symbol setClass: (Symbol class) */
XP_STX_CLASS(stx,stx->class_symbol) = class_SymbolMeta;
/* Metaclass setClass: (Metaclass class) */
XP_STX_CLASS(stx,stx->class_metaclass) = class_MetaclassMeta;
/* Pairlink setClass: (Pairlink class) */
XP_STX_CLASS(stx,stx->class_pairlink) = class_PairlinkMeta;
stx->class_symlink = /* Symlink */
xp_stx_alloc_object(stx,XP_STX_CLASS_SIZE);
stx->class_symbol = /* Symbol */
xp_stx_alloc_object(stx,XP_STX_CLASS_SIZE);
stx->class_metaclass = /* Metaclass */
xp_stx_alloc_object(stx,XP_STX_CLASS_SIZE);
stx->class_pairlink = /* Pairlink */
xp_stx_alloc_object(stx,XP_STX_CLASS_SIZE);
/* (Symlink class) setClass: Metaclass */
XP_STX_CLASS(stx,class_SymlinkMeta) = stx->class_metaclass;
/* (Symbol class) setClass: Metaclass */
XP_STX_CLASS(stx,class_SymbolMeta) = stx->class_metaclass;
/* (Metaclass class) setClass: Metaclass */
XP_STX_CLASS(stx,class_MetaclassMeta) = stx->class_metaclass;
/* (Pairlink class) setClass: Metaclass */
XP_STX_CLASS(stx,class_PairlinkMeta) = stx->class_metaclass;
/* Symlink setClass: (Symlink class) */
XP_STX_CLASS(stx,stx->class_symlink) = class_SymlinkMeta;
/* Symbol setClass: (Symbol class) */
XP_STX_CLASS(stx,stx->class_symbol) = class_SymbolMeta;
/* Metaclass setClass: (Metaclass class) */
XP_STX_CLASS(stx,stx->class_metaclass) = class_MetaclassMeta;
/* Pairlink setClass: (Metaclass class) */
XP_STX_CLASS(stx,stx->class_pairlink) = class_PairlinkMeta;
/* (Symlink class) setSpec: CLASS_SIZE */
XP_STX_AT(stx,class_SymlinkMeta,XP_STX_CLASS_SPEC) =
XP_STX_TO_SMALLINT(XP_STX_CLASS_SIZE);
/* (Symbol class) setSpec: CLASS_SIZE */
XP_STX_AT(stx,class_SymbolMeta,XP_STX_CLASS_SPEC) =
XP_STX_TO_SMALLINT(XP_STX_CLASS_SIZE);
/* (Metaclass class) setSpec: CLASS_SIZE */
XP_STX_AT(stx,class_MetaclassMeta,XP_STX_CLASS_SPEC) =
XP_STX_TO_SMALLINT(XP_STX_CLASS_SIZE);
/* (Pairlink class) setSpec: CLASS_SIZE */
XP_STX_AT(stx,class_PairlinkMeta,XP_STX_CLASS_SPEC) =
XP_STX_TO_SMALLINT(XP_STX_CLASS_SIZE);
/* #Symlink */
symbol_Symlink = xp_stx_new_symbol (stx, XP_STX_TEXT("Symlink"));
/* #Symbol */
symbol_Symbol = xp_stx_new_symbol (stx, XP_STX_TEXT("Symbol"));
/* #Metaclass */
symbol_Metaclass = xp_stx_new_symbol (stx, XP_STX_TEXT("Metaclass"));
/* #Pairlink */
symbol_Pairlink = xp_stx_new_symbol (stx, XP_STX_TEXT("Pairlink"));
/* Symlink setName: #Symlink */
XP_STX_AT(stx,stx->class_symlink,XP_STX_CLASS_NAME) = symbol_Symlink;
/* Symbol setName: #Symbol */
XP_STX_AT(stx,stx->class_symbol,XP_STX_CLASS_NAME) = symbol_Symbol;
/* Metaclass setName: #Metaclass */
XP_STX_AT(stx,stx->class_metaclass,XP_STX_CLASS_NAME) = symbol_Metaclass;
/* Pairlink setName: #Pairlink */
XP_STX_AT(stx,stx->class_pairlink,XP_STX_CLASS_NAME) = symbol_Pairlink;
/* register class names into the system dictionary */
xp_stx_hash_insert (stx, stx->smalltalk,
xp_stx_hash_string_object(stx, symbol_Symlink),
symbol_Symlink, stx->class_symlink);
xp_stx_hash_insert (stx, stx->smalltalk,
xp_stx_hash_string_object(stx, symbol_Symbol),
symbol_Symbol, stx->class_symbol);
xp_stx_hash_insert (stx, stx->smalltalk,
xp_stx_hash_string_object(stx, symbol_Metaclass),
symbol_Metaclass, stx->class_metaclass);
xp_stx_hash_insert (stx, stx->smalltalk,
xp_stx_hash_string_object(stx, symbol_Pairlink),
symbol_Pairlink, stx->class_pairlink);
}

5
ase/stx/stx.h
View File

@ -1,5 +1,5 @@
/*
* $Id: stx.h,v 1.13 2005-05-17 16:18:56 bacon Exp $
* $Id: stx.h,v 1.14 2005-05-18 04:01:51 bacon Exp $
*/
#ifndef _XP_STX_STX_H_
@ -73,9 +73,10 @@ struct xp_stx_t
xp_stx_word_t symbol_table;
xp_stx_word_t smalltalk;
xp_stx_word_t class_symbol_link;
xp_stx_word_t class_symlink;
xp_stx_word_t class_symbol;
xp_stx_word_t class_metaclass;
xp_stx_word_t class_pairlink;
xp_stx_word_t class_method;
xp_stx_word_t class_context;

58
ase/stx/symbol.c
View File

@ -1,5 +1,5 @@
/*
* $Id: symbol.c,v 1.1 2005-05-17 16:18:56 bacon Exp $
* $Id: symbol.c,v 1.2 2005-05-18 04:01:51 bacon Exp $
*/
#include <xp/stx/symbol.h>
@ -7,18 +7,18 @@
#include <xp/stx/misc.h>
#include <xp/bas/assert.h>
#define SYMBOL_LINK_DIMENSION 2
#define SYMBOL_LINK_LINK 0
#define SYMBOL_LINK_SYMBOL 1
#define SYMLINK_SIZE 2
#define SYMLINK_LINK 0
#define SYMLINK_SYMBOL 1
xp_stx_word_t xp_stx_new_symbol_link (xp_stx_t* stx, xp_stx_word_t sym)
xp_stx_word_t xp_stx_new_symlink (xp_stx_t* stx, xp_stx_word_t sym)
{
xp_stx_word_t x;
x = xp_stx_alloc_object (stx, SYMBOL_LINK_DIMENSION);
XP_STX_CLASS(stx,x) = stx->class_symbol_link;
/*XP_STX_AT(stx,x,SYMBOL_LINK_LINK) = stx->nil;*/
XP_STX_AT(stx,x,SYMBOL_LINK_SYMBOL) = sym;
x = xp_stx_alloc_object (stx, SYMLINK_SIZE);
XP_STX_CLASS(stx,x) = stx->class_symlink;
/*XP_STX_AT(stx,x,SYMLINK_LINK) = stx->nil;*/
XP_STX_AT(stx,x,SYMLINK_SYMBOL) = sym;
return x;
}
@ -34,23 +34,23 @@ xp_stx_word_t xp_stx_new_symbol (xp_stx_t* stx, const xp_stx_char_t* name)
if (link == stx->nil) {
x = xp_stx_alloc_string_object (stx, name);
XP_STX_CLASS(stx,x) = stx->class_symbol;
XP_STX_AT(stx,table,hash) = xp_stx_new_symbol_link(stx,x);
XP_STX_AT(stx,table,hash) = xp_stx_new_symlink(stx,x);
}
else {
do {
x = XP_STX_AT(stx,link,SYMBOL_LINK_SYMBOL);
x = XP_STX_AT(stx,link,SYMLINK_SYMBOL);
xp_assert (XP_STX_CLASS(stx,x) == stx->class_symbol);
if (xp_stx_strxcmp (
&XP_STX_CHARAT(stx,x,0),
XP_STX_SIZE(stx,x), name) == 0) return x;
next = XP_STX_AT(stx,link,SYMBOL_LINK_LINK);
next = XP_STX_AT(stx,link,SYMLINK_LINK);
if (next == stx->nil) {
x = xp_stx_alloc_string_object (stx, name);
XP_STX_CLASS(stx,x) = stx->class_symbol;
XP_STX_AT(stx,link,SYMBOL_LINK_LINK) =
xp_stx_new_symbol_link(stx,x);
XP_STX_AT(stx,link,SYMLINK_LINK) =
xp_stx_new_symlink(stx,x);
break;
}
@ -75,23 +75,23 @@ xp_stx_word_t xp_stx_new_symbol_pp (
if (link == stx->nil) {
x = xp_stx_allocn_string_object (stx, prefix, name, postfix);
XP_STX_CLASS(stx,x) = stx->class_symbol;
XP_STX_AT(stx,table,hash) = xp_stx_new_symbol_link(stx,x);
XP_STX_AT(stx,table,hash) = xp_stx_new_symlink(stx,x);
}
else {
do {
x = XP_STX_AT(stx,link,SYMBOL_LINK_SYMBOL);
x = XP_STX_AT(stx,link,SYMLINK_SYMBOL);
xp_assert (XP_STX_CLASS(stx,x) == stx->class_symbol);
if (xp_stx_strxcmp (
&XP_STX_CHARAT(stx,x,0),
XP_STX_SIZE(stx,x), name) == 0) return x;
next = XP_STX_AT(stx,link,SYMBOL_LINK_LINK);
next = XP_STX_AT(stx,link,SYMLINK_LINK);
if (next == stx->nil) {
x = xp_stx_allocn_string_object (stx, prefix, name, postfix);
XP_STX_CLASS(stx,x) = stx->class_symbol;
XP_STX_AT(stx,link,SYMBOL_LINK_LINK) =
xp_stx_new_symbol_link(stx,x);
XP_STX_AT(stx,link,SYMLINK_LINK) =
xp_stx_new_symlink(stx,x);
break;
}
@ -102,3 +102,23 @@ xp_stx_word_t xp_stx_new_symbol_pp (
return x;
}
void xp_stx_traverse_symbol_table (
xp_stx_t* stx, void (*func) (xp_stx_t*,xp_stx_word_t))
{
xp_stx_word_t link;
xp_stx_word_t size;
xp_stx_word_t table;
table = stx->symbol_table;
size = XP_STX_SIZE(stx,table);
while (size-- > 0) {
link = XP_STX_AT(stx,table,size);
while (link != stx->nil) {
func (stx,XP_STX_AT(stx,link,SYMLINK_SYMBOL));
link = XP_STX_AT(stx,link,SYMLINK_LINK);
}
}
}

5
ase/stx/symbol.h
View File

@ -1,5 +1,5 @@
/*
* $Id: symbol.h,v 1.1 2005-05-17 16:18:56 bacon Exp $
* $Id: symbol.h,v 1.2 2005-05-18 04:01:51 bacon Exp $
*/
#ifndef _XP_STX_SYMBOL_H_
@ -16,6 +16,9 @@ xp_stx_word_t xp_stx_new_symbol (xp_stx_t* stx, const xp_stx_char_t* name);
xp_stx_word_t xp_stx_new_symbol_pp (
xp_stx_t* stx, const xp_stx_char_t* name,
const xp_stx_char_t* prefix, const xp_stx_char_t* postfix);
void xp_stx_traverse_symbol_table (
xp_stx_t* stx, void (*func) (xp_stx_t*,xp_stx_word_t));
#ifdef __cplusplus
}

21
ase/test/stx/stx.c
View File

@ -2,10 +2,20 @@
#include <xp/bas/stdio.h>
#include <xp/stx/object.h>
#include <xp/stx/symbol.h>
#include <xp/stx/context.h>
#include <xp/stx/hash.h>
void print_symbol_names (xp_stx_t* stx, xp_stx_word_t idx)
void print_symbol_names (xp_stx_t* stx, xp_stx_word_t sym)
{
/*
xp_stx_word_t key = XP_STX_AT(stx,idx,1);
xp_printf (XP_TEXT("%u -> %s\n"), key, &XP_STX_CHARAT(stx,key,0));
*/
xp_printf (XP_TEXT("%u -> %s\n"), sym, &XP_STX_CHARAT(stx,sym,0));
}
void print_symbol_names_2 (xp_stx_t* stx, xp_stx_word_t idx)
{
xp_stx_word_t key = XP_STX_AT(stx,idx,1);
xp_printf (XP_TEXT("%u -> %s\n"), key, &XP_STX_CHARAT(stx,key,0));
@ -35,8 +45,13 @@ int xp_main (int argc, xp_char_t* argv[])
xp_printf (XP_TEXT("stx.nil %d\n"), stx.nil);
xp_printf (XP_TEXT("stx.true %d\n"), stx.true);
xp_printf (XP_TEXT("stx.false %d\n"), stx.false);
xp_printf (XP_TEXT("-------------\n"));
xp_stx_hash_traverse (&stx, stx.symbol_table, print_symbol_names);
xp_stx_traverse_symbol_table (&stx, print_symbol_names);
xp_printf (XP_TEXT("-------------\n"));
xp_stx_hash_traverse (&stx, stx.smalltalk, print_symbol_names_2);
xp_printf (XP_TEXT("-------------\n"));
{
xp_stx_word_t class_name, method_name;
@ -46,7 +61,7 @@ int xp_main (int argc, xp_char_t* argv[])
class_name = xp_stx_new_symbol (&stx,argv[1]);
method_name = xp_stx_new_symbol (&stx,XP_STX_TEXT("main"));
if (xp_stx_lookup_global (&stx,class_name, &main_class) == -1) {
if (xp_stx_lookup_global (&stx,class_name,&main_class) == -1) {
xp_printf (XP_TEXT("non-existent class: %s\n"), argv[1]);
return -1;
}