Index: runtime/parrot/library/HTTP/Daemon.pir =================================================================== --- runtime/parrot/library/HTTP/Daemon.pir (revision 43792) +++ runtime/parrot/library/HTTP/Daemon.pir (working copy) @@ -209,7 +209,7 @@ =item __get_bool() -Vtable method, called from the C or C opcode. Returns +Vtable function, called from the C or C opcode. Returns true, if the daemon object is listening on a socket, that is if the initialization went ok. Index: runtime/parrot/library/Getopt/Obj.pir =================================================================== --- runtime/parrot/library/Getopt/Obj.pir (revision 43792) +++ runtime/parrot/library/Getopt/Obj.pir (working copy) @@ -357,7 +357,7 @@ =item C -A vtable method, invoked by e.g. C. The format is as such. +A vtable function, invoked by e.g. C. The format is as such. =over 4 Index: runtime/parrot/library/P6object.pir =================================================================== --- runtime/parrot/library/P6object.pir (revision 43792) +++ runtime/parrot/library/P6object.pir (working copy) @@ -727,7 +727,7 @@ =over 4 -=item get_string() (vtable method) +=item get_string() (vtable function) Returns the "shortname" of the protoobject's class and parens. @@ -743,7 +743,7 @@ .return ($S0) .end -=item defined() (vtable method) +=item defined() (vtable function) Protoobjects are always treated as being undefined. @@ -754,7 +754,7 @@ .end -=item name() (vtable method) +=item name() (vtable function) Have protoobjects return their longname in response to a C opcode. Index: src/byteorder.c =================================================================== --- src/byteorder.c (revision 43792) +++ src/byteorder.c (working copy) @@ -10,7 +10,7 @@ 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 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. Index: src/oo.c =================================================================== --- src/oo.c (revision 43792) +++ src/oo.c (working copy) @@ -130,7 +130,7 @@ } } - /* 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,7 +500,7 @@ 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; Index: src/pmc/role.pmc =================================================================== --- src/pmc/role.pmc (revision 43792) +++ src/pmc/role.pmc (working copy) @@ -750,7 +750,7 @@ 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 Index: src/pmc/class.pmc =================================================================== --- src/pmc/class.pmc (revision 43792) +++ src/pmc/class.pmc (working copy) @@ -62,7 +62,7 @@ =item C -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 @@ -767,7 +767,7 @@ 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,7 +1714,7 @@ =item C Adds the given sub PMC as a method with the given name. Delegates to the -C vtable method. +C vtable function. =cut @@ -1728,7 +1728,7 @@ =item C Adds the given sub PMC as a vtable override with the given name. Delegates to -the C vtable method. +the C vtable function. =cut @@ -1883,7 +1883,7 @@ 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 Index: src/pmc/object.pmc =================================================================== --- src/pmc/object.pmc (revision 43792) +++ src/pmc/object.pmc (working copy) @@ -430,7 +430,7 @@ 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,7 +447,7 @@ } /* 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,7 +643,7 @@ 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,7 +669,7 @@ } 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); Index: src/pmc/multisub.pmc =================================================================== --- src/pmc/multisub.pmc (revision 43792) +++ src/pmc/multisub.pmc (working copy) @@ -79,7 +79,7 @@ /* 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; Index: src/pmc/namespace.pmc =================================================================== --- src/pmc/namespace.pmc (revision 43792) +++ src/pmc/namespace.pmc (working copy) @@ -68,7 +68,7 @@ /* 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,7 +984,7 @@ =item C -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 Index: src/pmc/pmcproxy.pmc =================================================================== --- src/pmc/pmcproxy.pmc (revision 43792) +++ src/pmc/pmcproxy.pmc (working copy) @@ -457,7 +457,7 @@ */ 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) Index: src/pmc/arrayiterator.pmc =================================================================== --- src/pmc/arrayiterator.pmc (revision 43792) +++ src/pmc/arrayiterator.pmc (working copy) @@ -40,7 +40,7 @@ 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 Index: src/io/api.c =================================================================== --- src/io/api.c (revision 43792) +++ src/io/api.c (working copy) @@ -905,7 +905,7 @@ =item C -Returns the return value of the C vtable method on C<*pmc>. +Returns the return value of the C vtable function on C<*pmc>. =cut Index: docs/pmc2c.pod =================================================================== --- docs/pmc2c.pod (revision 43792) +++ docs/pmc2c.pod (working copy) @@ -133,7 +133,7 @@ =item 3. -A list of vtable method implementations +A list of vtable function implementations =item 4. @@ -143,7 +143,7 @@ =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,11 +157,11 @@ =item C -Calls the static vtable method 'method' in C. +Calls the static vtable function 'method' in C. =item C -Calls the vtable method 'method' using the dynamic type of C. +Calls the vtable functions 'method' using the dynamic type of C. =item C @@ -169,7 +169,7 @@ =item C -Calls the vtable method 'method' using the static type of C (in +Calls the vtable function 'method' using the static type of C (in other words, calls another method defined in the same file). =item C Index: docs/book/draft/ch07_dynpmcs.pod =================================================================== --- docs/book/draft/ch07_dynpmcs.pod (revision 43792) +++ docs/book/draft/ch07_dynpmcs.pod (working copy) @@ -195,7 +195,7 @@ =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 */ Index: docs/book/draft/chXX_hlls.pod =================================================================== --- docs/book/draft/chXX_hlls.pod (revision 43792) +++ docs/book/draft/chXX_hlls.pod (working copy) @@ -211,9 +211,9 @@ =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. Index: docs/dev/infant.pod =================================================================== --- docs/dev/infant.pod (revision 43792) +++ docs/dev/infant.pod (working copy) @@ -142,14 +142,14 @@ + 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 Index: docs/dev/pmc_freeze.pod =================================================================== --- docs/dev/pmc_freeze.pod (revision 43792) +++ docs/dev/pmc_freeze.pod (working copy) @@ -79,7 +79,7 @@ =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,7 +99,7 @@ This is done by a callback function inside the B structure called B. 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 -vtable method. +vtable functions. =head2 The visit() vtable @@ -140,19 +140,19 @@ So after all we finally arrived at the point to actually perform the desired functionality. First the PMC-specific part is done inside F then -the specific vtable method B, B, whatever, is called, again via a +the specific vtable function B, B, whatever, is called, again via a function pointer called B. =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 too, so that it's simpler to override the functionality. =head2 Serializer interface During initialization the Bs B data pointer is filled -with an object having B methods that remarkably look like a PMCs +with an object having B function that remarkably look like a PMCs vtable. So Bvtable-Epush_integer> spits out an INTVAL to the frozen B, while B gets an INTVAL from the frozen stream. Index: docs/dev/pmc_obj_design_meeting_notes.pod =================================================================== --- docs/dev/pmc_obj_design_meeting_notes.pod (revision 43792) +++ docs/dev/pmc_obj_design_meeting_notes.pod (working copy) @@ -60,7 +60,7 @@ statically calls the method in the current class. B: 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. Index: docs/dev/pccmethods.pod =================================================================== --- docs/dev/pccmethods.pod (revision 43792) +++ docs/dev/pccmethods.pod (working copy) @@ -10,7 +10,7 @@ A C 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. This offers flexibility -not found in a PMC C or a vtable method using C calling conventions. +not found in a PMC C or a vtable function using C calling conventions. C is used to call a method using the Parrot Calling Conventions. It uses the standard find_method/invoke approach that the callmethodcc opcode @@ -113,7 +113,7 @@ =head2 Performance -When a C or vtable method is called, C is used to map the +When a C or vtable function is called, C 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 to be any slower. It may well Index: lib/Parrot/Vtable.pm =================================================================== --- lib/Parrot/Vtable.pm (revision 43792) +++ lib/Parrot/Vtable.pm (working copy) @@ -67,7 +67,7 @@ [ 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. If it is not an MMD method, C is -1. =cut @@ -209,7 +209,7 @@ /* * 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,7 +281,7 @@ =item C -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 Index: lib/Parrot/Pmc2c/PMC/default.pm =================================================================== --- lib/Parrot/Pmc2c/PMC/default.pm (revision 43792) +++ lib/Parrot/Pmc2c/PMC/default.pm (working copy) @@ -32,7 +32,7 @@ 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); Index: lib/Parrot/Pmc2c/PMC/Object.pm =================================================================== --- lib/Parrot/Pmc2c/PMC/Object.pm (revision 43792) +++ lib/Parrot/Pmc2c/PMC/Object.pm (working copy) @@ -22,8 +22,8 @@ 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,7 +31,7 @@ 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,7 +56,7 @@ 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,7 +76,7 @@ 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); Index: lib/Parrot/Pmc2c/PMC/Null.pm =================================================================== --- lib/Parrot/Pmc2c/PMC/Null.pm (revision 43792) +++ lib/Parrot/Pmc2c/PMC/Null.pm (working copy) @@ -29,7 +29,7 @@ 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); Index: lib/Parrot/Pmc2c/PMC/ParrotClass.pm =================================================================== --- lib/Parrot/Pmc2c/PMC/ParrotClass.pm (revision 43792) +++ lib/Parrot/Pmc2c/PMC/ParrotClass.pm (working copy) @@ -66,7 +66,7 @@ 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}; Index: lib/Parrot/Pmc2c/Object.pm =================================================================== --- lib/Parrot/Pmc2c/Object.pm (revision 43792) +++ lib/Parrot/Pmc2c/Object.pm (working copy) @@ -37,8 +37,8 @@ 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 Index: lib/Parrot/Pmc2c/PMCEmitter.pm =================================================================== --- lib/Parrot/Pmc2c/PMCEmitter.pm (revision 43792) +++ lib/Parrot/Pmc2c/PMCEmitter.pm (working copy) @@ -167,7 +167,7 @@ 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,7 +322,7 @@ 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,7 +1028,7 @@ 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'; Index: lib/Parrot/Pmc2c/MethodEmitter.pm =================================================================== --- lib/Parrot/Pmc2c/MethodEmitter.pm (revision 43792) +++ lib/Parrot/Pmc2c/MethodEmitter.pm (working copy) @@ -215,7 +215,7 @@ =item C Rewrites the method body performing the various macro substitutions for -vtable method bodies (see F). +vtable function bodies (see F). =cut Index: lib/Parrot/Pmc2c/PMC.pm =================================================================== --- lib/Parrot/Pmc2c/PMC.pm (revision 43792) +++ lib/Parrot/Pmc2c/PMC.pm (working copy) @@ -132,7 +132,7 @@ =item C -True if pmc generates code for vtable method C<$method>. +True if pmc generates code for vtable function C<$method>. =cut @@ -321,7 +321,7 @@ =item C -Returns true if the vtable method C<$method> writes our value. +Returns true if the vtable function C<$method> writes our value. =back Index: lib/Parrot/Pmc2c/Parser.pm =================================================================== --- lib/Parrot/Pmc2c/Parser.pm (revision 43792) +++ lib/Parrot/Pmc2c/Parser.pm (working copy) @@ -279,7 +279,7 @@ } 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); Index: compilers/pct/src/POST/Node.pir =================================================================== --- compilers/pct/src/POST/Node.pir (revision 43792) +++ compilers/pct/src/POST/Node.pir (working copy) @@ -82,7 +82,7 @@ .end -=item get_string() # vtable method +=item get_string() # vtable function Returns the result of the current node as a string. Index: compilers/pirc/src/pircompunit.c =================================================================== --- compilers/pirc/src/pircompunit.c (revision 43792) +++ compilers/pirc/src/pircompunit.c (working copy) @@ -184,9 +184,9 @@ set_sub_vtable(lexer_state * const lexer, char const * vtablename)> Set the :vtable() flag argument to the current subroutine. If C -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,12 +198,12 @@ if (vtablename == NULL) /* the sub's name I 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); Index: compilers/pirc/src/pircompunit.h =================================================================== --- compilers/pirc/src/pircompunit.h (revision 43792) +++ compilers/pirc/src/pircompunit.h (working copy) @@ -84,7 +84,7 @@ 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 */ Index: t/pmc/pmcproxy.t =================================================================== --- t/pmc/pmcproxy.t (revision 43792) +++ t/pmc/pmcproxy.t (working copy) @@ -144,7 +144,7 @@ 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,7 +178,7 @@ 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') Index: t/pmc/exception-old.t =================================================================== --- t/pmc/exception-old.t (revision 43792) +++ t/pmc/exception-old.t (working copy) @@ -359,7 +359,7 @@ /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' ); Index: t/dynpmc/rotest.t =================================================================== --- t/dynpmc/rotest.t (revision 43792) +++ t/dynpmc/rotest.t (working copy) @@ -49,7 +49,7 @@ 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 ], Index: t/op/exceptions.t =================================================================== --- t/op/exceptions.t (revision 43792) +++ t/op/exceptions.t (working copy) @@ -378,7 +378,7 @@ 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' ); Index: examples/tutorial/56_defined.pir =================================================================== --- examples/tutorial/56_defined.pir (revision 43792) +++ examples/tutorial/56_defined.pir (working copy) @@ -26,7 +26,7 @@ =pod Most PMC's, but not all, should return true for C. It all -depends on how the PMC implements its vtable method for C. +depends on how the PMC implements its vtable function for C. For example the C PMC always returns false (0) for C. =cut