Ticket #487: replacing_vtable_method_with_vtable_function.patch

runtime/parrot/library/HTTP/Daemon.pir

@@ -209 +209 @@
 
 =item __get_bool()
 
-Vtable method, called from the C<if> or C<unless> opcode. Returns
+Vtable function, called from the C<if> or C<unless> opcode. Returns
 true, if the daemon object is listening on a socket, that is if the
 initialization went ok.
 

runtime/parrot/library/Getopt/Obj.pir

@@ -357 +357 @@
 
 =item C<push_string(STRING format)>
 
-A vtable method, invoked by e.g. C<push getopts, "foo|f=s">.  The format is as such.
+A vtable function, invoked by e.g. C<push getopts, "foo|f=s">.  The format is as such.
 
 =over 4
 

runtime/parrot/library/P6object.pir

@@ -727 +727 @@
 
 =over 4
 
-=item get_string()  (vtable method)
+=item get_string()  (vtable function)
 
 Returns the "shortname" of the protoobject's class and parens.
 
@@ -743 +743 @@
     .return ($S0)
 .end
 
-=item defined()  (vtable method)
+=item defined()  (vtable function)
 
 Protoobjects are always treated as being undefined.
 
@@ -754 +754 @@
 .end
 
 
-=item name()  (vtable method)
+=item name()  (vtable function)
 
 Have protoobjects return their longname in response to a
 C<typeof_s_p> opcode.

src/byteorder.c

@@ -10 +10 @@
 
 These are assigned to a vtable when the PBC file is loaded.
 
-If the vtable method for conversion from the native byteorder is called,
+If the vtable function for conversion from the native byteorder is called,
 it is a I<no op> and will work, but the caller should know if the
 byteorder in the PBC file is native and skip the conversion and just map
 it in.

src/oo.c

@@ -130 +130 @@
         }
     }
 
