ASM Community

.data?

	mystruct ASTRUCT<>

.code

	lea eax, dword ptr MyFunction

	mov mystruct.fptr, eax





                push parm1             ;a way to clean it up from here 

                push parm2

                push parm3

                call mystruct.fptr      ; to here

I seem to remember reading something about mcall?

Thanks.

You can set the type of the structure member like this:

SomeFunction PROTO STDCALL :DWORD



ptrSomeFunction typedef PTR SomeFunction



SomeStruct STRUCT

...

fptr ptrSomeFunction ?

...

SomeStruct ENDS



Then just call:



invoke someStructInstance.fptr, 0

Thomas

Thanks for the replies. I think I need to explain a little better.

I cannot use invoke with a function pointer, because invoke only works with prototyped functions. Unless there is a way to prototype a funtion pointer, invoke will not work.

The verbose method of pushing parms and calling will work.

I probly should not have put 1,2,3 after the parms. Order is not the problem. I am assuming the parameter order is always correct _stdcall.

I don't know anything about making macro, and a Google search didn't turn up any tuts. I am sure that by now someone else has realized they can't prototype a function pointer. I figure by now someone has made a macro wrap pushing of paramaters and calling. If there already is one, and it could be considered standard, I'd prefer to use it before trying my own. I'm working on a high level data structure with embedded functions. I'd like to give the user the option of using the verbose method, or using a macro. I don't want to confuse things by making a macro that already exists.

Thanks for the help, I've already learned something from the previous posts.

Wow, not what I was looking for but better!!!:eek:

By just making several TYPEDEFs, ie.
(stealing you stuff)

Type1    TYPEDEF PROTO :DWORD, 

Type2    TYPEDEF PROTO :DWORD,DWORD

Type3    TYPEDEF PROTO :DWORD,DWORD,DWORD

It looks like you can do function overloading!!:grin:

Or at least varying amounts of parameters depending on what is needed at the time.(just what I may need)

So simple too.
You've been a big help NaN.

Ok...

SetLayeredWindowAttributes PROTO :DWORD, :DWORD, :BYTE, :DWORD



1) invoke (TYPE SetLayeredWindowAttributes) ptr [i]register[/i], <parms>

2) invoke (TYPE SetLayeredWindowAttributes) ptr [[i]register[/i]], <parms>

3) invoke (TYPE SetLayeredWindowAttributes) ptr [[i]variable[/i]], <parms>

1 & 2 work like expected. 3, however, ends up calling "variable", not what
"variable" points to. IE, if "variable" is located at offset 401110 in
memory, you'll see a "call 401110" not "call dword ptr [401110]".

Bitrake, any ideas?

Well, there *is* an opcode for "call indirect", and it sucks that I can't
figure out how to make masm use it for case #3...

Sorry Sliver, currently my ideas on function overloading are confined to the realm of 'wild speculation' based on NaN's post.

I'm not sure #3 might work for me. Heres what I am doing:

.data?

mystruct STRUCT<>

.code



lea edx, dword ptr MyFunction;

;lea eax,[@ILT+0(_MyFuntion@16) (401005h)



mov mystruct.handle, edx;first struct element=pointer to function



push something

push something

push something

call mystruct.handle;diss=call dword ptr[myString (4043A4h)]

The trick is in the call. I call the address of my variable, but the jump table contains the address of my function.

Ahh just tried this, and it works:

call dword ptr mystruct

got to work now

True. I posted exactly what I'm doing just in case someone knows a trick to make it with invoke.

That's still not what wanted - it does "call sstring" and not "call ".
Too bad, I just got my hopes up :(

f0dder, here you go. :)

.data

	P4 TYPEDEF proto :DWORD, :DWORD, :DWORD, :DWORD



	P4P TYPEDEF PTR P4



	Jump dd OFFSET JumpHere

	

	route STRUCT

		tag dd ?

		j P4P ?

	route ENDS



	MyRoute route <>

.code

	; direct

	invoke P4 ptr [JumpHere],4,3,2,1

	; indirect

	invoke P4P ptr [Jump],4,3,2,1

	; indirect

	invoke [MyRoute.j],4,3,2,1

	; indirect

	invoke [ebx].route.j,4,3,2,1

With a creative UNION, a general elegant solution is posible, imo. :)

Something like:

	P0 TYPEDEF proto

	P1 TYPEDEF proto :DWORD

	P2 TYPEDEF proto :DWORD, :DWORD

	P3 TYPEDEF proto :DWORD, :DWORD, :DWORD

	P4 TYPEDEF proto :DWORD, :DWORD, :DWORD, :DWORD

	P5 TYPEDEF proto :DWORD, :DWORD, :DWORD, :DWORD, :DWORD

	P6 TYPEDEF proto :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD

	P7 TYPEDEF proto :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD

	P8 TYPEDEF proto :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD

	P9 TYPEDEF proto :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD, :DWORD



	P0P TYPEDEF PTR P0

	P1P TYPEDEF PTR P1

	P2P TYPEDEF PTR P2

	P3P TYPEDEF PTR P3

	P4P TYPEDEF PTR P4

	P5P TYPEDEF PTR P5

	P6P TYPEDEF PTR P6

	P7P TYPEDEF PTR P7

	P8P TYPEDEF PTR P8

	P9P TYPEDEF PTR P9



	pr UNION

		i0 P0P ?

		i1 P1P ?

		i2 P2P ?

		i3 P3P ?

		i4 P4P ?

		i5 P5P ?

		i6 P6P ?

		i7 P7P ?

		i8 P8P ?

		i9 P9P ?

	pr ENDS

Now just tag any indirect invoke with the proto you want to use: invoke .pr.i4,4,3,2,1. Some will ask why? Well, this abstracts the whole thing to a single public union - the rest of the typedefs/protos can be psuedo-private.