Mailing List Archive

Author: creamyg
Date: 2008-09-06 17:54:25 -0700 (Sat, 06 Sep 2008)
New Revision: 3829

Added:
trunk/c_src/KinoSearch/Obj/VTable.bp
trunk/c_src/KinoSearch/Obj/VTable.c
trunk/perl/lib/KinoSearch/Obj/VTable.pm
Removed:
trunk/c_src/KinoSearch/Util/VirtualTable.bp
trunk/c_src/KinoSearch/Util/VirtualTable.c
trunk/perl/lib/KinoSearch/Util/VirtualTable.pm
Modified:
trunk/boilerplater/lib/Boilerplater/Binding/Perl.pm
trunk/boilerplater/lib/Boilerplater/Class.pm
trunk/c_src/KinoSearch/Obj.bp
trunk/c_src/KinoSearch/Obj.c
trunk/c_src/KinoSearch/Obj/FastObj.bp
trunk/c_src/KinoSearch/Obj/FastObj.c
trunk/c_src/KinoSearch/Obj/Undefined.c
trunk/c_src/KinoSearch/Posting/RawPosting.c
trunk/c_src/KinoSearch/Posting/RichPosting.c
trunk/c_src/KinoSearch/Posting/ScorePosting.c
trunk/c_src/KinoSearch/Search/MultiSearcher.c
trunk/c_src/KinoSearch/Search/PolyQuery.c
trunk/c_src/KinoSearch/Util/BitVector.c
trunk/c_src/KinoSearch/Util/ByteBuf.c
trunk/c_src/KinoSearch/Util/Carp.c
trunk/c_src/KinoSearch/Util/CharBuf.bp
trunk/c_src/KinoSearch/Util/CharBuf.c
trunk/c_src/KinoSearch/Util/DynVirtualTable.bp
trunk/c_src/KinoSearch/Util/DynVirtualTable.c
trunk/c_src/KinoSearch/Util/Freezer.c
trunk/c_src/KinoSearch/Util/Hash.c
trunk/c_src/KinoSearch/Util/Native.h
trunk/c_src/KinoSearch/Util/ToolSet.h
trunk/c_src/KinoSearch/Util/VArray.c
trunk/perl/MANIFEST
trunk/perl/buildlib/Lucy/Build.pm
trunk/perl/lib/KinoSearch/Obj.pm
trunk/perl/xs/KinoSearch/Obj.c
trunk/perl/xs/KinoSearch/Obj/FastObj.c
trunk/perl/xs/KinoSearch/Util/Native.c
trunk/perl/xs/XSBind.c
trunk/perl/xs/XSBind.h
Log:
Move KinoSearch::Util::VirtualTable to KinoSearch::Obj::VTable.


