dfsch_object_t* dfsch_make_class(dfsch_object_t* superclass,
char* name,
dfsch_object_t* slots){
class_t* klass = (class_t*)dfsch_make_object(DFSCH_CLASS_TYPE);
klass->standard_type.name = name;
klass->standard_type.slots = make_slots(slots);
klass->standard_type.flags = DFSCH_TYPEF_USER_EXTENSIBLE;
if (superclass){
class_t* super = DFSCH_ASSERT_INSTANCE(superclass,
DFSCH_CLASS_TYPE);
klass->standard_type.superclass = (dfsch_type_t*)super;
klass->standard_type.size =
adjust_sizes(klass->standard_type.slots,
klass->standard_type.superclass->size);
klass->initvalues = super->initvalues;
klass->initargs = super->initargs;
} else {
klass->standard_type.superclass = NULL;
klass->standard_type.size = adjust_sizes(klass->standard_type.slots,
sizeof(dfsch_object_t));
}
klass->standard_type.write = instance_write;
/* klass->standard_type.equal_p = class_equal_p;
klass->standard_type.apply = class_apply;
klass->standard_type.hash = class_hash;*/
return (dfsch_object_t*)klass;
}
dfsch_object_t* dfsch_string_output_port(){
string_output_port_t* port =
(string_output_port_t*)dfsch_make_object((dfsch_type_t*)
DFSCH_STRING_OUTPUT_PORT_TYPE);
port->mutex = create_finalized_mutex();
port->list = sl_create();
return (dfsch_object_t*)port;
}
dfsch_object_t* dfsch_make_instance(dfsch_object_t* klass,
dfsch_object_t* args){
dfsch_object_t* obj;
class_t* c = DFSCH_ASSERT_INSTANCE(klass, DFSCH_CLASS_TYPE);
obj = dfsch_make_object((dfsch_type_t*)c);
call_initialize_instance(obj, c, args);
return obj;
}
dfsch_object_t* dfsch_tcl_make_interpreter(Tcl_Interp* interp){
interpreter_t* i
= (interpreter_t*)dfsch_make_object(DFSCH_TCL_INTERPRETER_TYPE);
i->interpreter = interp;
i->active = 1;
i->owner = dfsch__get_thread_info();
GC_register_finalizer(i, (GC_finalization_proc)interpreter_finalizer,
NULL, NULL, NULL);
return (dfsch_object_t*)i;
}
dfsch_object_t* dfsch_string_input_port(char* buf, size_t len){
string_input_port_t* port =
(string_input_port_t*)dfsch_make_object((dfsch_type_t*)
DFSCH_STRING_INPUT_PORT_TYPE);
port->buf = buf;
port->len = len;
port->cur = 0;
port->mutex = create_finalized_mutex();
return (dfsch_object_t*)port;
}
dfsch_object_t* dfsch_tcl_wrap_command(char* name,
dfsch_object_t* interp){
command_wrapper_t* cw
= (command_wrapper_t*)dfsch_make_object(DFSCH_TCL_COMMAND_WRAPPER_TYPE);
if (interp) {
cw->interpreter = interpreter(interp);
} else {
cw->interpreter = NULL;
}
cw->name = name;
return (dfsch_object_t*)cw;
}
dfsch_object_t* dfsch_regex_compile(char* expression, int flags){
dfsch_regex_t* r = (dfsch_regex_t*)dfsch_make_object(®ex_type);
regex_compile(&(r->regex), expression, flags);
if ((flags & REG_NOSUB) == REG_NOSUB){
r->sub_count = 0;
}else{
r->sub_count = get_sub_count(expression, flags);
}
GC_REGISTER_FINALIZER(r, (GC_finalization_proc)regex_finalizer,
NULL, NULL, NULL);
return (dfsch_object_t*)r;
}
dfsch_object_t* dfsch_make_file_port(FILE* file, int close, char* name){
file_port_t* port = (file_port_t*)dfsch_make_object((dfsch_type_t*)
DFSCH_FILE_PORT_TYPE);
port->file = file;
port->close = close;
port->name = name;
port->open = 1; /* Creating closed ports makes no sense */
if (close){
GC_REGISTER_FINALIZER(port, (GC_finalization_proc)file_port_finalizer,
NULL, NULL, NULL);
}
return (dfsch_object_t*)port;
}
static dfsch_object_t* spawn_port(dfsch_object_t* klass,
char* cmd_line){
process_port_t* p = dfsch_make_object(klass);
p->cmd_line = cmd_line;
if (klass == DFSCH_PROCESS_INPUT_PORT_TYPE){
p->file = popen(cmd_line, "r");
} else {
p->file = popen(cmd_line, "w");
}
if (!p->file){
dfsch_error("Cannot spawn process",
dfsch_make_string_cstr(strerror(errno)));
}
GC_REGISTER_FINALIZER(p, (GC_finalization_proc)port_finalizer,
NULL, NULL, NULL);
p->open = 1;
return (dfsch_object_t*)p;
}
dfsch_object_t* creator = NULL;
sqlite3_database_t* db;
int created;
int busy_timeout;
dfsch_object_t* read_only = NULL;
struct stat s;
DFSCH_STRING_ARG_OPT(args, filename, ":memory:");
DFSCH_KEYWORD_PARSER_BEGIN(args);
DFSCH_KEYWORD_GENERIC("busy-timeout", busy_timeout, dfsch_number_to_long);
DFSCH_KEYWORD("creator", creator);
DFSCH_KEYWORD("read-only", read_only);
DFSCH_KEYWORD_PARSER_END(args);
DFSCH_ARG_END(args);
db = (sqlite3_database_t*)dfsch_make_object(&sqlite3_database_type);
GC_REGISTER_FINALIZER(db,
(GC_finalization_proc)database_finalizer,
NULL, NULL, NULL);
created = (stat(filename, &s)==-1 || !S_ISREG(s.st_mode));
if (sqlite3_open_v2(filename, &db->db,
SQLITE_OPEN_FULLMUTEX |
(read_only != NULL ?
SQLITE_OPEN_READONLY :
SQLITE_OPEN_READWRITE | (creator != NULL
? SQLITE_OPEN_CREATE
: 0)),
NULL) != SQLITE_OK){
dfsch_object_t* str = dfsch_make_string_cstr(sqlite3_errmsg(db->db));
dfsch_object_t* dfsch_make_decoded_time(){
return dfsch_make_object(&decoded_time_type);
}
