Studio:Working with pointers to target-resident functions - Revision history

Timd: Text replace - 'Category:Function Pointers' to 'Category:Studio:Function Pointers'

2009-08-21T00:50:45Z

Text replace - 'Category:Function Pointers' to 'Category:Studio:Function Pointers'

← Older revision		Revision as of 00:50, 21 August 2009
Line 73:		Line 73:
	</source>		</source>

	[[Category:Function Pointers]]		[[Category:Studio:Function Pointers]]
	[[Category:Studio:Workarounds]]		[[Category:Studio:Workarounds]]

Timd: Text replace - 'Category:Workarounds' to 'Category:Studio:Workarounds'

2009-08-21T00:18:46Z

Text replace - 'Category:Workarounds' to 'Category:Studio:Workarounds'

← Older revision		Revision as of 00:18, 21 August 2009
Line 74:		Line 74:

	[[Category:Function Pointers]]		[[Category:Function Pointers]]
	[[Category:Workarounds]]		[[Category:Studio:Workarounds]]

Timd: Working with pointers to target-resident functions moved to Studio:Working with pointers to target-resident functions

2009-08-18T23:13:45Z

Working with pointers to target-resident functions moved to Studio:Working with pointers to target-resident functions

← Older revision	Revision as of 23:13, 18 August 2009
(No difference)

Timd at 23:46, 10 March 2008

2008-03-10T23:46:44Z

