Studio:Scl ptr opaque - Revision history

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

2009-08-21T00:41:39Z

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

← Older revision		Revision as of 00:41, 21 August 2009
Line 77:		Line 77:
	For additional information on scl_ptr_opaque, including constraints, refer to the section on scl_ptr_opaque in the [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]].		For additional information on scl_ptr_opaque, including constraints, refer to the section on scl_ptr_opaque in the [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]].

	[[Category: Pointers]]		[[Category:Studio:Pointers]]
	[[Category:Studio:SCL]]		[[Category:Studio:SCL]]

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

2009-08-21T00:11:45Z

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

← Older revision		Revision as of 00:11, 21 August 2009
Line 78:		Line 78:

	[[Category: Pointers]]		[[Category: Pointers]]
	[[Category: SCL]]		[[Category:Studio:SCL]]

Timd: Scl ptr opaque moved to Studio:Scl ptr opaque

2009-08-18T22:41:01Z

Scl ptr opaque moved to Studio:Scl ptr opaque

← Older revision	Revision as of 22:41, 18 August 2009
(No difference)

Stevel: /* See Also */

2008-10-08T20:34:06Z

Ivailop: /* See Also */

2008-10-02T17:53:38Z

Ivailop: /* See Also */

2008-10-02T00:23:49Z

Ivailop: /* Examples */

2008-10-02T00:23:23Z

Examples

← Older revision		Revision as of 00:23, 2 October 2008
Line 30:		Line 30:
	Two examples using the scl_ptr_opaque pragma are shown below:		Two examples using the scl_ptr_opaque pragma are shown below:

	# The first example uses the scl_ptr_opaque pragma to declare a structure member and a parameter list member as an opaque pointer.		=== Example 1 ===
			The first example uses the scl_ptr_opaque pragma to declare a structure member and a parameter list member as an opaque pointer.
	~~# The second example uses the scl_ptr_opaque pragma~~ to ~~declare pointer type definitions as opaque.~~		<source lang=c>
			// Typedef defining a structure with a member of type pointer to char //
			typedef struct
			{
			int f1;
			char * f2;
			}data_t;

	~~=== Example 1 ===~~		// Function prototype with an INOUT pointer of type data_t //
	// ~~Typedef defining a structure~~ with ~~a member~~ of type ~~pointer to char~~ //		void modifyData( data_t * p );
	~~typedef struct~~
	{
	~~int f1;~~
	~~char~~ * ~~f2;~~
	~~}data_t~~;

	~~// Function prototype with an INOUT pointer of type data_t //~~		// Use the scl_function pragma to associate a SUID with the function ModifyData //
	~~void modifyData( data_t * p );~~		#pragma scl_function( modifyData )
	// Use the scl_function pragma to associate a SUID with the function ModifyData //		// Use the scl_ptr_opaque pragma to define the member f2 as opaque //
	#pragma scl_function( modifyData )		#pragma scl_ptr_opaque( data_t.f2 )
	// Use the scl_ptr_opaque pragma to define the member f2 as opaque //		// Use the scl_ptr_opaque pragma to define the parameter p as opaque //
	#pragma scl_ptr_opaque( data_t.f2 )		#pragma scl_ptr_opaque( modifyData.p )
	// Use the scl_ptr_opaque pragma to define the parameter p as opaque //		</source>
	#pragma scl_ptr_opaque( modifyData.p )

	=== Example 2 ===		=== Example 2 ===
	// Typedef defining a structure with two members //		The second example uses the scl_ptr_opaque pragma to declare pointer type definitions as opaque.
	typedef struct		<source lang=c>
	{		// Typedef defining a structure with two members //
	int f1;		typedef struct
	char f2;		{
	}data_t;		int f1;
			char f2;
			}data_t;

			// Typedef defining a pointer to the data strucure //
			typedef data_t * pointerToData;
			// Prototype defining a function that returns a pointer to the data structure //
			data_t * getData( void );

	~~// Typedef defining a pointer to the data strucure //~~		// Use the scl_ptr_opaque pragma to define the type pointerToData as opaque //
	~~typedef data_t * pointerToData;~~		#pragma scl_ptr_opaque( pointerToData )
	~~// Prototype defining a function that returns a pointer to the data structure //~~		// Use the scl_function pragma to associate a SUID with the function "getData" //
	~~data_t * getData( void );~~		#pragma scl_function( getData )
	// Use the scl_ptr_opaque pragma to define the type pointerToData as opaque //		// Use the scl_ptr pragma to define "getData" return value as opaque pointer //
	#pragma scl_ptr_opaque( pointerToData )		#pragma scl_ptr_opaque( getData )
	// Use the scl_function pragma to associate a SUID with the function "getData" //		</source>
	#pragma scl_function( getData )
	// Use the scl_ptr pragma to define "getData" return value as opaque pointer //
	#pragma scl_ptr_opaque( getData )

	== See Also ==		== See Also ==