Modified: trunk/boilerplater/lib/Boilerplater/Binding/Perl.pm
===================================================================
--- trunk/boilerplater/lib/Boilerplater/Binding/Perl.pm 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/boilerplater/lib/Boilerplater/Binding/Perl.pm 2008-09-07 00:54:25 UTC (rev 3829)
@@ -593,7 +593,7 @@
next if $class->static;
my $vt_type = $PREFIX . $class->vtable_type;
$registrations
- .= qq| ${prefix}DynVT_add_to_registry((${prefix}VirtualTable*)|
+ .= qq| ${prefix}DynVT_add_to_registry((${prefix}VTable*)|
. qq|&$PREFIX|
. $class->vtable_var
. qq|);\n|;

Modified: trunk/boilerplater/lib/Boilerplater/Class.pm
===================================================================
--- trunk/boilerplater/lib/Boilerplater/Class.pm 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/boilerplater/lib/Boilerplater/Class.pm 2008-09-07 00:54:25 UTC (rev 3829)
@@ -127,7 +127,7 @@
sub get_parent { shift->{parent} }
sub static { shift->{static} }

-# The name of the global VirtualTable object for this class.
+# The name of the global VTable object for this class.
sub vtable_var { uc( shift->{struct_name} ) }

# The name of the global Callbacks list for this class.
@@ -142,7 +142,7 @@
my $class_name_len = length( $self->{class_name} );
return <<END_STUFF;
kino_ZombieCharBuf $full_var_name = {
- (kino_VirtualTable*)&KINO_ZOMBIECHARBUF,
+ (kino_VTable*)&KINO_ZOMBIECHARBUF,
{ 1 },
"$self->{class_name}",
$class_name_len,
@@ -352,9 +352,9 @@
$method_macros

typedef struct $vt_type {
- ${prefix}VirtualTable *_;
+ ${prefix}VTable *_;
boil_ref_t ref;
- ${prefix}VirtualTable *parent;
+ ${prefix}VTable *parent;
${prefix}CharBuf *name;
size_t obj_alloc_size;
size_t vt_alloc_size;
@@ -398,12 +398,12 @@
return <<END_VTABLE

$PREFIX$vt_type $PREFIX$vtable_var = {
- (${prefix}VirtualTable*)&${PREFIX}VIRTUALTABLE, /* vtable vtable */
+ (${prefix}VTable*)&${PREFIX}VTABLE, /* vtable vtable */
{ 1 }, /* fake ref.count */
- (${prefix}VirtualTable*)$parent_ref, /* parent */
+ (${prefix}VTable*)$parent_ref, /* parent */
(${prefix}CharBuf*)&${PREFIX}$name_var,
sizeof(${prefix}$self->{struct_name}), /* obj_alloc_size */
- offsetof(${prefix}VirtualTable, methods)
+ offsetof(${prefix}VTable, methods)
+ $num_methods * sizeof(${prefix}method_t), /* vt_alloc_size */
(kino_Callback**)&${PREFIX}${vtable_var}_CALLBACKS, /* callbacks */
{

Modified: trunk/c_src/KinoSearch/Obj/FastObj.bp
===================================================================
--- trunk/c_src/KinoSearch/Obj/FastObj.bp 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Obj/FastObj.bp 2008-09-07 00:54:25 UTC (rev 3829)
@@ -9,11 +9,11 @@
* rather than native object.
*/
incremented FastObj*
- Create(FastObj *invoker, const CharBuf *class_name, VirtualTable *vtable,
+ Create(FastObj *invoker, const CharBuf *class_name, VTable *vtable,
size_t alloc_size);

incremented FastObj*
- Foster(FastObj *invoker, const CharBuf *class_name, VirtualTable *vtable,
+ Foster(FastObj *invoker, const CharBuf *class_name, VTable *vtable,
size_t alloc_size, void *native_blank);

public incremented FastObj*

Modified: trunk/c_src/KinoSearch/Obj/FastObj.c
===================================================================
--- trunk/c_src/KinoSearch/Obj/FastObj.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Obj/FastObj.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -6,8 +6,8 @@
#include <string.h>

#include "KinoSearch/Obj/FastObj.h"
+#include "KinoSearch/Obj/VTable.h"
#include "KinoSearch/Store/InStream.h"
-#include "KinoSearch/Util/VirtualTable.h"
#include "KinoSearch/Util/DynVirtualTable.h"
#include "KinoSearch/Util/Carp.h"
#include "KinoSearch/Util/MemManager.h"
@@ -15,7 +15,7 @@

FastObj*
FastObj_create(FastObj *invoker, const CharBuf *class_name,
- VirtualTable *vtable, size_t alloc_size)
+ VTable *vtable, size_t alloc_size)
{
FastObj *self = (FastObj*)kino_MemMan_wrapped_calloc(alloc_size, 1);
UNUSED_VAR(invoker);
@@ -26,8 +26,8 @@
self->_ = REFCOUNT_INC(vtable);
}
else {
- VirtualTable *subclass_vtable
- = (VirtualTable*)DynVT_singleton((CharBuf*)class_name, vtable);
+ VTable *subclass_vtable
+ = (VTable*)DynVT_singleton((CharBuf*)class_name, vtable);
self->_ = REFCOUNT_INC(subclass_vtable);
}
self->ref.count = 1;

Modified: trunk/c_src/KinoSearch/Obj/Undefined.c
===================================================================
--- trunk/c_src/KinoSearch/Obj/Undefined.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Obj/Undefined.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -3,7 +3,7 @@
#include "KinoSearch/Util/DynVirtualTable.h"
#include "KinoSearch/Obj/Undefined.h"

-static Undefined the_undef_object = { (VirtualTable*)&UNDEFINED, {1} };
+static Undefined the_undef_object = { (VTable*)&UNDEFINED, {1} };
Undefined *UNDEF = &the_undef_object;

chy_u32_t

Copied: trunk/c_src/KinoSearch/Obj/VTable.bp (from rev 3824, trunk/c_src/KinoSearch/Util/VirtualTable.bp)
===================================================================
--- trunk/c_src/KinoSearch/Obj/VTable.bp (rev 0)
+++ trunk/c_src/KinoSearch/Obj/VTable.bp 2008-09-07 00:54:25 UTC (rev 3829)
@@ -0,0 +1,56 @@
+parcel KinoSearch cnick Kino;
+
+/** Virtual method dispatch table.
+ *
+ * VTables, which are the first element in any KS object, are actually
+ * objects themselves. (Their first element is a VTable which describes the
+ * behavior of VTables.)
+ *
+ * Unlike most other objects, though, VTables are meant to be
+ * persistent throughout the life of the process. They are not refcounted,
+ * and attempting to call destroy() triggers an error.
+ *
+ * Dynamic subclasses should use DynVirtualTable instead.
+ */
+
+class KinoSearch::Obj::VTable extends KinoSearch::Obj::FastObj {
+
+ VTable *parent;
+ CharBuf *name;
+ size_t obj_alloc_size;
+ size_t vt_alloc_size;
+ Callback **callbacks;
+ kino_method_t[1] methods; /* flexible array */
+
+ CharBuf*
+ Get_Name(VTable *self);
+
+ incremented VTable*
+ Clone(VTable *self);
+
+ void
+ Destroy(VTable *self);
+}
+
+__C__
+#define KINO_CALLBACK_DEC(_name, _func, _offset) \
+ { (kino_VTable*)&KINO_CALLBACK, {1}, _name, sizeof(_name) - 1, \
+ (kino_method_t)_func, _offset }
+#ifdef KINO_USE_SHORT_NAMES
+ #define CALLBACK_DEC KINO_CALLBACK_DEC
+#endif
+__END_C__
+
+class KinoSearch::Util::Callback extends KinoSearch::Obj::FastObj {
+ const char *name;
+ size_t name_len;
+ kino_method_t func;
+ size_t offset;
+}
+
+/* Copyright 2006-2008 Marvin Humphrey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * under the same terms as Perl itself.
+ */
+

Copied: trunk/c_src/KinoSearch/Obj/VTable.c (from rev 3824, trunk/c_src/KinoSearch/Util/VirtualTable.c)
===================================================================
--- trunk/c_src/KinoSearch/Obj/VTable.c (rev 0)
+++ trunk/c_src/KinoSearch/Obj/VTable.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -0,0 +1,50 @@
+#define KINO_USE_SHORT_NAMES
+#define CHY_USE_SHORT_NAMES
+
+#include <string.h>
+
+#include "KinoSearch/Obj/VTable.h"
+#include "KinoSearch/Util/Carp.h"
+#include "KinoSearch/Util/CharBuf.h"
+#include "KinoSearch/Util/Hash.h"
+#include "KinoSearch/Util/MemManager.h"
+#include "KinoSearch/Search/ScoreDoc.h"
+
+void
+VTable_destroy(VTable *self)
+{
+ if (self->_ == (VTable*)&KINO_VTABLE) {
+ CONFESS("Attempt to destroy fixed vtable for class '%o'", self->name);
+ }
+ else {
+ REFCOUNT_DEC(self->name);
+ REFCOUNT_DEC(self->parent);
+ FREE_OBJ(self);
+ }
+}
+
+VTable*
+VTable_clone(VTable *self)
+{
+ VTable *evil_twin = (VTable*)FastObj_create(NULL, NULL,
+ self->_, self->vt_alloc_size);
+
+ memcpy(evil_twin, self, self->vt_alloc_size);
+ evil_twin->name = CB_Clone(self->name);
+ evil_twin->ref.count = 1;
+
+ if (evil_twin->parent != NULL)
+ (void)REFCOUNT_INC(evil_twin->parent);
+
+ return evil_twin;
+}
+
+CharBuf*
+VTable_get_name(VTable *self) { return self->name; }
+
+/* Copyright 2006-2008 Marvin Humphrey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * under the same terms as Perl itself.
+ */
+

Modified: trunk/c_src/KinoSearch/Obj.bp
===================================================================
--- trunk/c_src/KinoSearch/Obj.bp 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Obj.bp 2008-09-07 00:54:25 UTC (rev 3829)
@@ -5,7 +5,7 @@

class KinoSearch::Obj {

- VirtualTable *_;
+ VTable *_;
boil_ref_t ref;

/** Abstract initializer.
@@ -22,18 +22,18 @@
* @param invoker Ignored; may be NULL.
* @param class_name The class the object should be blessed into.
* May be NULL.
- * @param vtable The VirtualTable to either use or subclass.
+ * @param vtable The VTable to either use or subclass.
* @param alloc_size The number of bytes to allocate to the object.
*/
incremented Obj*
- Create(Obj *invoker, const CharBuf *class_name, VirtualTable *vtable,
+ Create(Obj *invoker, const CharBuf *class_name, VTable *vtable,
size_t alloc_size);

/* Alternate constructor, akin to create(), but which takes uses a
* pre-supplied native object rather than creating one ex nihilo.
*/
incremented Obj*
- Foster(Obj *self, const CharBuf *class_name, VirtualTable *vtable,
+ Foster(Obj *self, const CharBuf *class_name, VTable *vtable,
size_t alloc_size, void *native_blank);

/* Return an object's refcount.
@@ -83,9 +83,9 @@
i32_t
Hash_Code(Obj *self);

- /** Return the object's VirtualTable.
+ /** Return the object's VTable.
*/
- VirtualTable*
+ VTable*
Get_VTable(Obj *self);

/** Return the name of the class that the object belongs to.
@@ -97,7 +97,7 @@
* name.
*/
bool_t
- Is_A(Obj *self, VirtualTable *target_vtable);
+ Is_A(Obj *self, VTable *target_vtable);

/* Generic stringification: ClassName@hex_mem_address
*/
@@ -132,7 +132,7 @@
((kino_Obj_create_t) \
kino_Obj_method_ptr(&_vtable, Kino_Obj_Create_OFFSET) \
) \
- (NULL, _class_name, (kino_VirtualTable*)&_vtable, _vtable.obj_alloc_size) \
+ (NULL, _class_name, (kino_VTable*)&_vtable, _vtable.obj_alloc_size) \
)

#define KINO_FOSTER(_class_name, _vtable, _nat_obj) \
@@ -140,7 +140,7 @@
((kino_Obj_foster_t) \
kino_Obj_method_ptr(&_vtable, Kino_Obj_Foster_OFFSET) \
) \
- (NULL, _class_name, (kino_VirtualTable*)&_vtable, \
+ (NULL, _class_name, (kino_VTable*)&_vtable, \
_vtable.obj_alloc_size, _nat_obj) \
)

@@ -154,11 +154,11 @@
#define KINO_ABSTRACT_CLASS_CHECK(_self, _vtable) \
do { \
kino_Obj *const _obj = (kino_Obj*)_self; \
- kino_VirtualTable *const _vt = (kino_VirtualTable*)&_vtable; \
+ kino_VTable *const _vt = (kino_VTable*)&_vtable; \
if (_obj->_ == _vt) { \
KINO_REFCOUNT_DEC(_obj); \
KINO_CONFESS("%o is an abstract class", \
- Kino_VirtualTable_Get_Name(_vt)); \
+ Kino_VTable_Get_Name(_vt)); \
} \
} while (0)

@@ -193,7 +193,7 @@
* the vtable.
*/
#define KINO_OBJ_IS_A(var, vtable) \
- (Kino_Obj_Is_A(var, (kino_VirtualTable*)&vtable))
+ (Kino_Obj_Is_A(var, (kino_VTable*)&vtable))

/* Access the function pointer for a given method from the vtable.
*/

Modified: trunk/c_src/KinoSearch/Obj.c
===================================================================
--- trunk/c_src/KinoSearch/Obj.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Obj.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -6,7 +6,7 @@
#include <string.h>

#include "KinoSearch/Obj.h"
-#include "KinoSearch/Util/VirtualTable.h"
+#include "KinoSearch/Obj/VTable.h"
#include "KinoSearch/Util/DynVirtualTable.h"
#include "KinoSearch/Util/Carp.h"
#include "KinoSearch/Util/CharBuf.h"
@@ -36,9 +36,9 @@
}

bool_t
-Obj_is_a(Obj *self, VirtualTable *target_vtable)
+Obj_is_a(Obj *self, VTable *target_vtable)
{
- VirtualTable *vtable = self ? self->_ : NULL;
+ VTable *vtable = self ? self->_ : NULL;

while (vtable != NULL) {
if (vtable == target_vtable)
@@ -83,7 +83,7 @@
return Native_callback_str(self, "_to_string", 0);
}

-VirtualTable*
+VTable*
Obj_get_vtable(Obj *self) { return self->_; }
CharBuf*
Obj_get_class_name(Obj *self) { return self->_->name; }

Modified: trunk/c_src/KinoSearch/Posting/RawPosting.c
===================================================================
--- trunk/c_src/KinoSearch/Posting/RawPosting.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Posting/RawPosting.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -7,7 +7,7 @@
#include "KinoSearch/Util/StringHelper.h"

RawPosting KINO_RAWPOSTING_BLANK = {
- (kino_VirtualTable*)&RAWPOSTING,
+ (kino_VTable*)&RAWPOSTING,
{0},
0, /* doc_num */
1, /* freq */
@@ -22,7 +22,7 @@
char *term_text, size_t term_text_len)
{
RawPosting *self = (RawPosting*)pre_allocated_memory;
- self->_ = (kino_VirtualTable*)&RAWPOSTING;
+ self->_ = (kino_VTable*)&RAWPOSTING;
self->ref.count = 1; /* never used */
self->doc_num = doc_num;
self->freq = freq;

Modified: trunk/c_src/KinoSearch/Posting/RichPosting.c
===================================================================
--- trunk/c_src/KinoSearch/Posting/RichPosting.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Posting/RichPosting.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -46,7 +46,7 @@
RichPosting*
RichPost_clone(RichPosting *self)
{
- VirtualTable *vtable = self->_;
+ VTable *vtable = self->_;
RichPosting *evil_twin = (RichPosting*)CREATE(NULL, (*vtable));
evil_twin = RichPost_init(evil_twin, self->sim);


Modified: trunk/c_src/KinoSearch/Posting/ScorePosting.c
===================================================================
--- trunk/c_src/KinoSearch/Posting/ScorePosting.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Posting/ScorePosting.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -45,7 +45,7 @@
ScorePosting*
ScorePost_clone(ScorePosting *self)
{
- VirtualTable *vtable = self->_;
+ VTable *vtable = self->_;
ScorePosting *evil_twin = (ScorePosting*)CREATE(NULL, (*vtable));
ScorePost_init(evil_twin, self->sim);


Modified: trunk/c_src/KinoSearch/Search/MultiSearcher.c
===================================================================
--- trunk/c_src/KinoSearch/Search/MultiSearcher.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Search/MultiSearcher.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -39,9 +39,9 @@
CONFESS("Not a Searchable");
}
else {
- Schema *candidate = Searchable_Get_Schema(searchable);
- VirtualTable *orig_vt = Obj_Get_VTable(schema);
- VirtualTable *candidate_vt = Obj_Get_VTable(candidate);
+ Schema *candidate = Searchable_Get_Schema(searchable);
+ VTable *orig_vt = Obj_Get_VTable(schema);
+ VTable *candidate_vt = Obj_Get_VTable(candidate);

/* Confirm that searchables all use the same schema. */
if (orig_vt != candidate_vt) {

Modified: trunk/c_src/KinoSearch/Search/PolyQuery.c
===================================================================
--- trunk/c_src/KinoSearch/Search/PolyQuery.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Search/PolyQuery.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -176,8 +176,7 @@
{
CharBuf *class_name = CB_deserialize(NULL, instream);
if (!self) {
- VirtualTable *vtable
- = (VirtualTable*)DynVT_singleton(class_name, NULL);
+ VTable *vtable = (VTable*)DynVT_singleton(class_name, NULL);
Obj_create_t create = (Obj_create_t)METHOD_PTR(vtable, Obj, Create);
self = (PolyCompiler*)create(NULL, NULL, vtable,
vtable->obj_alloc_size);

Modified: trunk/c_src/KinoSearch/Util/BitVector.c
===================================================================
--- trunk/c_src/KinoSearch/Util/BitVector.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/BitVector.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -85,7 +85,7 @@
u32_t byte_size = (u32_t)ceil(self->cap / 8.0);

/* Forbid inheritance. */
- if (self->_ != (kino_VirtualTable*)&BITVECTOR)
+ if (self->_ != (kino_VTable*)&BITVECTOR)
CONFESS("Attempt by %o to inherit BitVec_Clone", Obj_Get_Class_Name(self));

memcpy(evil_twin->bits, self->bits, byte_size * sizeof(u8_t));

Modified: trunk/c_src/KinoSearch/Util/ByteBuf.c
===================================================================
--- trunk/c_src/KinoSearch/Util/ByteBuf.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/ByteBuf.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -5,7 +5,7 @@
#include <stdio.h>
#include <ctype.h>

-#include "KinoSearch/Util/VirtualTable.h"
+#include "KinoSearch/Obj/VTable.h"
#include "KinoSearch/Util/ByteBuf.h"

#include "KinoSearch/Store/InStream.h"

Modified: trunk/c_src/KinoSearch/Util/Carp.c
===================================================================
--- trunk/c_src/KinoSearch/Util/Carp.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/Carp.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -6,7 +6,7 @@
#include <ctype.h>

#include "KinoSearch/Util/Carp.h"
-#include "KinoSearch/Util/VirtualTable.h"
+#include "KinoSearch/Obj/VTable.h"
#include "KinoSearch/Util/CharBuf.h"

/* Fallbacks in case variadic macros aren't available. */

Modified: trunk/c_src/KinoSearch/Util/CharBuf.bp
===================================================================
--- trunk/c_src/KinoSearch/Util/CharBuf.bp 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/CharBuf.bp 2008-09-07 00:54:25 UTC (rev 3829)
@@ -342,9 +342,9 @@
#define KINO_CBEND(self) ((self)->ptr + (self)->size)

#define KINO_ZCB_BLANK \
- { (kino_VirtualTable*)&KINO_ZOMBIECHARBUF, {1}, "", 0, 0 }
+ { (kino_VTable*)&KINO_ZOMBIECHARBUF, {1}, "", 0, 0 }
#define KINO_ZCB_LITERAL(string) \
- { (kino_VirtualTable*)&KINO_ZOMBIECHARBUF, {1}, string "", \
+ { (kino_VTable*)&KINO_ZOMBIECHARBUF, {1}, string "", \
sizeof(string) -1, sizeof(string) }

extern const kino_ZombieCharBuf KINO_ZCB_EMPTY;
@@ -356,7 +356,7 @@
{
kino_ZombieCharBuf retval;
retval.ref.count = 1;
- retval._ = (kino_VirtualTable*)&KINO_ZOMBIECHARBUF;
+ retval._ = (kino_VTable*)&KINO_ZOMBIECHARBUF;
retval.cap = 0;
retval.size = size;
retval.ptr = ptr;

Modified: trunk/c_src/KinoSearch/Util/CharBuf.c
===================================================================
--- trunk/c_src/KinoSearch/Util/CharBuf.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/CharBuf.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -5,7 +5,7 @@
#include <stdio.h>
#include <ctype.h>

-#include "KinoSearch/Util/VirtualTable.h"
+#include "KinoSearch/Obj/VTable.h"
#include "KinoSearch/Util/CharBuf.h"

#include "KinoSearch/Store/InStream.h"
@@ -708,7 +708,7 @@
ZombieCharBuf*
CB_iter_init(CharBuf *self, ZombieCharBuf *target)
{
- target->_ = (VirtualTable*)&ZOMBIECHARBUF;
+ target->_ = (VTable*)&ZOMBIECHARBUF;
ZCB_Assign(target, self);
return target;
}

Modified: trunk/c_src/KinoSearch/Util/DynVirtualTable.bp
===================================================================
--- trunk/c_src/KinoSearch/Util/DynVirtualTable.bp 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/DynVirtualTable.bp 2008-09-07 00:54:25 UTC (rev 3829)
@@ -1,9 +1,9 @@
parcel KinoSearch cnick Kino;

class KinoSearch::Util::DynVirtualTable cnick DynVT
- extends KinoSearch::Util::VirtualTable {
+ extends KinoSearch::Obj::VTable {

- /* Note: there cannot be more member vars since VirtualTable stores
+ /* Note: there cannot be more member vars since VTable stores
* methods in a flexible array.
*/

@@ -16,7 +16,7 @@
* result.
*/
static DynVirtualTable*
- singleton(const CharBuf *subclass_name, VirtualTable *parent);
+ singleton(const CharBuf *subclass_name, VTable *parent);

/** Replace a function pointer in the VTable.
*/
@@ -25,23 +25,23 @@

/* Register a vtable, so that it can be retrieved by class name.
*
- * Note that this function takes a VirtualTable rather than a
+ * Note that this function takes a VTable rather than a
* DynVirtualTable. TODO: Move this functionality to some kind of class
* loader.
*/
static void
- add_to_registry(VirtualTable *vtable);
+ add_to_registry(VTable *vtable);

/* Find a registered class and return its vtable. May return NULL if the
* class is not registered.
*/
- static VirtualTable*
+ static VTable*
fetch_vtable(const CharBuf *class_name);

/* Given a class name, return the vtable belonging to a parent class, or NULL
* if such a vtable can't be found.
*/
- static VirtualTable*
+ static VTable*
find_parent_vtable(const CharBuf *class_name);

/* Initialize the registry hash.

Modified: trunk/c_src/KinoSearch/Util/DynVirtualTable.c
===================================================================
--- trunk/c_src/KinoSearch/Util/DynVirtualTable.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/DynVirtualTable.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -28,7 +28,7 @@
/* Constructor. Returns singletons, keyed by class name.
*/
DynVirtualTable*
-DynVT_singleton(const CharBuf *subclass_name, VirtualTable *parent)
+DynVT_singleton(const CharBuf *subclass_name, VTable *parent)
{
DynVirtualTable *singleton;

@@ -52,9 +52,9 @@
}

/* Copy source vtable. */
- singleton = (DynVirtualTable*)VirtualTable_Clone(parent);
+ singleton = (DynVirtualTable*)VTable_Clone(parent);
REFCOUNT_DEC(singleton->_);
- singleton->_ = (VirtualTable*)REFCOUNT_INC(&DYNVIRTUALTABLE);
+ singleton->_ = (VTable*)REFCOUNT_INC(&DYNVIRTUALTABLE);

/* Turn clone into child. */
REFCOUNT_DEC(singleton->parent);
@@ -124,10 +124,10 @@
pointer.func_ptr[0] = method;
}

-VirtualTable*
+VTable*
DynVT_find_parent_vtable(const CharBuf *class_name)
{
- return (VirtualTable*)Native_callback_obj(&DYNVIRTUALTABLE,
+ return (VTable*)Native_callback_obj(&DYNVIRTUALTABLE,
"find_parent_vtable", 1, ARG_STR("class_name", class_name));
}

@@ -146,17 +146,17 @@
if (self->parent && (REFCOUNT(self->parent) == 2)) {
remove_from_registry(self->parent->name);
}
- kino_VirtualTable_destroy((kino_VirtualTable*)self);
+ kino_VTable_destroy((kino_VTable*)self);
}

void
-DynVT_add_to_registry(VirtualTable *vtable)
+DynVT_add_to_registry(VTable *vtable)
{
- VirtualTable *fetched;
+ VTable *fetched;

if (DynVT_registry == NULL)
DynVT_init_registry();
- fetched = (VirtualTable*)Hash_Fetch(DynVT_registry, vtable->name);
+ fetched = (VTable*)Hash_Fetch(DynVT_registry, vtable->name);
if (fetched) {
if (fetched != vtable) {
CONFESS("Attempt to redefine a vtable for '%o'",
@@ -168,12 +168,12 @@
}
}

-VirtualTable*
+VTable*
DynVT_fetch_vtable(const CharBuf *class_name)
{
- VirtualTable *vtable = NULL;
+ VTable *vtable = NULL;
if (DynVT_registry != NULL) {
- vtable = (VirtualTable*)Hash_Fetch(DynVT_registry, class_name);
+ vtable = (VTable*)Hash_Fetch(DynVT_registry, class_name);
}
return vtable;
}

Modified: trunk/c_src/KinoSearch/Util/Freezer.c
===================================================================
--- trunk/c_src/KinoSearch/Util/Freezer.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/Freezer.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -18,7 +18,7 @@
Freezer_thaw(InStream *instream)
{
CharBuf *class_name = CB_deserialize(NULL, instream);
- VirtualTable *vtable = (VirtualTable*)DynVT_singleton(class_name, NULL);
+ VTable *vtable = (VTable*)DynVT_singleton(class_name, NULL);
Obj_create_t create = (Obj_create_t)METHOD_PTR(vtable, Obj, Create);
Obj *blank = create(NULL, NULL, vtable, vtable->obj_alloc_size);
REFCOUNT_DEC(class_name);

Modified: trunk/c_src/KinoSearch/Util/Hash.c
===================================================================
--- trunk/c_src/KinoSearch/Util/Hash.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/Hash.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -4,7 +4,7 @@
#include <string.h>
#include <stdarg.h>

-#include "KinoSearch/Util/VirtualTable.h"
+#include "KinoSearch/Obj/VTable.h"

#include "KinoSearch/Util/Hash.h"
#include "KinoSearch/Obj/Undefined.h"

Modified: trunk/c_src/KinoSearch/Util/Native.h
===================================================================
--- trunk/c_src/KinoSearch/Util/Native.h 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/Native.h 2008-09-07 00:54:25 UTC (rev 3829)
@@ -11,7 +11,7 @@
* The first argument is void* to avoid the need for tiresome casting to Obj*,
* but must always be a KS object.
*
- * If the invoker is a VirtualTable, it will be used to make a class
+ * If the invoker is a VTable, it will be used to make a class
* callback rather than an object callback.
*/


Modified: trunk/c_src/KinoSearch/Util/ToolSet.h
===================================================================
--- trunk/c_src/KinoSearch/Util/ToolSet.h 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/ToolSet.h 2008-09-07 00:54:25 UTC (rev 3829)
@@ -19,11 +19,11 @@
#include "KinoSearch/Obj.h"
#include "KinoSearch/Obj/FastObj.h"
#include "KinoSearch/Obj/Undefined.h"
+#include "KinoSearch/Obj/VTable.h"
#include "KinoSearch/Util/Carp.h"
#include "KinoSearch/Util/MathUtils.h"
#include "KinoSearch/Util/MemManager.h"
#include "KinoSearch/Util/StringHelper.h"
-#include "KinoSearch/Util/VirtualTable.h"
#include "KinoSearch/Util/DynVirtualTable.h"
#include "KinoSearch/Util/CharBuf.h"
#include "KinoSearch/Util/VArray.h"

Modified: trunk/c_src/KinoSearch/Util/VArray.c
===================================================================
--- trunk/c_src/KinoSearch/Util/VArray.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/VArray.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -3,7 +3,7 @@
#define KINO_USE_SHORT_NAMES
#define CHY_USE_SHORT_NAMES

-#include "KinoSearch/Util/VirtualTable.h"
+#include "KinoSearch/Obj/VTable.h"
#include "KinoSearch/Util/VArray.h"
#include "KinoSearch/Util/Carp.h"
#include "KinoSearch/Util/MemManager.h"

Deleted: trunk/c_src/KinoSearch/Util/VirtualTable.bp
===================================================================
--- trunk/c_src/KinoSearch/Util/VirtualTable.bp 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/VirtualTable.bp 2008-09-07 00:54:25 UTC (rev 3829)
@@ -1,56 +0,0 @@
-parcel KinoSearch cnick Kino;
-
-/** Virtual method dispatch table.
- *
- * VirtualTables, which are the first element in any KS object, are actually
- * objects themselves. (Their first element is a vtable which describes the
- * behavior of VirtualTables.)
- *
- * Unlike most other objects, though, VirtualTables are meant to be
- * persistent throughout the life of the process. They are not refcounted,
- * and attempting to call destroy() triggers an error.
- *
- * Dynamic subclasses should use DynVirtualTable instead.
- */
-
-class KinoSearch::Util::VirtualTable extends KinoSearch::Obj::FastObj {
-
- VirtualTable *parent;
- CharBuf *name;
- size_t obj_alloc_size;
- size_t vt_alloc_size;
- Callback **callbacks;
- kino_method_t[1] methods; /* flexible array */
-
- CharBuf*
- Get_Name(VirtualTable *self);
-
- incremented VirtualTable*
- Clone(VirtualTable *self);
-
- void
- Destroy(VirtualTable *self);
-}
-
-__C__
-#define KINO_CALLBACK_DEC(_name, _func, _offset) \
- { (kino_VirtualTable*)&KINO_CALLBACK, {1}, _name, sizeof(_name) - 1, \
- (kino_method_t)_func, _offset }
-#ifdef KINO_USE_SHORT_NAMES
- #define CALLBACK_DEC KINO_CALLBACK_DEC
-#endif
-__END_C__
-
-class KinoSearch::Util::Callback extends KinoSearch::Obj::FastObj {
- const char *name;
- size_t name_len;
- kino_method_t func;
- size_t offset;
-}
-
-/* Copyright 2006-2008 Marvin Humphrey
- *
- * This program is free software; you can redistribute it and/or modify
- * under the same terms as Perl itself.
- */
-

Deleted: trunk/c_src/KinoSearch/Util/VirtualTable.c
===================================================================
--- trunk/c_src/KinoSearch/Util/VirtualTable.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/c_src/KinoSearch/Util/VirtualTable.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -1,50 +0,0 @@
-#define KINO_USE_SHORT_NAMES
-#define CHY_USE_SHORT_NAMES
-
-#include <string.h>
-
-#include "KinoSearch/Util/VirtualTable.h"
-#include "KinoSearch/Util/Carp.h"
-#include "KinoSearch/Util/CharBuf.h"
-#include "KinoSearch/Util/Hash.h"
-#include "KinoSearch/Util/MemManager.h"
-#include "KinoSearch/Search/ScoreDoc.h"
-
-void
-VirtualTable_destroy(VirtualTable *self)
-{
- if (self->_ == (VirtualTable*)&KINO_VIRTUALTABLE) {
- CONFESS("Attempt to destroy fixed vtable for class '%o'", self->name);
- }
- else {
- REFCOUNT_DEC(self->name);
- REFCOUNT_DEC(self->parent);
- FREE_OBJ(self);
- }
-}
-
-VirtualTable*
-VirtualTable_clone(VirtualTable *self)
-{
- VirtualTable *evil_twin = (VirtualTable*)FastObj_create(NULL, NULL,
- self->_, self->vt_alloc_size);
-
- memcpy(evil_twin, self, self->vt_alloc_size);
- evil_twin->name = CB_Clone(self->name);
- evil_twin->ref.count = 1;
-
- if (evil_twin->parent != NULL)
- (void)REFCOUNT_INC(evil_twin->parent);
-
- return evil_twin;
-}
-
-CharBuf*
-VirtualTable_get_name(VirtualTable *self) { return self->name; }
-
-/* Copyright 2006-2008 Marvin Humphrey
- *
- * This program is free software; you can redistribute it and/or modify
- * under the same terms as Perl itself.
- */
-

Modified: trunk/perl/MANIFEST
===================================================================
--- trunk/perl/MANIFEST 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/perl/MANIFEST 2008-09-07 00:54:25 UTC (rev 3829)
@@ -72,6 +72,7 @@
lib/KinoSearch/InvIndexer.pm
lib/KinoSearch/Obj.pm
lib/KinoSearch/Obj/FastObj.pm
+lib/KinoSearch/Obj/VTable.pm
lib/KinoSearch/Posting.pm
lib/KinoSearch/Posting/MatchPosting.pm
lib/KinoSearch/Posting/RichPosting.pm
@@ -164,7 +165,6 @@
lib/KinoSearch/Util/StringHelper.pm
lib/KinoSearch/Util/ToolSet.pm
lib/KinoSearch/Util/VArray.pm
-lib/KinoSearch/Util/VirtualTable.pm
lib/KSx/Remote/SearchClient.pm
lib/KSx/Remote/SearchServer.pm
lib/KSx/Search/Filter.pm

Modified: trunk/perl/buildlib/Lucy/Build.pm
===================================================================
--- trunk/perl/buildlib/Lucy/Build.pm 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/perl/buildlib/Lucy/Build.pm 2008-09-07 00:54:25 UTC (rev 3829)
@@ -645,7 +645,7 @@

CHARBUF_NOT_POINTER
\$var.ref.count = 1;
- \$var._ = (${prefix}VirtualTable*)&${PREFIX}ZOMBIECHARBUF;
+ \$var._ = (${prefix}VTable*)&${PREFIX}ZOMBIECHARBUF;
\$var.ptr = SvPVutf8_nolen(\$arg);
\$var.size = SvCUR(\$arg);


Copied: trunk/perl/lib/KinoSearch/Obj/VTable.pm (from rev 3824, trunk/perl/lib/KinoSearch/Util/VirtualTable.pm)
===================================================================
--- trunk/perl/lib/KinoSearch/Obj/VTable.pm (rev 0)
+++ trunk/perl/lib/KinoSearch/Obj/VTable.pm 2008-09-07 00:54:25 UTC (rev 3829)
@@ -0,0 +1,20 @@
+use KinoSearch;
+
+1;
+
+__END__
+
+__AUTO_XS__
+
+{ "KinoSearch::Obj::VTable" => {
+ bind_methods => [qw( Get_Name )],
+ }
+}
+
+__COPYRIGHT__
+
+Copyright 2007-2008 Marvin Humphrey
+
+This program is free software; you can redistribute it and/or modify
+under the same terms as Perl itself.
+

Modified: trunk/perl/lib/KinoSearch/Obj.pm
===================================================================
--- trunk/perl/lib/KinoSearch/Obj.pm 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/perl/lib/KinoSearch/Obj.pm 2008-09-07 00:54:25 UTC (rev 3829)
@@ -14,7 +14,7 @@
kino_CharBuf class_name;
CODE:
{
- kino_VirtualTable *target = kino_DynVT_fetch_vtable(&class_name);
+ kino_VTable *target = kino_DynVT_fetch_vtable(&class_name);
RETVAL = Kino_Obj_Is_A(self, target);
}
OUTPUT: RETVAL
@@ -72,7 +72,7 @@
kino_ViewFileDes *file_des = kino_ViewFileDes_new(ptr, len);
kino_InStream *instream = kino_InStream_new((kino_FileDes*)file_des);
kino_ZombieCharBuf class_name = sv_to_class_name(blank_obj);
- kino_VirtualTable *vtable = (kino_VirtualTable*)kino_DynVT_singleton(
+ kino_VTable *vtable = (kino_VTable*)kino_DynVT_singleton(
(kino_CharBuf*)&class_name, NULL);
kino_Obj *self = KINO_FOSTER(NULL, (*vtable), blank_obj);
kino_Obj *deserialized = Kino_Obj_Deserialize(self, instream);

Deleted: trunk/perl/lib/KinoSearch/Util/VirtualTable.pm
===================================================================
--- trunk/perl/lib/KinoSearch/Util/VirtualTable.pm 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/perl/lib/KinoSearch/Util/VirtualTable.pm 2008-09-07 00:54:25 UTC (rev 3829)
@@ -1,20 +0,0 @@
-use KinoSearch;
-
-1;
-
-__END__
-
-__AUTO_XS__
-
-{ "KinoSearch::Util::VirtualTable" => {
- bind_methods => [qw( Get_Name )],
- }
-}
-
-__COPYRIGHT__
-
-Copyright 2007-2008 Marvin Humphrey
-
-This program is free software; you can redistribute it and/or modify
-under the same terms as Perl itself.
-

Modified: trunk/perl/xs/KinoSearch/Obj/FastObj.c
===================================================================
--- trunk/perl/xs/KinoSearch/Obj/FastObj.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/perl/xs/KinoSearch/Obj/FastObj.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -10,7 +10,7 @@

kino_FastObj*
kino_FastObj_foster(kino_FastObj *invoker, const kino_CharBuf *class_name,
- kino_VirtualTable *vtable, size_t alloc_size,
+ kino_VTable *vtable, size_t alloc_size,
void *native_blank)
{
SV *inner_obj = SvRV((SV*)native_blank);
@@ -24,8 +24,8 @@
self->_ = KINO_REFCOUNT_INC(vtable);
}
else {
- kino_VirtualTable *real_vtable
- = (kino_VirtualTable*)kino_DynVT_singleton(class_name, vtable);
+ kino_VTable *real_vtable
+ = (kino_VTable*)kino_DynVT_singleton(class_name, vtable);
self->_ = KINO_REFCOUNT_INC(real_vtable);
}


Modified: trunk/perl/xs/KinoSearch/Obj.c
===================================================================
--- trunk/perl/xs/KinoSearch/Obj.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/perl/xs/KinoSearch/Obj.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -12,7 +12,7 @@

kino_Obj*
kino_Obj_create(kino_Obj *invoker, const kino_CharBuf *class_name,
- kino_VirtualTable *vtable, size_t alloc_size)
+ kino_VTable *vtable, size_t alloc_size)
{
kino_Obj *self = (kino_Obj*)kino_MemMan_wrapped_calloc(alloc_size, 1);
SV *inner_obj;
@@ -25,8 +25,8 @@
self->_ = KINO_REFCOUNT_INC(vtable);
}
else {
- kino_VirtualTable *real_vtable
- = (kino_VirtualTable*)kino_DynVT_singleton(class_name, vtable);
+ kino_VTable *real_vtable
+ = (kino_VTable*)kino_DynVT_singleton(class_name, vtable);
self->_ = KINO_REFCOUNT_INC(real_vtable);
}

@@ -48,7 +48,7 @@

kino_Obj*
kino_Obj_foster(kino_Obj *invoker, const kino_CharBuf *class_name,
- kino_VirtualTable *vtable, size_t alloc_size,
+ kino_VTable *vtable, size_t alloc_size,
void *native_blank)
{
kino_Obj *self = (kino_Obj*)kino_MemMan_wrapped_calloc(alloc_size, 1);
@@ -61,8 +61,8 @@
self->_ = KINO_REFCOUNT_INC(vtable);
}
else {
- kino_VirtualTable *real_vtable
- = (kino_VirtualTable*)kino_DynVT_singleton( class_name, vtable);
+ kino_VTable *real_vtable
+ = (kino_VTable*)kino_DynVT_singleton( class_name, vtable);
self->_ = KINO_REFCOUNT_INC(real_vtable);
}
self->ref.native = inner_obj;

Modified: trunk/perl/xs/KinoSearch/Util/Native.c
===================================================================
--- trunk/perl/xs/KinoSearch/Util/Native.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/perl/xs/KinoSearch/Util/Native.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -1,6 +1,6 @@
#include "XSBind.h"

-#include "KinoSearch/Util/VirtualTable.h"
+#include "KinoSearch/Obj/VTable.h"

#include "KinoSearch/Obj.h"
#include "KinoSearch/Util/Native.h"
@@ -56,8 +56,8 @@
chy_u32_t i;
SV *invoker;

- if (KINO_OBJ_IS_A(obj, KINO_VIRTUALTABLE)) {
- kino_VirtualTable *vtable = (kino_VirtualTable*)obj;
+ if (KINO_OBJ_IS_A(obj, KINO_VTABLE)) {
+ kino_VTable *vtable = (kino_VTable*)obj;
invoker = cb_to_sv(vtable->name);
}
else {
@@ -203,8 +203,8 @@
SV *invoker;
chy_u32_t i;

- if (KINO_OBJ_IS_A(obj, KINO_VIRTUALTABLE)) {
- kino_VirtualTable *vtable = (kino_VirtualTable*)obj;
+ if (KINO_OBJ_IS_A(obj, KINO_VTABLE)) {
+ kino_VTable *vtable = (kino_VTable*)obj;
invoker = cb_to_sv(vtable->name);
}
else {

Modified: trunk/perl/xs/XSBind.c
===================================================================
--- trunk/perl/xs/XSBind.c 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/perl/xs/XSBind.c 2008-09-07 00:54:25 UTC (rev 3829)
@@ -20,7 +20,7 @@
kino_Obj*
kino_XSBind_new_blank_obj(SV *either_sv)
{
- kino_VirtualTable *vtable;
+ kino_VTable *vtable;

/* Get a vtable. */
if ( sv_isobject(either_sv)
@@ -32,7 +32,7 @@
}
else {
kino_ZombieCharBuf klass = sv_to_class_name(either_sv);
- vtable = (kino_VirtualTable*)kino_DynVT_singleton(
+ vtable = (kino_VTable*)kino_DynVT_singleton(
(kino_CharBuf*)&klass, NULL);
}

@@ -40,7 +40,7 @@
}

kino_Obj*
-kino_XSBind_sv_to_kobj(SV *sv, kino_VirtualTable *vtable)
+kino_XSBind_sv_to_kobj(SV *sv, kino_VTable *vtable)
{
kino_Obj *retval = maybe_sv_to_kobj(sv, vtable);
if (!retval) CONFESS("Need a %o, but got NULL or undef", vtable->name);
@@ -48,7 +48,7 @@
}

kino_Obj*
-kino_XSBind_sv_to_kobj_or_zcb(SV *sv, kino_VirtualTable *vtable,
+kino_XSBind_sv_to_kobj_or_zcb(SV *sv, kino_VTable *vtable,
kino_ZombieCharBuf *zcb)
{
kino_Obj *retval = NULL;
@@ -59,10 +59,10 @@
IV tmp = SvIV( SvRV(sv) );
retval = INT2PTR(kino_Obj*, tmp);
}
- else if ( vtable == (kino_VirtualTable*)&KINO_ZOMBIECHARBUF
- || vtable == (kino_VirtualTable*)&KINO_VIEWCHARBUF
- || vtable == (kino_VirtualTable*)&KINO_CHARBUF
- || vtable == (kino_VirtualTable*)&KINO_OBJ
+ else if ( vtable == (kino_VTable*)&KINO_ZOMBIECHARBUF
+ || vtable == (kino_VTable*)&KINO_VIEWCHARBUF
+ || vtable == (kino_VTable*)&KINO_CHARBUF
+ || vtable == (kino_VTable*)&KINO_OBJ
) {
STRLEN size;
char *ptr = SvPVutf8(sv, size);
@@ -74,7 +74,7 @@
}

kino_Obj*
-kino_XSBind_maybe_sv_to_kobj(SV *sv, kino_VirtualTable *vtable)
+kino_XSBind_maybe_sv_to_kobj(SV *sv, kino_VTable *vtable)
{
kino_Obj *retval = NULL;
if (sv && SvOK(sv)) {
@@ -85,17 +85,17 @@
else if (SvROK(sv)) {
SV *inner = SvRV(sv);
if (SvTYPE(inner) == SVt_PVAV) {
- if ( vtable == (kino_VirtualTable*)&KINO_VARRAY
- || vtable == (kino_VirtualTable*)&KINO_FASTOBJ
- || vtable == (kino_VirtualTable*)&KINO_OBJ
+ if ( vtable == (kino_VTable*)&KINO_VARRAY
+ || vtable == (kino_VTable*)&KINO_FASTOBJ
+ || vtable == (kino_VTable*)&KINO_OBJ
) {
retval = (kino_Obj*)parray_to_karray((AV*)inner);
}
}
else if (SvTYPE(inner) == SVt_PVHV) {
- if ( vtable == (kino_VirtualTable*)&KINO_HASH
- || vtable == (kino_VirtualTable*)&KINO_FASTOBJ
- || vtable == (kino_VirtualTable*)&KINO_OBJ
+ if ( vtable == (kino_VTable*)&KINO_HASH
+ || vtable == (kino_VTable*)&KINO_FASTOBJ
+ || vtable == (kino_VTable*)&KINO_OBJ
) {
retval = (kino_Obj*)phash_to_khash((HV*)inner);
}
@@ -459,7 +459,7 @@

kino_Obj*
kino_XSBind_extract_kobj(HV *hash, const char *key, STRLEN key_len,
- kino_VirtualTable *vtable)
+ kino_VTable *vtable)
{
SV **const sv_ptr = hv_fetch(hash, key, key_len, 0);
if (sv_ptr == NULL)

Modified: trunk/perl/xs/XSBind.h
===================================================================
--- trunk/perl/xs/XSBind.h 2008-09-06 23:46:47 UTC (rev 3828)
+++ trunk/perl/xs/XSBind.h 2008-09-07 00:54:25 UTC (rev 3829)
@@ -6,12 +6,12 @@

#include "charmony.h"
#include "KinoSearch/Obj.h"
+#include "KinoSearch/Obj/VTable.h"
#include "KinoSearch/Util/Carp.h"
#include "KinoSearch/Util/ByteBuf.h"
#include "KinoSearch/Util/CharBuf.h"
#include "KinoSearch/Util/VArray.h"
#include "KinoSearch/Util/Hash.h"
-#include "KinoSearch/Util/VirtualTable.h"

#include "EXTERN.h"
#include "perl.h"
@@ -38,27 +38,27 @@
kino_XSBind_new_blank_obj(SV *either_sv);

/* If the SV contains a KS object which passes an "isa" test against the
- * passed-in VirtualTable, return a pointer to it. If the vtable indicates
- * that a VArray or a Hash is desired and the SV contains the corresponding
- * Perl data structure, attempt to convert it to a mortalized KS copy.
- * If the desired object cannot be derived, throw an exception.
+ * passed-in VTable, return a pointer to it. If the vtable indicates that a
+ * VArray or a Hash is desired and the SV contains the corresponding Perl data
+ * structure, attempt to convert it to a mortalized KS copy. If the desired
+ * object cannot be derived, throw an exception.
*/
kino_Obj*
-kino_XSBind_sv_to_kobj(SV *sv, kino_VirtualTable *vtable);
+kino_XSBind_sv_to_kobj(SV *sv, kino_VTable *vtable);

/* If the SV contains a KS object which passes an "isa" test against the
- * passed-in VirtualTable, return a pointer to it. If not, but a
- * ZombieCharBuf would satisfy the "isa" test, stringify the SV, assign its
- * string to <code>zcb</code> and return a pointer to that instead.
+ * passed-in VTable, return a pointer to it. If not, but a ZombieCharBuf
+ * would satisfy the "isa" test, stringify the SV, assign its string to
+ * <code>zcb</code> and return a pointer to that instead.
*/
kino_Obj*
-kino_XSBind_sv_to_kobj_or_zcb(SV *sv, kino_VirtualTable *vtable,
+kino_XSBind_sv_to_kobj_or_zcb(SV *sv, kino_VTable *vtable,
kino_ZombieCharBuf *zcb);

/* As sv_to_kobj above, but returns NULL instead of throwing an exception.
*/
kino_Obj*
-kino_XSBind_maybe_sv_to_kobj(SV *sv, kino_VirtualTable *vtable);
+kino_XSBind_maybe_sv_to_kobj(SV *sv, kino_VTable *vtable);

/* Given an SV* that may be either an object or a class name, return the
* class name as a ZombieCharBuf. Morally equivalent to
@@ -154,16 +154,16 @@
*/
kino_Obj*
kino_XSBind_extract_kobj(HV *hash, const char *key, STRLEN key_len,
- kino_VirtualTable *vtable);
+ kino_VTable *vtable);

/* SV to KS obj conversion functions with vtable casts.
*/
#define SV_TO_KOBJ(sv, vtable) \
- sv_to_kobj((sv), (kino_VirtualTable*)(vtable))
+ sv_to_kobj((sv), (kino_VTable*)(vtable))
#define SV_TO_KOBJ_OR_ZCB(sv, vtable, zcb) \
- sv_to_kobj_or_zcb((sv), (kino_VirtualTable*)(vtable), zcb)
+ sv_to_kobj_or_zcb((sv), (kino_VTable*)(vtable), zcb)
#define MAYBE_SV_TO_KOBJ(sv, vtable) \
- maybe_sv_to_kobj((sv), (kino_VirtualTable*)(vtable))
+ maybe_sv_to_kobj((sv), (kino_VTable*)(vtable))

/* Check the vtable function pointer for a method and determine whether it
* differs from the original. If it doesn't throw an exception.


_______________________________________________
kinosearch-commits mailing list
kinosearch-commits@rectangular.com
http://www.rectangular.com/mailman/listinfo/kinosearch-commits