The first hunk is in define_new_function(). This if-statement ignores
any inherited private function, so that it's not redefined.
But it also ignores any regular function, that was inherited
with the "private functions" modifier (which makes the function
not private for us, but to outsiders). That's why I also
require NAME_HIDDEN to be set. But NAME_HIDDEN is also set,
when it was only a prototype und so I check, that NAME_UNDEFINED
is not set.

Now to the changes in copy_functions():

This function ignored any NAME_HIDDEN, TYPE_MOD_NO_MASK, but
not NAME_UNDEFINED and not TYPE_MOD_PRIVATE functions. As NAME_HIDDEN
are either private functions, prototypes or cross-definitions,
it can only be later, because private functions have TYPE_MOD_PRIVATE
(and "private nomask" becomes "private", so TYPE_MOD_NO_MASK isn't
satisfied anymore) and Prototypes have NAME_UNDEFINED. I replaced
this by a check for NAME_CROSS_DEFINED. (Don't know, why only
nomask cross-definitions are ignored, I think, it should ignore
all cross-definitions.) Btw. if the "'private nomask' degenerates to
'private'"-part wouldn't be there, it would also ignore 'nomask private'
functions und therefore would not cross-define them, if they were virtual
functions. (Why this missing cross-definition crashes, I'll explain later
in the part for copy_variables.)

virtual private functions should also be cross-defined, that's why
I removed the condition for NAME_HIDDEN. (This condition was superflous,
because the last else-if-statement would cross-define them anyway.)

If this function is private, we keep the first definition.
If the previous function was private (TYPE_MOD_PRIVATE, NAME_HIDDEN
because of "private functions inherit" making the function also
TYPE_MOD_PRIVATE, and not NAME_UNDEFINED to get no prototypes, which
are also NAME_HIDDEN), we take the new function. (For the
current function a check for TYPE_MOD_PRIVATE would only be required,
because it doesn't has the "private functions inherit"-problem.
But to make it uniform, I decided to use the same condition for
fun and OldFunction.)

Only then (just before the cross-definitions) there comes the check
for double inheriting 'nomask' functions. Because private functions
were handled before, I removed the check for TYPE_MOD_PRIVATE.
The same for the following checks: I removed the checks for private
functions. So the last if-condition can be omitted completely (we
handled private and virtual functions before).

After that comes the handling of two functions in the same superclass
having the same name. As cross-definitions are handled before,
the original if-statement can be left out. But now we have to check
whether this new function is really the dominant definition and not
just some invisible function.

The last part is about copy_variables() and why it crashes if two
occurrences of the same private virtual function are not cross-defined.
copy_variables would then adjust the inherit index of the second occurrence,
but neither the function index nor the inherit function index offset
can't be adjusted and so the wrong function index in the inherit's
program will be computed and thus lead to a crash. I inserted a warning
(because I maybe wrong), but I think it should be a fatal error.

Greetings,
Gnomi.