#include "Cello/Prelude.h" #include "Cello/Type.h" #include <string.h> var Bool = methods { methods_begin(Bool), method(Bool, Eq), method(Bool, Ord), method(Bool, Hash), method(Bool, AsChar), method(Bool, AsLong), method(Bool, AsDouble), method(Bool, AsStr), method(Bool, Show), methods_end(Bool) }; var Bool_Eq(var self, var obj) { return (var)(intptr_t)(self == obj); } var Bool_Gt(var self, var obj) { return (var)(intptr_t)(self > obj); } var Bool_Lt(var self, var obj) { return (var)(intptr_t)(self < obj); } long Bool_Hash(var self) {
#include "Cello/Exception.h" #include <stdlib.h> #include <string.h> var Dictionary = methods { methods_begin(Dictionary), method(Dictionary, New), method(Dictionary, Assign), method(Dictionary, Copy), method(Dictionary, Eq), method(Dictionary, Collection), method(Dictionary, Dict), method(Dictionary, Iter), method(Dictionary, Show), methods_end(Dictionary) }; var Dictionary_New(var self, va_list* args) { DictionaryData* dict = cast(self, Dictionary); dict->size = 1024; dict->keys = new(List, 0); dict->key_buckets = calloc(dict->size, sizeof(var)); dict->val_buckets = calloc(dict->size, sizeof(var)); for (int i = 0; i < dict->size; i++) { dict->key_buckets[i] = new(List, 0); dict->val_buckets[i] = new(List, 0); }
#include "Cello/File.h" #include "Cello/Exception.h" #include "Cello/Number.h" #include "Cello/String.h" var File = methods { methods_begin(File), method(File, New), method(File, With), method(File, Stream), method(File, Dict), method(File, Format), methods_end(File), }; var File_New(var self, va_list* args) { FileData* fd = cast(self, File); const char* filename = va_arg(*args, const char*); const char* access = va_arg(*args, const char*); stream_open(self, filename, access); return self; } var File_Delete(var self) { FileData* fd = cast(self, File); if (fd->f != NULL) { stream_close(self); } return self; } size_t File_Size(void) {
#include "Exception+.h" #include <stdlib.h> #include <string.h> var Table = methods { methods_begin(Table), method(Table, New), method(Table, Assign), method(Table, Copy), method(Table, Eq), method(Table, Collection), method(Table, Dict), method(Table, Iter), method(Table, Show), methods_end(Table) }; var Table_New(var self, va_list* args) { TableData* tab = cast(self, Table); tab->key_type = cast(va_arg(*args, var), Type); tab->val_type = cast(va_arg(*args, var), Type); tab->size = 1024; tab->keys = new(Array, tab->key_type, 0); tab->key_buckets = malloc(tab->size * sizeof(var)); tab->val_buckets = malloc(tab->size * sizeof(var)); if (tab->key_buckets == NULL) { throw(OutOfMemoryError, "Cannot create Table. Out of memory!"); }
return call_with(self, $(List, num, num, args, 0)); } var call_with(var self, var args) { Call* icall = type_class(type_of(self), Call); assert(icall->call_with); return icall->call_with(self, args); } var Function = methods { methods_begin(Function), method(Function, New), method(Function, Copy), method(Function, Assign), method(Function, Call), methods_end(Function), }; var Function_New(var self, va_list* args) { FunctionData* fd = cast(self, Function); fd->func = va_arg(*args, var); return self; } var Function_Delete(var self) { return self; } var Function_Copy(var self) { FunctionData* fd = cast(self, Function); return new(Function, fd->func);
return type_class_method(type_of(self), Vector, dot, self, obj); } float length(var self) { return type_class_method(type_of(self), Vector, length, self); } var Vec2 = methods { methods_begin(Vec2), method(Vec2, New), method(Vec2, Assign), method(Vec2, Copy), method(Vec2, Eq), method(Vec2, Show), method(Vec2, Vector), methods_end(Vec2) }; var Vec2_New(var self, var_list vl) { Vec2Data* v = cast(self, Vec2); v->x = as_double(var_list_get(vl)); v->y = as_double(var_list_get(vl)); return self; } var Vec2_Delete(var self) { return self; } size_t Vec2_Size(void) { return sizeof(Vec2Data);
#include "Cello/Channel.h" var Channel = methods { methods_begin(Channel), method(Channel, New), method(Channel, Push), methods_end(Channel) }; var Channel_New(var self, va_list* args) { ChannelData* co = cast(self, Channel); co->buffer_size = va_arg(*args, int); co->read_pos = 0; co->write_pos = 0; co->buffer = NULL; pthread_mutex_init(&co->mutex, NULL); pthread_cond_init(&co->read_ready_cond, NULL); pthread_cond_init(&co->write_ready_cond, NULL); if (co->buffer_size) { co->buffer = malloc(co->buffer_size * sizeof(*co->buffer)); } return self; } var Channel_Delete(var self) { ChannelData* co = cast(self, Channel); pthread_mutex_destroy(&co->mutex); pthread_cond_destroy(&co->read_ready_cond);
var Array = methods { methods_begin(Array), method(Array, New), method(Array, Assign), method(Array, Copy), method(Array, Eq), method(Array, Collection), method(Array, Push), method(Array, At), method(Array, Iter), method(Array, Reverse), method(Array, Append), method(Array, Sort), method(Array, Show), methods_end(Array) }; var Array_New(var self, va_list* args) { ArrayData* ad = cast(self, Array); ad->item_type = cast(va_arg(*args, var), Type); ad->num_items = 0; ad->num_slots = 0; ad->items = NULL; int count = va_arg(*args, int); for(int i = 0; i < count; i++) { push(self, va_arg(*args, var)); }
} var Int = methods { methods_begin(Int), method(Int, New), method(Int, Assign), method(Int, Copy), method(Int, Eq), method(Int, Ord), method(Int, Hash), method(Int, AsLong), method(Int, AsDouble), method(Int, Num), method(Int, Serialize), method(Int, Show), methods_end(Int) }; var Int_New(var self, va_list* args) { IntData* intdata = cast(self, Int); intdata->value = va_arg(*args, int); return self; } var Int_Delete(var self) { return self; } void Int_Assign(var self, var obj) { IntData* intdata = cast(self, Int); intdata->value = as_long(obj);
#include "Cello/Type.h" #include "Cello/Exception.h" #include <string.h> var Reference = methods { methods_begin(Reference), method(Reference, New), method(Reference, Assign), method(Reference, Copy), method(Reference, Eq), method(Reference, Hash), method(Reference, At), method(Reference, With), method(Reference, Show), methods_end(Reference) }; var Reference_New(var self, va_list* args) { ReferenceData* rd = cast(self, Reference); rd->ref = va_arg(*args, var); return rd; } var Reference_Delete(var self) { return self; } void Reference_Assign(var self, var obj) { ReferenceData* rd0 = cast(self, Reference); ReferenceData* rd1 = cast(obj, Reference);
#include "Tree+.h" #include "Array+.h" #include "Bool+.h" #include "None+.h" var Tree = methods { methods_begin(Tree), method(Tree, New), method(Tree, Assign), method(Tree, Copy), method(Tree, Collection), method(Tree, Dict), method(Tree, Iter), methods_end(Tree), }; var Tree_New(var self, va_list* args) { TreeData* td = cast(self, Tree); td->key_type = cast(va_arg(*args, var), Type); td->val_type = cast(va_arg(*args, var), Type); td->keys = new(Array, td->key_type, 0); td->root = NULL; return self; } var Tree_Delete(var self) { TreeData* td = cast(self, Tree); clear(self); delete(td->keys); return self;
#include "Type.h" #include "Bool.h" #include "Exception.h" #include "Number.h" #include "String.h" #include <string.h> var Type = methods { methods_begin(Type), method(Type, New), method(Type, AsStr), method(Type, Show), methods_end(Type), }; var Type_Cast(var obj, var t, const char* func, const char* file, int line) { if (type_of(obj) is t) { return obj; } else { return throw(TypeError, "Argument to function '%s' at '%s:%i' :: " "Got Type '%s' :: " "Expected Type '%s'", $(String, (char*)func), $(String, (char*)file), $(Int, line), type_of(obj), t); } }
var String = methods { methods_begin(String), method(String, New), method(String, Assign), method(String, Copy), method(String, Eq), method(String, Ord), method(String, Collection), method(String, Hash), method(String, Reverse), method(String, AsStr), method(String, Append), method(String, Format), method(String, Show), methods_end(String) }; var String_New(var self, va_list* args) { StringData* s = cast(self, String); const char* init = va_arg(*args, const char*); s->value = malloc(strlen(init) + 1); if (s->value == NULL) { throw(OutOfMemoryError, "Cannot allocate string, out of memory!"); } strcpy(s->value, init); return self; } var String_Delete(var self) { StringData* s = cast(self, String); free(s->value); return self;