← Older revision		Revision as of 23:46, 10 March 2008
Line 8:		Line 8:
	The following code sample illustrates our example:		The following code sample illustrates our example:

			<source lang="c">
	typedef enum {		typedef enum {
	TASK_SETUP,		TASK_SETUP,
Line 37:		Line 38:
	#pragma scl_function(getTaskHandle)		#pragma scl_function(getTaskHandle)
	#pragma scl_function(TaskCreate)		#pragma scl_function(TaskCreate)
			</source>

	Here, '''TaskCreate''' is our captured function on the target that accepts task handles to start. '''getTaskHandle''' is our helper function that takes a choice as input and returns a pointer to one of the on-target functions '''Setup''', '''Read''', and '''Shutdown'''. The only interfaces to the host are the captured functions '''getTaskHandle''' and '''TaskCreate'''.		Here, '''TaskCreate''' is our captured function on the target that accepts task handles to start. '''getTaskHandle''' is our helper function that takes a choice as input and returns a pointer to one of the on-target functions '''Setup''', '''Read''', and '''Shutdown'''. The only interfaces to the host are the captured functions '''getTaskHandle''' and '''TaskCreate'''.
Line 42:		Line 44:
	Finally, we show how these interfaces are called from a host script:		Finally, we show how these interfaces are called from a host script:

			<source lang="javascript">
	studio.Workspace.Interfaces.Item("getTaskHandle").Owner.Register();		studio.Workspace.Interfaces.Item("getTaskHandle").Owner.Register();
	studio.Workspace.Interfaces.Item("TaskCreate").Owner.Register();		studio.Workspace.Interfaces.Item("TaskCreate").Owner.Register();
Line 68:		Line 71:
	fnTaskCreate.User.ParameterList.handle = fnGetTaskHandle.User.ReturnValue;		fnTaskCreate.User.ParameterList.handle = fnGetTaskHandle.User.ReturnValue;
	fnTaskCreate.User.Call();		fnTaskCreate.User.Call();
			</source>

	[[Category:Function Pointers]]		[[Category:Function Pointers]]
	[[Category:Workarounds]]		[[Category:Workarounds]]

Timd at 18:48, 29 February 2008

2008-02-29T18:48:04Z

← Older revision		Revision as of 18:48, 29 February 2008
Line 68:		Line 68:
	fnTaskCreate.User.ParameterList.handle = fnGetTaskHandle.User.ReturnValue;		fnTaskCreate.User.ParameterList.handle = fnGetTaskHandle.User.ReturnValue;
	fnTaskCreate.User.Call();		fnTaskCreate.User.Call();
			[[Category:Function Pointers]]
			[[Category:Workarounds]]

Root: /* A technique for calling target-resident functions through opaque function pointers. */

2007-07-19T20:01:40Z

A technique for calling target-resident functions through opaque function pointers.

← Older revision		Revision as of 20:01, 19 July 2007
Line 1:		Line 1:
	=== A technique for calling target-resident functions through opaque function pointers. ===		=== A technique for calling target-resident functions through opaque function pointers===

	Occasionally it is desirable to execute functions on target that are unknown to the host, that is, the functions to be called are implemented on the target and not exposed to the host through an interface.		Occasionally it is desirable to execute functions on the target that are unknown to the host; that is, the functions to be called are implemented on the target and not exposed to the host through an interface.
	For example, a target-based function, '''''TaskCreate''''' could accept as input a function pointer that it uses to start a task. These task functions are unknown to the caller of '''TaskCreate''' on the host. The pointer passed into '''TaskCreate''' is opaque from the caller's perspective. As far as the caller knows, ~~he gets~~ a task handle from somewhere, and calls '''TaskCreate''' to start it.		For example, a target-based function, '''''TaskCreate''''', could accept as input a function pointer that it uses to start a task. These task functions are unknown to the caller of '''TaskCreate''' on the host. The pointer passed into '''TaskCreate''' is opaque from the caller's perspective. As far as the caller knows, a task handle is gotten from somewhere, and calls '''TaskCreate''' in order to start it.

	So, how can a task handle be obtained by the host? A target-based inline helper function could be written to pass back an opaque pointer to an appropriate function, based on ~~some~~ criteria passed in by the caller.		So how can a task handle be obtained by the host? A target-based inline helper function could be written to pass back an opaque pointer to an appropriate function, based on criteria passed in by the caller.

	~~We'll use the~~ following code sample ~~to illustrate~~ our example:		The following code sample illustrates our example:

	typedef enum {		typedef enum {

Stevel: Controlling target-resident callbacks moved to Working with pointers to target-resident functions: Renamed title.

2007-07-13T23:32:29Z

Controlling target-resident callbacks moved to Working with pointers to target-resident functions: Renamed title.

← Older revision	Revision as of 23:32, 13 July 2007
(No difference)

Stevel: Working with pointers to target-resident functions

2007-07-13T23:27:00Z

Working with pointers to target-resident functions

← Older revision		Revision as of 23:27, 13 July 2007
Line 1:		Line 1:
	=== A technique for ~~controlling~~ target-resident ~~callbacks from a target~~ function. ===		=== A technique for calling target-resident functions through opaque function pointers. ===

	Occasionally it is desirable to execute functions on target that are unknown to the host, that is, the functions to be called are implemented on the target and not exposed to the host through an interface.		Occasionally it is desirable to execute functions on target that are unknown to the host, that is, the functions to be called are implemented on the target and not exposed to the host through an interface.

Roberth: /* A technique for controlling target-resident callbacks from a target function. */

2007-07-13T22:37:20Z

A technique for controlling target-resident callbacks from a target function.

← Older revision		Revision as of 22:37, 13 July 2007
Line 38:		Line 38:
	#pragma scl_function(TaskCreate)		#pragma scl_function(TaskCreate)

	Here, '''TaskCreate''' is our captured function on the target that accepts task handles to start. '''getTaskHandle''' is our helper function that takes a choice as input and returns a pointer to one of the ~~internal~~ functions '''Setup''', '''Read''', and '''Shutdown'''. The only interfaces to the host are the captured functions '''getTaskHandle''' and '''TaskCreate'''.		Here, '''TaskCreate''' is our captured function on the target that accepts task handles to start. '''getTaskHandle''' is our helper function that takes a choice as input and returns a pointer to one of the on-target functions '''Setup''', '''Read''', and '''Shutdown'''. The only interfaces to the host are the captured functions '''getTaskHandle''' and '''TaskCreate'''.

	Finally, we show how these interfaces are called from a host script:		Finally, we show how these interfaces are called from a host script:
Line 49:		Line 49:

	// get and call the setup task		// get and call the setup task
	fnGetTaskHandle.User.ParameterList.eChoice = 0;		fnGetTaskHandle.User.ParameterList.eChoice = "TASK_SETUP";
	fnGetTaskHandle.User.Call();		fnGetTaskHandle.User.Call();
	ascript.MessageBox(fnGetTaskHandle.User.ReturnValue);		ascript.MessageBox(fnGetTaskHandle.User.ReturnValue);
Line 56:		Line 56:

	// get and call the read task		// get and call the read task
	fnGetTaskHandle.User.ParameterList.eChoice = 1;		fnGetTaskHandle.User.ParameterList.eChoice = "TASK_READ";
	fnGetTaskHandle.User.Call();		fnGetTaskHandle.User.Call();
	ascript.MessageBox(fnGetTaskHandle.User.ReturnValue);		ascript.MessageBox(fnGetTaskHandle.User.ReturnValue);
Line 63:		Line 63:

	// get and call the shutdown task		// get and call the shutdown task
	fnGetTaskHandle.User.ParameterList.eChoice = 2;		fnGetTaskHandle.User.ParameterList.eChoice = "TASK_SHUTDOWN";
	fnGetTaskHandle.User.Call();		fnGetTaskHandle.User.Call();
	ascript.MessageBox(fnGetTaskHandle.User.ReturnValue);		ascript.MessageBox(fnGetTaskHandle.User.ReturnValue);
	fnTaskCreate.User.ParameterList.handle = fnGetTaskHandle.User.ReturnValue;		fnTaskCreate.User.ParameterList.handle = fnGetTaskHandle.User.ReturnValue;
	fnTaskCreate.User.Call();		fnTaskCreate.User.Call();

Stevel: /* Technique for controlling target-resident callbacks from a target function. */

2007-07-13T20:44:18Z

Technique for controlling target-resident callbacks from a target function.

← Older revision		Revision as of 20:44, 13 July 2007
Line 1:		Line 1:
	=== ~~Technique~~ for controlling target-resident callbacks from a target function. ===		=== A technique for controlling target-resident callbacks from a target function. ===

	Occasionally it is desirable to execute functions on target that are unknown to the host, that is, the functions to be called are implemented on the target and not exposed to the host through an interface.		Occasionally it is desirable to execute functions on target that are unknown to the host, that is, the functions to be called are implemented on the target and not exposed to the host through an interface.