Stevel at 17:55, 16 July 2008

2008-07-16T17:55:59Z

← Older revision		Revision as of 17:55, 16 July 2008
Line 25:		Line 25:
	* An opaque pointer is a pointer that points to opaque data. This means that the receiver of the pointer may not examine the data being pointed to. The meaningful part of an opaque pointer is the pointer value itself, or the pointer address. Opaque pointer are often used for the passing of handles.		* An opaque pointer is a pointer that points to opaque data. This means that the receiver of the pointer may not examine the data being pointed to. The meaningful part of an opaque pointer is the pointer value itself, or the pointer address. Opaque pointer are often used for the passing of handles.
	* A pointer of type void (i.e., void *) is by default an opaque pointer. No pragma may be applied to a void pointer.		* A pointer of type void (i.e., void *) is by default an opaque pointer. No pragma may be applied to a void pointer.
	* For additional information on scl_ptr_opaque, including constraints, refer to the section on scl_ptr_opaque in the [[http://www.s2technologies.com/pdf/s2sSCLReferenceGuide.pdf SCL Reference Guide]].

	== Examples ==		== Examples ==
Line 70:		Line 69:
	// Use the scl_ptr pragma to define "getData" return value as opaque pointer //		// Use the scl_ptr pragma to define "getData" return value as opaque pointer //
	#pragma scl_ptr_opaque( getData )		#pragma scl_ptr_opaque( getData )

			== See Also ==
			* For additional information on scl_ptr_opaque, including constraints, refer to the section on scl_ptr_opaque in the [[http://www.s2technologies.com/pdf/s2sSCLReferenceGuide.pdf SCL Reference Guide]].

			[[Category: SCL_Reference]]

Stevel at 22:17, 10 July 2008

2008-07-10T22:17:03Z

← Older revision		Revision as of 22:17, 10 July 2008
Line 1:		Line 1:
	= The ~~scl_ptr_flist~~ pragma =		= The scl_ptr_opaque pragma =

	The scl_ptr_opaque pragma is used to specify a pointer data type as pointing to opaque data that should not be marshaled.		The scl_ptr_opaque pragma is used to specify a pointer data type as pointing to opaque data that should not be marshaled.

Stevel: New page: = The scl_ptr_flist pragma = The scl_ptr_opaque pragma is used to specify a pointer data type as pointing to opaque data that should not be marshaled. == Syntax == #pragma scl_ptr_opaq...

2008-07-10T22:16:03Z

New page: = The scl_ptr_flist pragma = The scl_ptr_opaque pragma is used to specify a pointer data type as pointing to opaque data that should not be marshaled. == Syntax == #pragma scl_ptr_opaq...

New page

= The scl_ptr_flist pragma =

The scl_ptr_opaque pragma is used to specify a pointer data type as pointing to opaque data that should not be marshaled.

== Syntax ==
#pragma scl_ptr_opaque(type-name)

#pragma scl_ptr_opaque(type-name, field-name)

{| border="1" cellspacing="0" cellpadding="10" style="align:left;"
| '''Parameters'''
| '''Type'''
| '''Description'''
|-
| ''type-name''
| Type
| Name of the type that contains the Pointer. The container type may be the name of a structure, a union, the pointer type itself, or a function. If the container type is a structure or a union, then the pointer is a member and the field-name must be specified. If the container type is a function, then the pointer is a parameter and the field-name must be specified.
|-
| ''field-name [Optional]''
| Member
| Name of the Pointer field, which may be a member field contained within a structure/union, or a parameter in the parameter list of a function.
|}

== Notes ==
* An opaque pointer is a pointer that points to opaque data. This means that the receiver of the pointer may not examine the data being pointed to. The meaningful part of an opaque pointer is the pointer value itself, or the pointer address. Opaque pointer are often used for the passing of handles.
* A pointer of type void (i.e., void *) is by default an opaque pointer. No pragma may be applied to a void pointer.
* For additional information on scl_ptr_opaque, including constraints, refer to the section on scl_ptr_opaque in the [[http://www.s2technologies.com/pdf/s2sSCLReferenceGuide.pdf SCL Reference Guide]].

== Examples ==

Two examples using the scl_ptr_opaque pragma are shown below:

# The first example uses the scl_ptr_opaque pragma to declare a structure member and a parameter list member as an opaque pointer.

# The second example uses the scl_ptr_opaque pragma to declare pointer type definitions as opaque.

=== Example 1 ===
// Typedef defining a structure with a member of type pointer to char //
typedef struct
{
int f1;
char * f2;
}data_t;

// Function prototype with an INOUT pointer of type data_t //
void modifyData( data_t * p );
// Use the scl_function pragma to associate a SUID with the function ModifyData //
#pragma scl_function( modifyData )
// Use the scl_ptr_opaque pragma to define the member f2 as opaque //
#pragma scl_ptr_opaque( data_t.f2 )
// Use the scl_ptr_opaque pragma to define the parameter p as opaque //
#pragma scl_ptr_opaque( modifyData.p )

=== Example 2 ===
// Typedef defining a structure with two members //
typedef struct
{
int f1;
char f2;
}data_t;

// Typedef defining a pointer to the data strucure //
typedef data_t * pointerToData;
// Prototype defining a function that returns a pointer to the data structure //
data_t * getData( void );
// Use the scl_ptr_opaque pragma to define the type pointerToData as opaque //
#pragma scl_ptr_opaque( pointerToData )
// Use the scl_function pragma to associate a SUID with the function "getData" //
#pragma scl_function( getData )
// Use the scl_ptr pragma to define "getData" return value as opaque pointer //
#pragma scl_ptr_opaque( getData )

← Older revision		Revision as of 20:34, 8 October 2008
Line 75:		Line 75:

	== See Also ==		== See Also ==
	For additional information on scl_ptr_opaque, including constraints, refer to the section on scl_ptr_opaque in the [~~http~~:~~//www.s2technologies.com/pdf/~~s2sSCLReferenceGuide.pdf SCL Reference Guide].		For additional information on scl_ptr_opaque, including constraints, refer to the section on scl_ptr_opaque in the [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]].

	[[Category: Pointers]]		[[Category: Pointers]]
	[[Category: SCL]]		[[Category: SCL]]

← Older revision		Revision as of 17:53, 2 October 2008
Line 77:		Line 77:
	For additional information on scl_ptr_opaque, including constraints, refer to the section on scl_ptr_opaque in the [http://www.s2technologies.com/pdf/s2sSCLReferenceGuide.pdf SCL Reference Guide].		For additional information on scl_ptr_opaque, including constraints, refer to the section on scl_ptr_opaque in the [http://www.s2technologies.com/pdf/s2sSCLReferenceGuide.pdf SCL Reference Guide].

	[[Category: ~~SCL_Reference~~]]		[[Category: Pointers]]
			[[Category: SCL]]