Pragmas - Revision history

Ivailop at 20:48, 17 July 2018

2018-07-17T20:48:09Z

Ivailop: /* Examples */

2015-09-29T22:18:32Z

Examples

← Older revision		Revision as of 22:18, 29 September 2015
Line 39:		Line 39:

	=== Examples ===		=== Examples ===
	Using the ~~defaults for~~ ''~~IMPLICIT~~'' and ''~~STRIDE_TEST_GROUP~~'' when capturing boo		Using the default "IMPLICIT" ''name-mangling'' and "STRIDE_TEST_GROUP" ''group-id'' when capturing <code>boo()</code>
	<source lang=c>		<source lang=c>
	int foo(int x);		int foo(int x);
Line 50:		Line 50:


	Setting a specific ''~~GROUP ID~~''		Setting a specific ''name-mangling'' and ''group-id''
	<source lang=c>		<source lang=c>
	void boo(void);		void boo(void);

Ivailop at 21:29, 10 July 2015

2015-07-10T21:29:16Z

← Older revision		Revision as of 21:29, 10 July 2015
Line 3:		Line 3:
	For details regarding the supported pragmas refer to [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]] document.		For details regarding the supported pragmas refer to [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]] document.

	= scl_function =		== scl_function ==
	The ''scl_function'' pragma allows the user to capture a function. When captured for the purpose of interception ('''intercept-able''') the optional arguments are used to specify how the intercept should be executed.		The ''scl_function'' pragma allows the user to capture a function. When captured for the purpose of interception ('''intercept-able''') the optional arguments are used to specify how the intercept should be executed.

Line 57:		Line 57:
	</source>		</source>

	= scl_cast =		== scl_cast ==
	Constraining is the transformation of a data type so that it behaves like another data type. There are two forms of constraining: type constraining and value constraining (see ''scl_values'' pragma).		Constraining is the transformation of a data type so that it behaves like another data type. There are two forms of constraining: type constraining and value constraining (see ''scl_values'' pragma).

Line 128:		Line 128:


	= scl_conform =		== scl_conform ==
	The scl_conform pragma allows the user to define a conformant array within a payload. The payload can be a C structure or a parameter declaration list. The conformant array must be the last item in the payload (e.g., the last field in the structure, or the last parameter in the declaration list). Because of this, only the payload name and the name of the size field in that payload are required. The SCL compiler automatically assumes the conformant array field within the specified payload.		The scl_conform pragma allows the user to define a conformant array within a payload. The payload can be a C structure or a parameter declaration list. The conformant array must be the last item in the payload (e.g., the last field in the structure, or the last parameter in the declaration list). Because of this, only the payload name and the name of the size field in that payload are required. The SCL compiler automatically assumes the conformant array field within the specified payload.

Line 185:		Line 185:
	* For additional information on scl_conform, including constraints, refer to the section on scl_conform in the [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]].		* For additional information on scl_conform, including constraints, refer to the section on scl_conform in the [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]].

	= scl_ptr =		== scl_ptr ==

	The scl_ptr pragma is used to identify a pointer data type and assign it pointer-specific attributes, such as marshaling direction and memory usage.		The scl_ptr pragma is used to identify a pointer data type and assign it pointer-specific attributes, such as marshaling direction and memory usage.
Line 299:		Line 299:
	</source>		</source>

	= scl_ptr_flist =		== scl_ptr_flist ==

	The scl_ptr_flist() pragma is used to specify the candidate functions that are available for a specific function pointer data type.		The scl_ptr_flist() pragma is used to specify the candidate functions that are available for a specific function pointer data type.
Line 351:		Line 351:


	= scl_ptr_opaque =		== scl_ptr_opaque ==

	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.
Line 429:		Line 429:
	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]].

	= scl_ptr_sized =		== scl_ptr_sized ==

	The scl_ptr_sized pragma is used to identify a pointer data type, and assign to it attributes that are used to point to a series of elements allocated in contiguous memory. The pragma also assigns additional attributes, such as marshaling direction and memory usage.		The scl_ptr_sized pragma is used to identify a pointer data type, and assign to it attributes that are used to point to a series of elements allocated in contiguous memory. The pragma also assigns additional attributes, such as marshaling direction and memory usage.
Line 548:		Line 548:


	= scl_struct_sized =		== scl_struct_sized ==
	The scl_struct_sized pragma is used to identify a sized structure. A sized structure is a C programming convention for representing a structure whose size is variable and defined by one of the members of the structure. This pragma is infrequently used, but must be used, whenever the programmer defined size does not match the C language size of the structure (as calculated by the sizeof macro).		The scl_struct_sized pragma is used to identify a sized structure. A sized structure is a C programming convention for representing a structure whose size is variable and defined by one of the members of the structure. This pragma is infrequently used, but must be used, whenever the programmer defined size does not match the C language size of the structure (as calculated by the sizeof macro).

