Language Reference/Predicates - Revision history

Thomas Linder Puls: /* Suspending */ Released

2024-01-11T12:02:31Z

Suspending: Released

← Older revision		Revision as of 14:02, 11 January 2024
Line 91:		Line 91:

	==== Suspending ====		==== Suspending ====

	~~{{Template:NonReleased}}~~

	Adding <vp>suspending</vp> to a predicate domain makes the predicate a {{lang\|Suspending Predicates\|suspending predicate}}		Adding <vp>suspending</vp> to a predicate domain makes the predicate a {{lang\|Suspending Predicates\|suspending predicate}}

Thomas Linder Puls: suspending

2024-01-04T13:46:26Z

suspending

@@ Line 54: / Line 54: @@
 <vipbnf><PredicateModeAndFlow>:
       <PredicateMode>-opt
       <FlowPattern>-list-opt</vipbnf>
 ==== Predicate Mode ====
@@ Line 96: / Line 89: @@
 Omitting of a predicate mode means <vp>procedure</vp>.
 ==== Flow Pattern ====

Thomas Linder Puls: review

2024-01-04T13:32:45Z

review

← Older revision		Revision as of 15:32, 4 January 2024
Line 25:		Line 25:
	<vipbnf><PredicateName> :		<vipbnf><PredicateName> :
	<LowerCaseIdentifier></vipbnf>		<LowerCaseIdentifier></vipbnf>

			Here {{lang2\|Predicates\|Predicate Domains\|PredicateDomainName}} is the name of a predicate domain declared in a domains section.

			Only class predicates can have link names. If the link name is not stated then a link name is derived from the predicate name, the way this name is derived depends on the {{lang2\|Predicates\|Calling Convention\|calling convention}}.

	=== Predicate Domains ===		=== Predicate Domains ===
Line 60:		Line 64:
	<PredicateMode>-opt		<PredicateMode>-opt
	<FlowPattern>-list-opt</vipbnf>		<FlowPattern>-list-opt</vipbnf>

	~~Here {{lang2\|Predicates\|Predicate Domains\|predicateDomainName}} is the name of a predicate domain declared in a domains section.~~

	~~Only class predicates can have link names. If the link name is not stated then a link name is derived from the predicate name, the way this name is derived depends on the calling convention.~~

	If the calling convention is {{lang2\|Predicates\|Calling Convention\|apicall}} then the link name stated in the <vp>as</vp> clause is decorated anyway. If this decoration is unintended, use {{lang2\|Predicates\|Calling Convention\|stdcall}} instead.

	==== Predicate Mode ====		==== Predicate Mode ====
Line 178:		Line 176:
	The calling convention <vp>thiscall</vp> follows the C++ standard calling convention for virtual functions. This calling convention uses the <vp>c</vp> link name strategy but sometimes it may use the different argument and stack handling rules. Calling convention <vp>thiscall</vp> can be applied to the object predicates only.		The calling convention <vp>thiscall</vp> follows the C++ standard calling convention for virtual functions. This calling convention uses the <vp>c</vp> link name strategy but sometimes it may use the different argument and stack handling rules. Calling convention <vp>thiscall</vp> can be applied to the object predicates only.

	The calling convention <vp>stdcall</vp> uses the <vp>c</vp> link name strategy but it uses the different argument and stack handling rules. The following table shows the implementation of <vp>stdcall</vp> calling convention:		The calling convention <vp>stdcall</vp> uses the <vp>c</vp> link name strategy but it uses the different argument and stack handling rules. The following table shows the implementation of <vp>stdcall</vp> calling convention.



	{\|{{prettytable}}		{\|{{prettytable}}
Line 204:		Line 204:
	The calling convention <vp>apicall</vp> uses the same argument and stack handling rules as <vp>stdcall</vp>, but for convenience to call MS Windows API functions <vp>apicall</vp> uses the naming conventions that are used by most MS Windows API functions. According to <vp>apicall</vp> naming conventions the link name of a predicate is constructed as follows:		The calling convention <vp>apicall</vp> uses the same argument and stack handling rules as <vp>stdcall</vp>, but for convenience to call MS Windows API functions <vp>apicall</vp> uses the naming conventions that are used by most MS Windows API functions. According to <vp>apicall</vp> naming conventions the link name of a predicate is constructed as follows:

	*an leading underscore (<vp>_</vp>) is prefixed to the predicate name;		*a leading underscore (<vp>_</vp>) is prefixed to the predicate name;
	*the predicate name in which the first letter is changed in to a capital letter;		*the predicate name in which the first letter is changed in to a capital letter;
	*the '<vp>A</vp>', the '<vp>W</vp>' or nothing is suffixed, if the arguments and the return type indicate an ANSI, Unicode or neutral predicate, respectively;		*the '<vp>A</vp>', the '<vp>W</vp>' or nothing is suffixed, if the arguments and the return type indicate an ANSI, Unicode or neutral predicate, respectively;
	*the '<vp>@</vp>~~' is suffixed;~~		*on the 32bit platform (x86) the sign <vp>@</vp> together with the number of bytes in the argument list is suffixed. But this is not used on the 64bit platform.
	*the number of bytes ~~pushed on~~ the ~~call stack~~ is suffixed.

	{{Example\|		{{Example\|
Line 217:		Line 216:

	<source lang="text">_PredicateNameW@8</source>		<source lang="text">_PredicateNameW@8</source>

			On x64 the name is:
			<source lang="text">_PredicateNameW</source>
	}}		}}

Line 250:		Line 252:
	\|'''Called''' predicate pops its own arguments from the stack.		\|'''Called''' predicate pops its own arguments from the stack.
	\|The first letter of the predicate name is changed to the capital letter.		\|The first letter of the predicate name is changed to the capital letter.
	\|An underscore (<vp>_</vp>) is prefixed to the name. The first letter is changed to the upper case. The '<vp>A</vp>', the '<vp>W</vp>' or nothing is suffixed. ~~The~~ sign <vp>@</vp> ~~is suffixed. The (decimal)~~ number of bytes in the argument list is suffixed.		\|An underscore (<vp>_</vp>) is prefixed to the name. The first letter is changed to the upper case. The '<vp>A</vp>', the '<vp>W</vp>' or nothing is suffixed. And on the 32bit platform (x86) the sign <vp>@</vp> together with the number of bytes in the argument list is suffixed.
	\|}		\|}

