Fix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates aFix bug #45.

Note there's an issue with raw subtitutions if you put an argument
such as $1=last, and last happens to be used as a local variable
as well. This can be fixed by assigning the argument to a local
variable first, before defining the other locals.

There is another problem too: the floating insertion instantiation
checks that emitted text is unique. However an overloaded function
which is overloaded only on some arguments could be emitted
with two definitions. The solution is to pass a dummy argument.

However even that is not enough, in the case where Felix uses
two names for the same type, eg a struct name and also a different
typedef.

In general there is no possible solution to this: if one of the types
is a pointer, even the function name can't be mangled with the type
name as a prefix (because it would get a gratuitous asterisk (*)
in it).

The only real solution to this one requires the C++ compiler
to make the distinctions, because its the only tool that knows
the actual C++ types. The way to do that is to use a template,
and pass the types as arguments, then C++ will instantiated it
exactly once for every real type set.

The problem with THAT is that C++ templates are badly broken,
in that they don't handle recursion. Template type arguments
cannot refer to the template, even unrelated incomplete
types are not allowed.

Indeed .. this is the reason Felix generates its own instances
of polymorphic entities. If only the C++ committee would fix this
stupidity.

So we're full circle.