-    /* Import any vtable methods. */
+    /* Import any vtable functions. */
     Parrot_pcc_invoke_method_from_c_args(interp, ns, CONST_STRING(interp, "get_associated_vtable_methods"), "->P", &vtable_overrides);
 
     if (!PMC_IS_NULL(vtable_overrides)) {
@@ -500 +500 @@
         VTABLE_get_pmc_keyed_str(interp, _class->parent_overrides, name);
 
     if (PMC_IS_NULL(result)) {
-        /* Walk and search for the vtable method. */
+        /* Walk and search for the vtable function. */
         const INTVAL num_classes = VTABLE_elements(interp, _class->all_parents);
         INTVAL       i;
 

src/pmc/role.pmc

@@ -750 +750 @@
     METHOD inspect(STRING *what :optional, int got_what :opt_flag) {
         PMC *found;
 
-        /* Just delegate to the appropriate vtable method. */
+        /* Just delegate to the appropriate vtable function. */
         if (got_what)
             found = VTABLE_inspect_str(interp, SELF, what);
         else

src/pmc/class.pmc

@@ -62 +62 @@
 
 =item C<vtable_overrides>
 
-A directory of vtable method names and method bodies this class overrides.
+A directory of vtable function names and function bodies this class overrides.
 An empty Hash PMC is allocated during initialization.
 
 =item C<attrib_metadata>
@@ -767 +767 @@
                 EXCEPTION_METHOD_NOT_FOUND,
                 "'%S' is not a valid vtable function name.", name);
 
-        /* Add it to vtable methods list. */
+        /* Add it to vtable functions list. */
         VTABLE_set_pmc_keyed_str(interp, _class->vtable_overrides, name, sub);
     }
 
@@ -1714 +1714 @@
 =item C<void add_method(STRING *name, PMC *sub)>
 
 Adds the given sub PMC as a method with the given name. Delegates to the
-C<add_method> vtable method.
+C<add_method> vtable function.
 
 =cut
 
@@ -1728 +1728 @@
 =item C<void add_vtable_override(STRING *name, PMC *sub)>
 
 Adds the given sub PMC as a vtable override with the given name. Delegates to
-the C<add_vtable_override> vtable method.
+the C<add_vtable_override> vtable function.
 
 =cut
 
@@ -1883 +1883 @@
     METHOD inspect(STRING *what :optional, int has_what :opt_flag) {
         PMC *found;
 
-        /* Just delegate to the appropriate vtable method. */
+        /* Just delegate to the appropriate vtable function. */
         if (has_what)
             found = SELF.inspect_str(what);
         else

src/pmc/object.pmc

@@ -430 +430 @@
         Parrot_Class_attributes  * const _class    = PARROT_CLASS(obj->_class);
         STRING * const meth_name = CONST_STRING(interp, "get_integer");
 
-        /* Walk and search for the vtable method. */
+        /* Walk and search for the vtable function. */
         const int num_classes = VTABLE_elements(interp, _class->all_parents);
         int i;
         for (i = 0; i < num_classes; i++) {
@@ -447 +447 @@
             }
             /* method name is get_integer */
             if (cur_class->vtable->base_type == enum_class_PMCProxy) {
-                /* Get the PMC instance and call the vtable method on that. */
+                /* Get the PMC instance and call the vtable function on that. */
                 STRING * const proxy      = CONST_STRING(interp, "proxy");
                 PMC    * const del_object = VTABLE_get_attr_str(interp, pmc, proxy);
 
@@ -643 +643 @@
         Parrot_Object_attributes * const obj    = PARROT_OBJECT(pmc);
         Parrot_Class_attributes  * const _class = PARROT_CLASS(obj->_class);
 
-        /* Walk and search for the vtable method. */
+        /* Walk and search for the vtable function. */
         const int num_classes = VTABLE_elements(interp, _class->all_parents);
         int i;
 
@@ -669 +669 @@
             }
 
             if (cur_class->vtable->base_type == enum_class_PMCProxy) {
-                /* Get the PMC instance and call the vtable method on that. */
+                /* Get the PMC instance and call the vtable function on that. */
                 PMC * const del_object =
                     VTABLE_get_attr_keyed(interp, pmc, cur_class, proxy);
 

src/pmc/multisub.pmc

@@ -79 +79 @@
 
     /* I don't really know how to implement these if they need something
        special, so I'll sort the sub list and defer processing to the
-       ResizablePMCArray's VTABLE methods of the same names. Hopefully we
+       ResizablePMCArray's VTABLE functions of the same names. Hopefully we
        don't need anything beyond that. */
     VTABLE PMC *get_pmc_keyed(PMC *key) {
         PMC * const sig_obj = CONTEXT(interp)->current_sig;

src/pmc/namespace.pmc

@@ -68 +68 @@
         /* Otherwise, store it in the namespace for the class to
          * retrieve later */
         else {
-            /* If we don't have a place to hang vtable methods, make one. */
+            /* If we don't have a place to hang vtable functions, make one. */
             if (PMC_IS_NULL(vtable))
                 nsinfo->vtable = vtable = pmc_new(interp, enum_class_Hash);
 
@@ -984 +984 @@
 
 =item C<METHOD get_associated_vtable_methods()>
 
-Gets the Hash of vtable methods associated with this namespace and removes it
+Gets the Hash of vtable functions associated with this namespace and removes it
 from the namespace.
 
 =cut

src/pmc/pmcproxy.pmc

@@ -457 +457 @@
 
 */
     METHOD inspect(STRING *what :optional, int got_what :opt_flag) {
-        /* Just delegate to the appropriate vtable method. */
+        /* Just delegate to the appropriate vtable function. */
         PMC * const found =
             got_what
                 ? VTABLE_inspect_str(interp, SELF, what)

src/pmc/arrayiterator.pmc

@@ -40 +40 @@
 
 NB: for different direction you have to use different ops!
 
-TODO: Discuss idea of having separate get_iter/get_reverse_iter VTABLE methods
+TODO: Discuss idea of having separate get_iter/get_reverse_iter VTABLE functions
 to avoid this caveat.
 
 =head1 Methods

src/io/api.c

@@ -905 +905 @@
 
 =item C<PIOOFF_T Parrot_io_make_offset_pmc(PARROT_INTERP, PMC *pmc)>
 
-Returns the return value of the C<get_integer> vtable method on C<*pmc>.
+Returns the return value of the C<get_integer> vtable function on C<*pmc>.
 
 =cut
 

docs/pmc2c.pod

@@ -133 +133 @@
 
 =item 3.
 
-A list of vtable method implementations
+A list of vtable function implementations
 
 =item 4.
 
@@ -143 +143 @@
 
 =head2 Method Body Substitutions
 
-The vtable method bodies can use the following substitutions:
+The vtable function bodies can use the following substitutions:
 
 =over 4
 
@@ -157 +157 @@
 
 =item C<OtherClass.SELF.method(a,b,c)>
 
-Calls the static vtable method 'method' in C<OtherClass>.
+Calls the static vtable function 'method' in C<OtherClass>.
 
 =item C<SELF.method(a,b,c)>
 
-Calls the vtable method 'method' using the dynamic type of C<SELF>.
+Calls the vtable functions 'method' using the dynamic type of C<SELF>.
 
 =item C<SELF(a,b,c)>
 
@@ -169 +169 @@
 
 =item C<STATICSELF.method(a,b,c)>
 
-Calls the vtable method 'method' using the static type of C<SELF> (in
+Calls the vtable function 'method' using the static type of C<SELF> (in
 other words, calls another method defined in the same file).
 
 =item C<OtherClass.SUPER(a,b,c)>

docs/book/draft/ch07_dynpmcs.pod

@@ -195 +195 @@
 =head3 VTABLE Functions Parameters
 
 VTABLE functions are defined just like ordinary C functions, almost. Here's
-a normal definition for a VTABLE method:
+a normal definition for a VTABLE function:
 
   VTABLE VTABLENAME (PARAMETERS) {
     /* ordinary C here, almost */

docs/book/draft/chXX_hlls.pod

@@ -211 +211 @@
 
 =over 4
 
-=item * VTable methods
+=item * VTable functions
 
-VTable methods are the standard interface for PMC data types, and all PMCs
+VTable functions are the standard interface for PMC data types, and all PMCs
 have them. If the PMCs were written properly to satisfy this interface
 all the necessary information from those PMCs. Operate on the PMCs at the
 VTable level, and we can safely ignore the implementation details of them.

docs/dev/infant.pod

@@ -142 +142 @@
  + Fast mark phase (GC already manipulates the flags)
  - Generation count must be maintained
  - Disallows recursive opcode calls (necessary for eg implementing
-   vtable methods in pasm)
+   vtable functions in pasm)
  - Can temporarily use more memory (dead objects accumulate during the
    current generation)
 
 In order to allow recursive opcode calls, we could increment the generation
 count in more places and make sure nothing is left unanchored at those points,
 but that would gradually remove all advantages of this scheme and make it more
-difficult to call existing vtable methods (since you never know when they might
+difficult to call existing vtable functions (since you never know when they might
 start running pasm code.)
 
 =head2 Variant 5: generation stack

docs/dev/pmc_freeze.pod

@@ -79 +79 @@
 =head2 The visit_info structure
 
 This structure holds all necessary information and function pointers specific
-to the desired functionality. It gets passed on to all vtable methods and
+to the desired functionality. It gets passed on to all vtable functions and
 callback functions.
 
 =head2 Working loop
@@ -99 +99 @@
 This is done by a callback function inside the B<visit_info> structure called
 B<visit_pmc_now>. It gets called initially to put the first item on the list
 and is called thereafter from all PMCs for contained PMCs inside the B<visit>
-vtable method.
+vtable functions.
 
 
 =head2 The visit() vtable
@@ -140 +140 @@
 
 So after all we finally arrived at the point to actually perform the desired
 functionality. First the PMC-specific part is done inside F<pmc_freeze.c> then
-the specific vtable method B<freeze>, B<thaw>, whatever, is called, again via a
+the specific vtable function B<freeze>, B<thaw>, whatever, is called, again via a
 function pointer called B<visit_action>.
 
 =head1 Freeze and thaw
 
 As stated PMCs are currently processed inside the core, PMC-specific parts are
-done by calling the PMCs vtable method. This parts could of course be moved to
+done by calling the PMCs vtable function. This parts could of course be moved to
 F<default.pmc> too, so that it's simpler to override the functionality.
 
 =head2 Serializer interface
 
 During initialization the B<visit_info>s B<image_io> data pointer is filled
-with an object having B<vtable> methods that remarkably look like a PMCs
+with an object having B<vtable> function that remarkably look like a PMCs
 vtable. So B<io-E<gt>vtable-E<gt>push_integer> spits out an INTVAL to the
 frozen B<image>, while B<shift_integer> gets an INTVAL from the frozen stream.
 

docs/dev/pmc_obj_design_meeting_notes.pod

@@ -60 +60 @@
 statically calls the method in the current class.
 
 B<Recommendation>: Throughout the source, rename SELF to STATIC_SELF, and
-rename DYNSELF to SELF. Additionally, direct access to VTABLE methods should
+rename DYNSELF to SELF. Additionally, direct access to VTABLE functions should
 be reviewed, and SELF should be used where possible to increase clarity and
 maintainability (this is a good CAGE task.) Also, this should become a coding
 standard for PMCs.

docs/dev/pccmethods.pod

@@ -10 +10 @@
 A C<PCCMETHOD> is a PMC method that follows Parrot Calling Conventions
 (a.k.a. PCC). This allows PIR code to call PMC methods using slurpy, named,
 and other types of arguments as specified in F<PDD03>. This offers flexibility
-not found in a PMC C<METHOD> or a vtable method using C calling conventions.
+not found in a PMC C<METHOD> or a vtable function using C calling conventions.
 
 C<PCCINVOKE> is used to call a method using the Parrot Calling Conventions.
 It uses the standard find_method/invoke approach that the callmethodcc opcode
@@ -113 +113 @@
 
 =head2 Performance
 
-When a C<METHOD> or vtable method is called, C<NCI> is used to map the
+When a C<METHOD> or vtable function is called, C<NCI> is used to map the
 arguments held in the current Parrot_Context onto the C calling conventions.
 That is, you still end up involving the Parrot Calling Conventions anyway,
 so there is no reason to expect a C<PCCMETHOD> to be any slower. It may well

lib/Parrot/Vtable.pm

@@ -67 +67 @@
 
   [ return_type method_name parameters section MMD_type attributes ]
 
-for each vtable method defined in C<$file>. If C<$file> is unspecified it
+for each vtable function defined in C<$file>. If C<$file> is unspecified it
 defaults to F<src/vtable.tbl>.  If it is not an MMD method, C<MMD_type> is -1.
 
 =cut
@@ -209 +209 @@
 
 /*
  * vtable accessor macros
- * as vtable methods might get moved around internally
+ * as vtable function might get moved around internally
  * these macros hide the details
  */
 
@@ -281 +281 @@
 
 =item C<vtbl_embed($vtable)>
 
-Returns the C function definitions to call the vtable methods on a PMC for the
+Returns the C function definitions to call the vtable function on a PMC for the
 elements in the referenced vtable array.
 
 =cut

lib/Parrot/Pmc2c/PMC/default.pm

@@ -32 +32 @@
 sub pre_method_gen {
     my ($self) = @_;
 
-    # vtable methods
+    # vtable functions
     foreach my $method ( @{ $self->vtable->methods } ) {
         my $vt_method_name = $method->name;
         next unless $self->unimplemented_vtable($vt_method_name);

lib/Parrot/Pmc2c/PMC/Object.pm

@@ -22 +22 @@
 Returns the C code for the method body.
 
 Overrides the default implementation to direct all unknown methods to
-first check if there is an implementation of the vtable method in the
-vtable methods hash of this class of any others, and delegates up to
+first check if there is an implementation of the vtable function in the
+vtable functions hash of this class of any others, and delegates up to
 any PMCs in the MRO.
 
 =cut
@@ -31 +31 @@
 sub pre_method_gen {
     my ($self) = @_;
 
-    # vtable methods
+    # vtable functions
     foreach my $method ( @{ $self->vtable->methods } ) {
         my $vt_method_name = $method->name;
         next unless $self->normal_unimplemented_vtable($vt_method_name);
@@ -56 +56 @@
     Parrot_Class_attributes  * const _class    = PARROT_CLASS(obj->_class);
     STRING        * const meth_name = CONST_STRING_GEN(interp, "$vt_method_name");
 
-    /* Walk and search for the vtable method. */
+    /* Walk and search for the vtable functions. */
     const int num_classes = VTABLE_elements(interp, _class->all_parents);
     int i;
     for (i = 0; i < num_classes; i++) {
@@ -76 +76 @@
         unless ($self->vtable_method_does_multi($vt_method_name)) {
             $method_body_text .= <<"EOC";
         if (cur_class->vtable->base_type == enum_class_PMCProxy) {
-            /* Get the PMC instance and call the vtable method on that. */
+            /* Get the PMC instance and call the vtable function on that. */
             STRING * const proxy      = CONST_STRING_GEN(interp, "proxy");
             PMC    * const del_object = VTABLE_get_attr_str(interp, SELF, proxy);
 

lib/Parrot/Pmc2c/PMC/Null.pm

@@ -29 +29 @@
 sub pre_method_gen {
     my ($self) = @_;
 
-    # vtable methods
+    # vtable functions
     foreach my $method ( @{ $self->vtable->methods } ) {
         my $vt_method_name = $method->name;
         next unless $self->normal_unimplemented_vtable($vt_method_name);

lib/Parrot/Pmc2c/PMC/ParrotClass.pm

@@ -66 +66 @@
 sub pre_method_gen {
     my ($self) = @_;
 
-    # vtable methods
+    # vtable functions
     foreach my $method ( @{ $self->vtable->methods } ) {
         my $vt_method_name = $method->name;
         next if exists $dont_delegate->{$vt_method_name};

lib/Parrot/Pmc2c/Object.pm

@@ -37 +37 @@
 generating.
 
 Overrides the default implementation to direct all unknown methods to
-first check if there is an implementation of the vtable method in the
-vtable methods hash of this class of any others, and delegates up to
+first check if there is an implementation of the vtable function in the
+vtable functions hash of this class of any others, and delegates up to
 any PMCs in the MRO.
 
 =back

lib/Parrot/Pmc2c/PMCEmitter.pm

@@ -167 +167 @@
     my $name    = $self->name;
     my $lc_name = $self->name;
 
-    # generate decls for all vtable methods in this PMC
+    # generate decls for all vtable functions in this PMC
     foreach my $vt_method_name ( @{ $self->vtable->names } ) {
         if ( $self->implements_vtable($vt_method_name) ) {
             $hout .=
@@ -322 +322 @@
 sub gen_methods {
     my ($self) = @_;
 
-    # vtable methods
+    # vtable functions
     foreach my $method ( @{ $self->vtable->methods } ) {
         my $vt_method_name = $method->name;
         next if $vt_method_name eq 'class_init';
@@ -1028 +1028 @@
         push @{ $multi_methods{ $name } }, [ $sig[1], $ssig, $fsig, $ns, $func, $method ];
     }
 
-    # vtable methods
+    # vtable functions
     foreach my $method ( @{ $self->vtable->methods } ) {
         my $vt_method_name = $method->name;
         next if $vt_method_name eq 'class_init';

lib/Parrot/Pmc2c/MethodEmitter.pm

@@ -215 +215 @@
 =item C<rewrite_vtable_method($self, $pmc, $super, $super_table)>
 
 Rewrites the method body performing the various macro substitutions for
-vtable method bodies (see F<tools/build/pmc2c.pl>).
+vtable function bodies (see F<tools/build/pmc2c.pl>).
 
 =cut
 

lib/Parrot/Pmc2c/PMC.pm

@@ -132 +132 @@
 
 =item C<implements_vtable($method)>
 
-True if pmc generates code for vtable method C<$method>.
+True if pmc generates code for vtable function C<$method>.
 
 =cut
 
@@ -321 +321 @@
 
 =item C<vtable_method_does_write($method)>
 
-Returns true if the vtable method C<$method> writes our value.
+Returns true if the vtable function C<$method> writes our value.
 
 =back
 

lib/Parrot/Pmc2c/Parser.pm

@@ -279 +279 @@
         }
         else {
 
-            # Name-mangle NCI and multi methods to avoid conflict with vtable methods.
+            # Name-mangle NCI and multi methods to avoid conflict with vtable functions.
             if ( $marker) {
                 if ( $marker =~ /MULTI/ ) {
                     $method->type(Parrot::Pmc2c::Method::MULTI);

compilers/pct/src/POST/Node.pir

@@ -82 +82 @@
 .end
 
 
-=item get_string()   # vtable method
+=item get_string()   # vtable function
 
 Returns the result of the current node as a string.
 

compilers/pirc/src/pircompunit.c

@@ -184 +184 @@
 set_sub_vtable(lexer_state * const lexer, char const * vtablename)>
 
 Set the :vtable() flag argument to the current subroutine. If C<vtablename>
-is NULL, the name of the current sub is taken to be the vtable method name.
-If the vtable method name (either specified or the current sub's name) is
-in fact not a vtable method, an error message is emitted.
+is NULL, the name of the current sub is taken to be the vtable function name.
+If the vtable function name (either specified or the current sub's name) is
+in fact not a vtable function, an error message is emitted.
 
 =cut
 
@@ -198 +198 @@
     if (vtablename == NULL)  /* the sub's name I<is> the vtablename */
         vtablename = CURRENT_SUB(lexer)->info.subname;
 
-    /* get the index number of this vtable method */
+    /* get the index number of this vtable function */
     vtable_index = Parrot_get_vtable_index(lexer->interp,
                                            Parrot_str_new(lexer->interp, vtablename,
                                                                strlen(vtablename)));
 
-    /* now check whether the method name actually a vtable method */
+    /* now check whether the method name actually a vtable function */
     if (vtable_index == -1)
         yypirerror(lexer->yyscanner, lexer,
                    "'%s' is not a vtable method but was used with :vtable flag", vtablename);

compilers/pirc/src/pircompunit.h

@@ -84 +84 @@
     PIRC_SUB_FLAG_METHOD     = 1 << 10, /* the sub is a method */
     PIRC_SUB_FLAG_HAS_OUTER  = 1 << 11, /* the sub is lexically nested */
     PIRC_SUB_FLAG_IS_OUTER   = 1 << 12, /* the sub contains lexically nested subs. */
-    PIRC_SUB_FLAG_VTABLE     = 1 << 13, /* this sub overrides a vtable method */
+    PIRC_SUB_FLAG_VTABLE     = 1 << 13, /* this sub overrides a vtable function */
     PIRC_SUB_FLAG_LEX        = 1 << 14, /* this sub needs a LexPad */
     PIRC_SUB_FLAG_MULTI      = 1 << 15, /* this sub is a multi method/sub */
     PIRC_SUB_FLAG_SUBID      = 1 << 16, /* this sub has a namespace-unaware identifier */

t/pmc/pmcproxy.t

@@ -144 +144 @@
     addparent $P0, $P1
     ok(1, "added Class's PMCProxy as a parent of the PDD15 class")
 
-    #We will override the add_role vtable method.
+    #We will override the add_role vtable function.
     $P2 = get_global 'no_add_role'
     $P0.'add_vtable_override'('add_role', $P2)
     ok(1, 'overrode a vtable method')
@@ -178 +178 @@
     addparent $P0, $P1
     ok(1, "added Class's PMCProxy as a parent of the PDD15 class")
 
-    #We will override the inspect_str vtable method.
+    #We will override the inspect_str vtable function.
     $P2 = get_global 'always42'
     $P0.'add_vtable_override'('inspect_str', $P2)
     ok(1, 'overrode inspect_str method')

t/pmc/exception-old.t

@@ -359 +359 @@
 /Mark 500 not found/
 OUTPUT
 
-# stringification is handled by a vtable method, which runs in a second
+# stringification is handled by a vtable function, which runs in a second
 # runloop. when an error in the method tries to go to a Error_Handler defined
 # outside it, it winds up going to the inner runloop, giving strange results.
 pir_output_is( <<'CODE', <<'OUTPUT', 'pop_eh out of context (2)', todo => 'runloop shenanigans' );

t/dynpmc/rotest.t

@@ -49 +49 @@
     my %tests = (
 
         # these first two tests would test overriding of the default
-        # read-onlyness notion of vtable methods
+        # read-onlyness notion of vtable functions
         q{value = 42}  => [ 1, 0 ],
         q{$I0 = value} => [ 0, 0 ],
 

t/op/exceptions.t

@@ -378 +378 @@
 done.
 OUTPUT
 
-# stringification is handled by a vtable method, which runs in a second
+# stringification is handled by a vtable function, which runs in a second
 # runloop. when an error in the method tries to go to a Error_Handler defined
 # outside it, it winds up going to the inner runloop, giving strange results.
 pir_output_is( <<'CODE', <<'OUTPUT', 'pop_eh out of context (2)', todo => 'runloop shenanigans' );

examples/tutorial/56_defined.pir

@@ -26 +26 @@
 =pod
 
 Most PMC's, but not all, should return true for C<defined>.  It all
-depends on how the PMC implements its vtable method for C<defined>.
+depends on how the PMC implements its vtable function for C<defined>.
 For example the C<Undef> PMC always returns false (0) for C<defined>.
 
 =cut