Insuring a function is only called from a macro

[holysmoke]

Hi all,
I have a function

void actualfunction(unsigned int t, unsigned int lineno)
{
....
}

I want that it is called only from a macro I wrote for it (I don't
want to use a wrapper function) like,

#define FUNCTION(a) actualfunction((a), __LINE__)

How to do I insure that actualfunction is only called as FUNCTION?
One thing I could do is, call another function that sets a global
variable and then test that variable in 'actualfunction'.

#define FUNCTION(a) setTest(); \
actualfunction((a), __LINE__); \
void setTest(void)
{
static unsigned char test;
test = 0xFF;
}

void actualfunction(unsigned int t, unsigned int lineno)
{
assert(test == 0xFF);
test = 0x00;

....
}
BTW I'm ok to ignore the case where some calls setTest and then
actualfunction directly but this is a run time check, is a compile
time check posssible?


Would appreciate any pointers. Thanks!

[Richard Tobin]

In article <07**********************************@n33g2000pri. googlegroups.com>,
holysmoke <su**********@gmail.comwrote:

>I want that it is called only from a macro I wrote for it (I don't
want to use a wrapper function) like,

You can't. Anything the macro expands to, the user could just
write themselves.

The simplest solution is to give the function an obscure name that
makes it clear it shouldn't be used, like xxx_function_internal, or
function_calling_me_directly_invalidates_warranty. And document
the fact that it shouldn't be used.

-- Richard
--
Please remember to mention me / in tapes you leave behind.

[Chris M. Thomasson]

"Richard Tobin" <ri*****@cogsci.ed.ac.ukwrote in message
news:g8***********@pc-news.cogsci.ed.ac.uk...

In article
<07**********************************@n33g2000pri. googlegroups.com>,
holysmoke <su**********@gmail.comwrote:

>>I want that it is called only from a macro I wrote for it (I don't
want to use a wrapper function) like,

You can't. Anything the macro expands to, the user could just
write themselves.

The simplest solution is to give the function an obscure name that
makes it clear it shouldn't be used, like xxx_function_internal, or

function_calling_me_directly_invalidates_warranty.

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

=^D

And document
the fact that it shouldn't be used.

[Keith Thompson]

holysmoke <su**********@gmail.comwrites:

I have a function

void actualfunction(unsigned int t, unsigned int lineno)
{
...
}

I want that it is called only from a macro I wrote for it (I don't
want to use a wrapper function) like,

#define FUNCTION(a) actualfunction((a), __LINE__)

How to do I insure that actualfunction is only called as FUNCTION?

[...]

Any standard library function may be additionally implemented as a
macro with the same name. You could use the same trick:

void actualfunction(unsigned int t, unsigned int lineno) { ... }

#define actualfunction(t) ((actualfunction)((t), __LINE__))

Any ordinary function call to actualfunction will invoke your
macro.

As Richard Tobin pointed out, anything you can do in your macro, a
user can also do. In particular, surrounding the function name with
parentheses or taking the function's address will bypass your macro.

But I presume you're not looking for absolute security in the presence
of hostile users, just a convenient way to make it easy for them to
invoke your macro.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[James Harris]

On 19 Aug, 11:31, [e-mail] (Richard Tobin) wrote:

In article <[e-mail]>,

holysmoke <[e-mail]:

I want that it is called only from a macro I wrote for it (I don't
want to use a wrapper function) like,

You can't. Anything the macro expands to, the user could just
write themselves.

Is there a way to use the preprocessor to generate a dynamic name for
the function - based on time of day or something random, even the line
number, as long as it's not known in the calling code - and then call
that from within the macro? Assemblers sometimes permit this. I don't
know about the C preprocessor.

[Eric Sosman]

James Harris wrote:

On 19 Aug, 11:31, [e-mail] (Richard Tobin) wrote:

>In article <[e-mail]>,

holysmoke <[e-mail]:

>>I want that it is called only from a macro I wrote for it (I don't
want to use a wrapper function) like,

You can't. Anything the macro expands to, the user could just
write themselves.

Is there a way to use the preprocessor to generate a dynamic name for
the function - based on time of day or something random, even the line
number, as long as it's not known in the calling code - and then call
that from within the macro? Assemblers sometimes permit this. I don't
know about the C preprocessor.

To do such a thing, you'd need to be able to generate
the same function name at the point of definition and at each
call. Since you might compile the function definition today
and the calls on the second Tuesday of each of the next six
years, I don't see how the name generation could be entirely
impenetrable: All the information needed to come up with the
name is necessarily available at the point of the call.