Thomas Linder Puls: /* Predicate Domains */ domains info in domains section

2024-01-04T13:21:10Z

Predicate Domains: domains info in domains section

← Older revision		Revision as of 15:21, 4 January 2024
Line 56:		Line 56:

	Predicate domains can have <vpbnf><AnonymousIdentifier></vpbnf> as a {{lang2\|Predicates\|Type_Expressions\|predicateArgumentType}} to specify that the argument can be of any type.		Predicate domains can have <vpbnf><AnonymousIdentifier></vpbnf> as a {{lang2\|Predicates\|Type_Expressions\|predicateArgumentType}} to specify that the argument can be of any type.

	~~Predicate domains with ellipsis can only be used in predicate declarations.~~

	~~Predicate domains that are used in domain definitions can at most state one flow.~~

	<vipbnf><PredicateModeAndFlow>:		<vipbnf><PredicateModeAndFlow>:

Thomas Linder Puls: /* Predicate Declarations */ duplicate info

2024-01-04T13:19:48Z

Predicate Declarations: duplicate info

@@ Line 25: / Line 25: @@
 <vipbnf><PredicateName> :
     <LowerCaseIdentifier></vipbnf>
 === Predicate Domains ===

Thomas Linder Puls: /* See also */ in, out and byVal

2024-01-04T12:40:58Z

Thomas Linder Puls: /* Predicate Domains */ Info moved forward

2024-01-04T12:38:52Z

Predicate Domains: Info moved forward

← Older revision		Revision as of 14:38, 4 January 2024
Line 43:		Line 43:

	<vipbnf><PredicateDomain>:		<vipbnf><PredicateDomain>:
	<PredicateModeAndFlow>-list-opt <CallingConvention>-opt</vipbnf>		( <FormalArgument>-comma-sep-list-opt ) <ReturnArgument>-opt
			<PredicateModeAndFlow>-list-opt <CallingConvention>-opt</vipbnf>

	<vipbnf><FormalArgument>:		<vipbnf><FormalArgument>:

Thomas Linder Puls: Move info back

2024-01-04T12:34:30Z

Move info back

← Older revision		Revision as of 14:34, 4 January 2024
Line 39:		Line 39:

	=== Predicate Domains ===		=== Predicate Domains ===

			A predicate that returns a value is called a '''''function''''', whereas a predicate that does not return a value is sometimes called an '''''ordinary''''' predicate, to stress that it is not a function.

			<vipbnf><PredicateDomain>:
			<PredicateModeAndFlow>-list-opt <CallingConvention>-opt</vipbnf>

			<vipbnf><FormalArgument>:
			<TypeExpression> <VariableName>-opt
			<Ellipsis></vipbnf>

			<vipbnf><ReturnArgument>:
			-> <FormalArgument></vipbnf>

			<vipbnf><VariableName>:
			<UpperCaseIdentifier></vipbnf>

			Predicate domains can have <vpbnf><Ellipsis></vpbnf> argument as the last <vpbnf><FormalArgument></vpbnf> in the <vpbnf><FormalArgument>-comma-sep-list</vpbnf>.

			Predicate domains can have an <vpbnf><AnonymousIdentifier></vpbnf> as a formal argument type to specify that the argument can be of any type.

			<vipbnf><PredicateModeAndFlow>:
			<PredicateMode>-opt
			<FlowPattern>-list-opt</vipbnf>


	Predicate domains can have <vpbnf><Ellipsis></vpbnf> argument as the last <vpbnf><FormalArgument></vpbnf> in the <vpbnf><FormalArgument>-comma-sep-list</vpbnf>.		Predicate domains can have <vpbnf><Ellipsis></vpbnf> argument as the last <vpbnf><FormalArgument></vpbnf> in the <vpbnf><FormalArgument>-comma-sep-list</vpbnf>.

Thomas Linder Puls: Predicate domains moved here

2024-01-04T12:25:00Z

Predicate domains moved here

Show changes

Thomas Linder Puls: release

2019-03-12T16:16:43Z

release

← Older revision		Revision as of 18:16, 12 March 2019
Line 177:		Line 177:

	=== Extension Predicates ===		=== Extension Predicates ===

	~~{{Template:NonReleased}}~~

	Extension predicates is a syntactic sugaring, which makes it possible use class predicates as if they were object predicates.		Extension predicates is a syntactic sugaring, which makes it possible use class predicates as if they were object predicates.

← Older revision		Revision as of 14:40, 4 January 2024
Line 648:		Line 648:
	* {{lang2\|Attributes\|formatString\|formatString}} attribute		* {{lang2\|Attributes\|formatString\|formatString}} attribute
	* {{lang2\|Attributes\|programPoint\|programPoint}} attribute		* {{lang2\|Attributes\|programPoint\|programPoint}} attribute
			* {{lang2\|Attributes\|in\|in}}, {{lang2\|Attributes\|out\|out}} and {{lang2\|Attributes\|byVal\|byVal}} attributes