Line 617:		Line 617:
	* For additional information on scl_struct_sized, including constraints, refer to the section on scl_struct_sized in the [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]].		* For additional information on scl_struct_sized, including constraints, refer to the section on scl_struct_sized in the [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]].

	= scl_union =		== scl_union ==

	Unions are C language constructs that have a set of members, of which at most one can be stored in the union object at any time. The stored member is called the "active" member. The scl_union pragma identifies which union member is the active member when a union is part of a payload.		Unions are C language constructs that have a set of members, of which at most one can be stored in the union object at any time. The stored member is called the "active" member. The scl_union pragma identifies which union member is the active member when a union is part of a payload.
Line 932:		Line 932:
	* For additional information on the scl_union pragma, including constraints, refer to the section on scl_union in the [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]].		* For additional information on the scl_union pragma, including constraints, refer to the section on scl_union in the [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]].

	= scl_union_activate =		== scl_union_activate ==

	The scl_union_activate pragma provides a means to map discriminant values to specific union members. It can only apply to discriminated unions that have been identified by the scl_union pragma.		The scl_union_activate pragma provides a means to map discriminant values to specific union members. It can only apply to discriminated unions that have been identified by the scl_union pragma.
Line 974:		Line 974:


	= scl_values =		== scl_values ==

	The scl_values pragma allows a data item to be constrained to a particular set of values.		The scl_values pragma allows a data item to be constrained to a particular set of values.

Ivailop at 21:24, 10 July 2015

2015-07-10T21:24:57Z

← Older revision		Revision as of 21:24, 10 July 2015
Line 1:		Line 1:
	The Stride pragmas are designed to allow annotation of C/C++ language constructs in such a way as to identify and define messages, function calls, and test units so that they can be transparently intercepted and remoted. During the build process the [[Build Tools \| Stride Build Tools]] generate [[Intercept Module]] that provides ~~the correct logic~~ for the test.		The Stride pragmas are designed to allow annotation of C/C++ language constructs in such a way as to identify and define messages, function calls, and test units so that they can be transparently intercepted and remoted. During the build process the [[Build Tools \| Stride Build Tools]] generate [[Intercept Module]] that provides [http://en.wikipedia.org/wiki/Test_harness harnessing] for the test.

	For details regarding the supported pragmas refer to [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]] document.		For details regarding the supported pragmas refer to [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]] document.

Ivailop: /* scl_function */

2015-07-10T21:19:14Z

scl_function

← Older revision		Revision as of 21:19, 10 July 2015
Line 26:		Line 26:
	\| ''name-mangling''		\| ''name-mangling''
	\| String		\| String
	\| Optional. Type of [[Name_Mangling\|name mangling]] to be used when intercepted. Possible values are ''"EXPLICIT"'' or ''"IMPLICIT"''. If the ''context'' argument is defined the default will be '''IMPLICIT'''. Note that if '''EXPLICIT''' is set the '''srTEST_INTERCEPT(<function_name>)"''' macro is required.		\| Optional. Type of [[Name_Mangling\|name mangling]] to be used when intercepted. Possible values are ''"EXPLICIT"'' or ''"IMPLICIT"''. If the ''context'' argument is defined the default will be '''IMPLICIT'''. Note that if '''EXPLICIT''' is set the '''srTEST_INTERCEPT('''<function_name>''')''' macro is required.
	\|-		\|-
	\| ''group-id''		\| ''group-id''

Ivailop at 21:15, 10 July 2015

2015-07-10T21:15:32Z

← Older revision		Revision as of 21:15, 10 July 2015
Line 1:		Line 1:
	The Stride pragmas are designed to allow annotation of C language constructs in such a way as to identify and define messages, function calls, and test units so that they can be transparently intercepted and remoted.		The Stride pragmas are designed to allow annotation of C/C++ language constructs in such a way as to identify and define messages, function calls, and test units so that they can be transparently intercepted and remoted. During the build process the [[Build Tools \| Stride Build Tools]] generate [[Intercept Module]] that provides the correct logic for the test.

	For details regarding the supported pragmas refer to [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]] document.		For details regarding the supported pragmas refer to [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]] document.

Ivailop: /* scl_function */

2015-07-10T21:13:05Z

scl_function

← Older revision		Revision as of 21:13, 10 July 2015
Line 8:		Line 8:
	=== Syntax ===		=== Syntax ===

	#pragma scl_function(function-name [,context, name-mangling, group-id])		#pragma scl_function(function-name [,context][, name-mangling][, group-id])


Line 54:		Line 54:
	void boo(void);		void boo(void);

	#pragma scl_function(boo, "DEFINITION", ''IMPLICIT'', ''MY_TEST_GROUP'')		#pragma scl_function(boo, "DEFINITION", "IMPLICIT", "MY_TEST_GROUP")
	</source>		</source>


	= scl_cast =		= scl_cast =

Marku: /* Discriminants */

2015-07-06T14:01:44Z

Discriminants

