allowing a function to be called only from a specific function

[junky_fellow]

Hi,

Is there any way, by which we can limit a specific function to be
called
only from a specific function ? I dont know the advantage of this.
Someone
asked this question from me in an interview.

thanks for any help ...

[Malcolm]

<ju**********@y ahoo.co.inwrote in message
news:11******** **************@ j72g2000cwa.goo glegroups.com.. .

>

On Nov 29, 3:50 pm, Richard Heathfield <[e-mail].i nvalidwrote:

>junky_fel...@y ahoo.co.in said:

Hi,

Is there any way, by which we can limit a specific function to be
called
only from a specific function ? I dont know the advantage of this.
Someone
asked this question from me in an interview.

thanks for any help ...For ease of reference, let's call them foo() and
bar(), and you want it to

be impossible to call bar() except from foo().

Put foo() and bar() in foo.c. Make bar() static:

static int bar(double *, void ***, char, unsigned long);

Compile foo.c to an object file, and publish the object file, together
with
the interface spec (foo.h, which need not and indeed should not even
mention bar() at all), to your users. Don't give them the source file.
:-)
They don't need it, and it'd only get them poking around in the guts of
bar(), which is presumably what you're trying to prevent.

Provided you do not export bar()'s address from foo() - and if you don't
know what I'm talking about, it's extremely unlikely that you'd do this
by
accident! - then you will now only be able to call bar() from foo().

In fact, I also suggested the same thing, but he said that there could
be
multilpe functions (say f1(), f2(), f3(), f4() etc) in the some file
and
f1() should be allowed to be called only from f2() and not from any
other function in that file or in some other file. Is there any way of
doing it ?

The interviewer is out of date.
Some old-time C compilers allowed the use of local function definitons

int foo()
{
int bar(int, int);

return bar(1,2);
}

int bar()
int x,
int y
{
return 0;
}

bar is now local to foo(). I think I've got that right. It never caught on
and now static is the universally-approved way of restricting access to a
function.
--
www.personal.leeds.ac.uk/~bgy1mm
freeware games to download.

[Old Wolf]

Chris Dollin wrote:

ju**********@ya hoo.co.in wrote:

Is there any way, by which we can limit a specific function to be
called only from a specific function ?

f3() { ... }

f4() { ... }

f5() { ... }

static f1() { ... }

f2() { ... f1() ... }

f3() can still write:
int f1();

to declare f1, and then call it.

[Old Wolf]

santosh wrote:

ju**********@ya hoo.co.in wrote:

In fact, I also suggested the same thing, but he said that there could
be multilpe functions (say f1(), f2(), f3(), f4() etc) in the some file
and f1() should be allowed to be called only from f2() and not from any
other function in that file or in some other file. Is there any way of
doing it ?

I think you want C++.

C++ does not support this either.

[Keith Thompson]

"Malcolm" <re*******@btin ternet.comwrite s:
[...]

The interviewer is out of date.
Some old-time C compilers allowed the use of local function definitons

int foo()
{
int bar(int, int);

return bar(1,2);
}

int bar()
int x,
int y
{
return 0;
}

bar is now local to foo(). I think I've got that right. It never caught on
and now static is the universally-approved way of restricting access to a
function.

That's not a local function definition; it's merely a local function
declaration. It's still perfectly legal, just as it always has been,
though it's widely considered to be poor style. (This specific
example would have been illegal before the introduction of prototypes,
but a local "int bar();" would have been legal.)

(There are other problems with the code.)

A local function *definition* would look like this:

int foo(void)
{
int bar(int x, int y)
{
return 0;
}
return bar(1, 2);
}

This has never been legal in standard C. <OT>gcc allows it as an
extension.</OT>

Nested functions make the compiler's job more difficult if it has to
support an inner function referring to an object declared in an outer
function.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <* <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Harald van Dijk]

Old Wolf wrote:

Chris Dollin wrote:

ju**********@ya hoo.co.in wrote:
Is there any way, by which we can limit a specific function to be
called only from a specific function ?

f3() { ... }

f4() { ... }

f5() { ... }

static f1() { ... }

f2() { ... f1() ... }

f3() can still write:
int f1();

to declare f1, and then call it.

When f1 is defined static, it cannot.

[Ancient_Hacker]

ju**********@ya hoo.co.in wrote:

Hi,

Is there any way, by which we can limit a specific function to be
called
only from a specific function ? I dont know the advantage of this.
Someone
asked this question from me in an interview.

thanks for any help ...

Lotsa ways to do it:

#define f5 if( strcmp( __FUNC__, "f2" ) == 0 ) f5 (); else
printf("cant call f2 from here");

or if your compiler doesnt have __FUNC__, test for __LINE__

or:

#define f5(x) f5 ( __FUNC__, x )
... then have f5 do the strcmp() for the function names its allowed to
be called from.

or:

in global scope have: char f5;

so nobody can call f5, except f2 is:

void f2( void ){ void f5(); // or whatever, now f5 can be called but
only from in here
}

[CBFalconer]

Harald van D?k wrote:

Old Wolf wrote:

>Chris Dollin wrote:

>>ju**********@ya hoo.co.in wrote:

Is there any way, by which we can limit a specific function to be
called only from a specific function ?

f3() { ... }

f4() { ... }

f5() { ... }

static f1() { ... }

f2() { ... f1() ... }

f3() can still write:
int f1();

to declare f1, and then call it.

When f1 is defined static, it cannot.

Yes it can. The 'static' only prevents visibility outside the
compilation unit.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net>

[Chris Dollin]

Old Wolf wrote:

Chris Dollin wrote:

ju**********@ya hoo.co.in wrote:
Is there any way, by which we can limit a specific function to be
called only from a specific function ?

f3() { ... }

f4() { ... }

f5() { ... }

static f1() { ... }

f2() { ... f1() ... }

f3() can still write:
int f1();

to declare f1, and then call it.

No solution - not even the ones in languages which support interesting
visibility rules - is robust against source editing.

--
Chris "subtle, like a barrel" Dollin
"A facility for quotation covers the absence of original thought." /Gaudy Night/

[Harald van Dijk]

CBFalconer wrote:

Harald van D?k wrote:

Old Wolf wrote:

Chris Dollin wrote:
ju**********@ya hoo.co.in wrote:

Is there any way, by which we can limit a specific function to be
called only from a specific function ?

f3() { ... }

f4() { ... }

f5() { ... }

static f1() { ... }

f2() { ... f1() ... }

f3() can still write:
int f1();

to declare f1, and then call it.

When f1 is defined static, it cannot.

Yes it can. The 'static' only prevents visibility outside the
compilation unit.

No, it cannot. f3 is defined before f1 is declared. You can refer to a
static function or variable with an extern declaration if and only if
the a static declaration is already in scope, and you cannot use static
on a function declaration with block scope.

[Christopher Benson-Manica]

Old Wolf <ol*****@inspir e.net.nzwrote:

santosh wrote:

I think you want C++.

C++ does not support this either.

Right, although he may have been thinking of friends and similar
things, which can do something like OP wanted, albeit for classes and
not functions as was required.

--
C. Benson Manica | I *should* know what I'm talking about - if I
cbmanica(at)gma il.com | don't, I need to know. Flames welcome.