Macro expansion produces pp-tokens, and once produced there
is nothing that distinguishes pp-tokens generated by macros from
pp-tokens generated directly from the source text.

--
Eric Sosman
es*****@ieee-dot-org.invalid

[Keith Thompson]

James Harris <ja************@googlemail.comwrites:

On 19 Aug, 11:31, [e-mail] (Richard Tobin) wrote:

>In article
<[e-mail]>,

holysmoke <[e-mail]:

>I want that it is called only from a macro I wrote for it (I don't
want to use a wrapper function) like,

You can't. Anything the macro expands to, the user could just
write themselves.

Is there a way to use the preprocessor to generate a dynamic name for
the function - based on time of day or something random, even the line
number, as long as it's not known in the calling code - and then call
that from within the macro? Assemblers sometimes permit this. I don't
know about the C preprocessor.

I can't think of a way to do this from the C preprocessor, but you
could always pre-filter the source code. Something like this:

void func_$(unsigned int t, unsigned int lineno)
{ ... }

#define func(t) (func_$((t), __LINE__))

where your own pre-filter converts each occurrence of $ to some random
number (the same one for each occurrence in the same file).

But really, what does this buy you? For the macro to be useful, you
need to provide the file that defines it to anyone who's going to use
it. Your users can always just take a look at it and see that
func(42)
expands to
(func_845285045997((42), __LINE))

Anything that you can do in a macro, your users will be able to do
themselves.

Assume for the sake of argument that a solution exists, something that
absolutely prevents users from calling your function other than via
the macro. What real advantage would this have over just (a) making
it convenient for users to use the macro, and (b) telling them they
shouldn't call the function directly? Something like this:

void do_not_call_directly(unsigned int t, unsigned int lineno)
{ ... }

#define func(t) (do_not_call_directly((t), __LINE__))

If you really need to *prevent* hostile users from calling your
function directly, that's a much harder problem, and one that I
suspect can't be solved within standard C. If you can just tell them
"If you call this function directly, all bets are off; I reserve the
right to change the name at the next full moon", that's a lot easier.

--
Keith Thompson (The_Other_Keith) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[rudolf]

In article
<17**********************************@26g2000hsk.g ooglegroups.com>,
James Harris <ja************@googlemail.comwrote:

Is there a way to use the preprocessor to generate a dynamic name for
the function - based on time of day or something random, even the line
number, as long as it's not known in the calling code - and then call
that from within the macro? Assemblers sometimes permit this. I don't
know about the C preprocessor.

Doesn't C++ mangle function names sometimes? Maybe you could do
something similar, although I'm not sure how.
** Posted from http://www.teranews.com **

[Richard Tobin]

In article <17**********************************@26g2000hsk.g ooglegroups.com>,
James Harris <ja************@googlemail.comwrote:

>Is there a way to use the preprocessor to generate a dynamic name for
the function - based on time of day or something random, even the line
number, as long as it's not known in the calling code - and then call
that from within the macro?

Even if you could - which you can't - then what's to stop the user
from do the same thing?

Why are you (or the OP) trying to do this? If you want to protect
against mistakes, then the solutions already proposed should be
adequate. If you want to protect against malicious programmers, the
whole thing is futile.

-- Richard
--
Please remember to mention me / in tapes you leave behind.

[James Harris]

On 20 Aug, 08:58, [e-mail] (Richard Tobin) wrote:

In article <[e-mail]>,
James Harris <[e-mail]:

Is there a way to use the preprocessor to generate a dynamic name for
the function - based on time of day or something random, even the line
number, as long as it's not known in the calling code - and then call
that from within the macro?

Even if you could - which you can't - then what's to stop the user
from do the same thing?

Why are you (or the OP) trying to do this? If you want to protect
against mistakes, then the solutions already proposed should be
adequate. If you want to protect against malicious programmers, the
whole thing is futile.

No reason. Just my devious mind wondering if there's an irregular way
to do what the OP wanted. Assemblers sometimes have a facility for
defining unique labels, something along the lines of this pseudo-
assembler

.define uniq @<next_id ;Set up a varying number 0 upwards

func'uniq': ;Label for function proper
... (function code)
ret

.macro KNOWN_FUNCTION_NAME ;Define the name known outside this
file
call func'uniq' ;Call the function proper
.endm ;End of macro
.undef uniq ;Remove this definition

Where @<next_idgenerates a different integer each time it appears.
Then the user code would call KNOWN_FUNCTION_NAME and could not know
in advance except by guessing what the real function name would be.
The real function name would be known only within the separate file
where it is defined.

Sounds like this is not possible with the C preprocessor, though.
Shame.....;-)