← Older revision		Revision as of 14:01, 6 July 2015
Line 662:		Line 662:

	==== Discriminants ====		==== Discriminants ====
	Unions within the source code are easily identified by the "union" keyword. As discriminants are not easy to identify, the scl_union() pragma is necessary to identify them. The [[scl_union_activate~~\|scl_union_activate()~~ pragma]] is optionally used to define a mapping between discriminant values and union members.		Unions within the source code are easily identified by the "union" keyword. As discriminants are not easy to identify, the scl_union() pragma is necessary to identify them. The scl_union_activate pragma is optionally used to define a mapping between discriminant values and union members.

	Within a discriminated union, the discriminant value determines the active member of the union, resulting in a mapping between discriminant values and union members. A number of mapping choices are supported:		Within a discriminated union, the discriminant value determines the active member of the union, resulting in a mapping between discriminant values and union members. A number of mapping choices are supported:
Line 676:		Line 676:
	:* A single union may only have a single discriminant field.		:* A single union may only have a single discriminant field.
	:* The type of the discriminant field must be an integer or enumerated type or must have been cast (using scl_cast()) to an integer or enumerated type.		:* The type of the discriminant field must be an integer or enumerated type or must have been cast (using scl_cast()) to an integer or enumerated type.
	:* ~~Any [[scl_values\|~~scl_values() pragma]] applied to the discriminant field affects the default mapping between discriminant values and union members.		:* The scl_values() pragma applied to the discriminant field affects the default mapping between discriminant values and union members.

	==== Default Mapping ====		==== Default Mapping ====

Marku: /* scl_struct_sized */

2015-07-06T14:00:32Z

scl_struct_sized

← Older revision		Revision as of 14:00, 6 July 2015
Line 552:		Line 552:
	The scl_struct_sized pragma is used to identify a sized structure. A sized structure is a C programming convention for representing a structure whose size is variable and defined by one of the members of the structure. This pragma is infrequently used, but must be used, whenever the programmer defined size does not match the C language size of the structure (as calculated by the sizeof macro).		The scl_struct_sized pragma is used to identify a sized structure. A sized structure is a C programming convention for representing a structure whose size is variable and defined by one of the members of the structure. This pragma is infrequently used, but must be used, whenever the programmer defined size does not match the C language size of the structure (as calculated by the sizeof macro).

	NOTE: ''For an alternative use case of sized structure please look at [[scl_conform]] pragma.''		NOTE: ''For an alternative use case of sized structure please look at scl_conform pragma.''

	=== Syntax ===		=== Syntax ===
Line 617:		Line 617:
	=== See Also ===		=== See Also ===
	* For additional information on scl_struct_sized, including constraints, refer to the section on scl_struct_sized in the [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]].		* For additional information on scl_struct_sized, including constraints, refer to the section on scl_struct_sized in the [[Media:s2sSCLReferenceGuide.pdf\|SCL Reference Guide]].


	= scl_union =		= scl_union =

Marku: /* Notes */

2015-07-06T13:59:33Z

Notes

← Older revision		Revision as of 13:59, 6 July 2015
Line 345:		Line 345:
	* The syntax shown in form 2 of 4 above should only be used when returning function pointers.		* The syntax shown in form 2 of 4 above should only be used when returning function pointers.
	* A function pointer data type as written in ANSI C merely specifies the format of the prototype. The format of the prototype is the data type of the return value and the datatypes of the parameters, if any. The scl_ptr_flist() pragma is therefore required by the SCL compiler to indicate which SCL-compatible interfaces are associated with a particular function pointer data type.		* A function pointer data type as written in ANSI C merely specifies the format of the prototype. The format of the prototype is the data type of the return value and the datatypes of the parameters, if any. The scl_ptr_flist() pragma is therefore required by the SCL compiler to indicate which SCL-compatible interfaces are associated with a particular function pointer data type.
	* When a payload contains a field that is a pointer to a function, it is possible that the receiver of such a payload may make a call using the value received. Because the set of possible functions that might be passed is very large, and because all remotable methods must be identified with a SUID, each such payload value be constrained to identify the specific set of functions that might be passed. These are referred to as the candidates. Each candidate must be known by its name. The ~~[[scl_brew_class\|scl_brew_class()]] and~~ scl_ptr_flist() ~~pragmas are~~ used for constraining fields of type pointer to function in this way.		* When a payload contains a field that is a pointer to a function, it is possible that the receiver of such a payload may make a call using the value received. Because the set of possible functions that might be passed is very large, and because all remotable methods must be identified with a SUID, each such payload value be constrained to identify the specific set of functions that might be passed. These are referred to as the candidates. Each candidate must be known by its name. The scl_ptr_flist() pragma is used for constraining fields of type pointer to function in this way.
	* Payload fields of type pointer to function that are not explicitly associated with a list of candidates are treated as if they have been declared as void *.		* Payload fields of type pointer to function that are not explicitly associated with a list of candidates are treated as if they have been declared as void *.

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