wiki.visual-prolog.com - User contributions [en]

Language Reference/Domains

2021-01-16T21:25:00Z

Joachim Tilsted Kristensen: /* Domain Definitions */

{{languageReferenceNavbar|Domains}}

=== Domains Sections ===

A domain section defines a set of domains in the current scope (see {{lang|Interfaces|Interface}}, {{lang|Classes|Class Declaration}}, and {{lang|Implementations|Class Implementation}}).

<vipbnf><DomainsSection>:
domains <DomainDefinition>-dot-term-list-opt</vipbnf>

=== Domain Definitions ===

A domain definition defines a named domain in the current scope.

<vipbnf><DomainDefinition>:
<DomainName> <FormalTypeParameterList>-opt = <DomainExpression></vipbnf>

If the domain on the right hand side denotes an interface or a compound domain, then the defined domain is synonym (i.e. identical) to the type expression. Otherwise the defined domain becomes a subdomain of the domain denoted by the domain expression. Here a domain name <vpbnf><DomainName></vpbnf> should be a {{lang2|Lexical_Elements|Identifiers|lower case identifier}}.

There are certain places where you must use a domain name rather than a type expression:

*as a declaration of a formal argument type;
*as a type of a constant or a fact variable;
*as a type in a list domain.

=== Domain Expressions ===

A domain expression denotes a type in a domain definition:

<vipbnf><DomainExpression>: one of
<TypeName>
<CompoundDomain>
<ListDomain>
<PredicateDomain>
<IntegralDomain>
<RealDomain>
<TypeVariable>
<ScopeTypeVariable>
<TypeApplication></vipbnf>

==== Type Expressions ====

The full range of <vpbnf><DomainExpression></vpbnf>s can only be used in a domain definition. <vpbnf><TypeExpression></vpbnf> is a subset of these expressions that are used in other many other contexts.

<vipbnf><TypeExpression>: one of
<TypeName>
<ListDomain>
<TypeVariable>
<ScopeTypeVariable>
<TypeApplication></vipbnf>

==== Type Names ====

A type name is either an ''interface'' name or the name of a ''value domain''. We use the term ''value domain'' to specify domains whose elements are {{lang2|Basic_Concepts|Types|immutable}} (unchangeable). Here we can say that objects, belonging to domains correspondent to ''interface'' names, have mutable state and terms of any other domains are immutable. So actually value types are everything except object types. A type name (obviously) denotes the type corresponding to the name of an existing domain.

<vipbnf><TypeName>: one of
<InterfaceName>
<DomainName>
<ClassQualifiedDomainName></vipbnf>

<vipbnf><InterfaceName>:
<LowercaseIdentifier></vipbnf>

<vipbnf><DomainName>:
<LowercaseIdentifier></vipbnf>

<vipbnf><ClassQualifiedDomainName>:
<ClassName>::<DomainName></vipbnf>

<vipbnf><ClassName>:
<LowercaseIdentifier></vipbnf>

Here <vpbnf><InterfaceName></vpbnf> is an interface name, <vpbnf><DomainName></vpbnf> is a value domain name, and <vpbnf><ClassName></vpbnf> is a class name.

{{Example|
<vip>domains
newDomain1 = existingDomain.
newDomain2 = myInterface.</vip>

In this example the domain name <vp>existingDomain</vp> and the interface name <vp>myInterface</vp> are used to define new domains.
}}

==== Compound Domains ====

Compound domains (also known as algebraic data types) are used to represent lists, trees, and other tree structured values. In its simple forms compound domains are used to represent structures and enumeration values. Compound domains can have a recursive definition. They can also be mutually/indirectly recursive.

<vipbnf><CompoundDomain>:
<Alignment>-opt <FunctorAlternative>-semicolon-sep-list</vipbnf>

<vipbnf><Alignment>:
align <IntegralConstantExpression></vipbnf>

Here <vpbnf><IntegralConstantExpression></vpbnf> is an expression, which must be compile time evaluated to an integral value.

A compound domain declaration declares a list of functor alternatives with optional alignment. Alignment must be <vp>1</vp>, <vp>2</vp> or <vp>4</vp>.

If a compound domain consists of one functor alternative, then it is considered as structure and has representation, which is binary compatible with the appropriate structure in language C.

<vipbnf><FunctorAlternative>:
<FunctorName> <FunctorName> ( <FormalArgument>-comma-sep-list-opt )</vipbnf>

Here <vpbnf><FunctorName></vpbnf> is the name of a functor alternative it should be a {{lang2|Lexical_Elements|Identifiers|lower case identifier}}.

<vipbnf><FormalArgument>:
<TypeExpression> <ArgumentName>-opt</vipbnf>

Here <vpbnf><ArgumentName></vpbnf> can be any {{lang2|Lexical_Elements|Identifiers|upper case identifier}}. The compiler ignores it.

Compound domains have no subtype relations to any other domains.

If a domain is defined as being equal to a compound domain, then these two domains are synonym types rather than subtypes. Meaning that they are just two different names for the same type.

{{Example|
<vip>domains
t1 = empty(); cons(integer V, t1 Tail).</vip>

<vp>t1</vp> is a compound domain with two alternatives. The first alternative is the null-ary functor <vp>empty()</vp>, while the second alternative is the two-ary functor <vp>cons</vp>, which takes an {{lang2|Built-in_entities|integer|integer}} and a term of the domain <vp>t1</vp> itself as arguments. So the domain <vp>t1</vp> is recursively defined.

The following expressions are terms of the domain <vp>t1</vp>:

<vip>empty
cons(77, empty())
cons(33, cons(44, cons(55, empty())))</vip>
}}

In the example above we used parenthesis after the null-ary function <vp>empty</vp>. Such parenthesis are optional in all situations, ''except'' in a domain definition consisting only of a single null-ary functor. In that case parenthesis are required to distinguish it from a synonym/subtype definition.

{{Example|
<vp>t1</vp> is a compound domain with a single null-ary functor, whereas <vp>t2</vp> is defined to be synonym to <vp>t1</vp>.

<vip>domains
t1 = f().
t2 = t1.</vip>
}}

{{Example|
<vip>domains
t1 = nil; subt2(t2).
t2 = hh(t1, t1).</vip>

<vp>t1</vp> is a compound domain with two alternatives. The first alternative is the null-ary functor <vp>nil</vp>, while the second alternative is the unary functor <vp>subt2</vp>, which takes a term of the domain <vp>t2</vp> as argument. <vp>t2</vp> is a compound domain with one alternative the functor <vp>hh</vp>, which takes two <vp>t1</vp> terms as argument. So the domains <vp>t1</vp> and <vp>t2</vp> are mutually recursive.

The following are terms in the domain <vp>t1</vp>:

<vip>nil
subt2(hh(nil, nil))
subt2(hh(subt2(hh(nil, nil)), nil))
consg(hh(nil, g(hh(nil, nil))))
subt2(hh(subt2(hh(nil, nil)), subt2(hh(nil, nil))))</vip>
}}

==== List Domains ====

List domains represent sequences of values of a certain domain. Thus, all elements in a <vp>T</vp> list must be of type <vp>T</vp>.

<vipbnf><ListDomain>:
<TypeExpression> *</vipbnf>

<vp>T*</vp> is the type of lists of <vp>T</vp> elements.

The following syntax is used for lists:

<vipbnf><ListExpression>:
[ <Term>-comma-sep-list-opt ]
[ <Term>-comma-sep-list | <Tail> ]</vipbnf>

<vipbnf><Tail>:
<Term></vipbnf>

Here <vpbnf><Tail></vpbnf> is a term which should have a value of the <vpbnf><ListDomain></vpbnf> type. Each <vpbnf><Term></vpbnf> should be of {{lang2|Domains|Type_Names|typeName}} type.

Actually, lists are just compound domains with two functors: <vp>[]</vp> denoting the empty list and the mix-fix functor <vp>[HD|TL]</vp> denoting the list with head <vp>HD</vp> and tail <vp>TL</vp>. The head must be of the underlying element type, whereas the tail must be a list of relevant type.

Lists are however syntactically sugared.

<vp>[E1, E2, ..., En | L ]</vp> is shorthand for <vp>[E1 | [ E2 | [ ...[ En | L ]...] ] ]</vp>

<vp>[E1, E2, ..., En]</vp> is shorthand for <vp>[E1, E2, ..., En | [] ]</vp>, which in turn is shorthand for <vp>[E1 | [ E2 | [ ...[ En | [] ]...] ] ]</vp>.

==== Predicate Domains ====

Values of a predicate domain are predicates with the same "signature", i.e. the same argument and return types, the same flow pattern and the same (or stronger) predicate mode.

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>:
( <FormalArgument>-comma-sep-list-opt ) <ReturnArgument>-opt
<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 <vpbnf><AnonymousIdentifier></vpbnf> as a {{lang2|Domains|Type_Expressions|predicateArgumentType}} to specify that the argument can be of any type.

Currently, 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>:
<PredicateMode>-opt
<FlowPattern>-list-opt</vipbnf>

===== Predicate Mode =====

The specified predicate mode applies for each member of a flow pattern list following it.

<vipbnf><PredicateMode>: one of
erroneous
failure
procedure
determ
multi
nondeterm</vipbnf>

Predicate modes can be described by the following sets:

<vip>erroneous = {}
failure = {Fail}
procedure = {Succeed}
determ = {Fail, Succeed}
multi = {Succeed, BacktrackPoint}
nondeterm = {Fail, Succeed, BacktrackPoint}</vip>

If ''Fail'' is in the set it means that the predicate can fail. If ''succeed'' is in the set it means that the predicate can succeed. If ''BacktrackPoint'' is in the set it means that the predicate can return with an active backtrack point in it.

If such a set, say <vp>failure</vp>, is a subset of another set, say <vp>nondeterm</vp>, then we say that the mode is stronger than the other, i.e. <vp>failure</vp> is stronger than <vp>nondeterm</vp>.

A predicate domain actually contain all predicates (with correct type and flow), which have the mode specified or a '''''stronger''''' mode.

It is illegal to state a predicate mode for constructors, they always have the <vp>procedure</vp> mode.

Omitting of a predicate mode means <vp>procedure</vp>.

===== Flow Pattern =====

The flow pattern defines the input/output direction of the arguments, which in combination with functor domains can be structures with parts of a single argument being input and other parts of the same argument being output.

A flow pattern consists of a sequence of flows, each flow corresponds to an argument (fist flow to first argument, etc).

<vipbnf><FlowPattern>:
( <Flow>-comma-sep-list-opt ) AnyFlow</vipbnf>

<vipbnf><Flow>: one of
i
o
<FunctorFlow>
<ListFlow>
<Ellipsis></vipbnf>

Ellipsis flow must match an ellipsis argument and can therefore be only the last flow in the flow pattern.

<vipbnf><Ellipsis>:
...</vipbnf>

A functor flow <vpbnf><FunctorFlow></vpbnf> states a functor and flows of each of the components of that flow. The functor must of course be in the domain of the corresponding argument.

<vipbnf><FunctorFlow>:
<FunctorName> ( <Flow>-comma-sep-list-opt )</vipbnf>

A functor flow declaration cannot contain ellipsis flow.

List flows are just like functor flows, but with the same syntactic sugaring as the list domain.

<vipbnf><ListFlow>:
[ <Flow>-comma-sep-list-opt <ListFlowTail>-opt]</vipbnf>

<vipbnf><ListFlowTail>:
| <Flow></vipbnf>

A list flow cannot contain ellipsis flow.

When declaring a predicate the flow can be omitted. Inside an implementation (i.e. for a local predicate) the needed flows are derived from the usages of the predicate. Inside an interface or a class declaration (i.e. for a public predicate) omitting flows means that all arguments are input.

The special flow pattern <vp>anyflow</vp> can be stated only in declarations of local predicates (i.e. in predicate declarations inside the implementation of a class). It means that the exact flow pattern(s) will be evaluated during the compilation.

{{Example|
<vip>domains
pp1 = (integer Argument1).</vip>

<vp>pp1</vp> is a predicate domain. The predicates that have type <vp>pp1</vp> takes one {{lang2|Built-in_entities|integer|integer}} argument. Since no flow-pattern is stated the argument is input, and since no predicate mode is mentioned the predicates are <vp>procedure</vp>.
}}

{{Example|
<vip>domains
pp2 = (integer Argument1) -> integer ReturnType.</vip>

Predicates of type <vp>pp2</vp> take one {{lang2|Built-in_entities|integer|integer}} argument and returns a value of type {{lang2|Built-in_entities|integer|integer}}. Therefore, <vp>pp2</vp> is actually a function domain and the predicates that have type <vp>pp2</vp> are actually functions. Since no flow-pattern is stated the argument is input and since no predicate mode is mentioned the predicates are <vp>procedure</vp>.
}}

{{Example|
<vip>predicates
ppp : (integer Argument1, integer Argument2) determ (o,i) (i,o) nondeterm (o,o).</vip>

The predicate <vp>ppp</vp> takes two {{lang2|Built-in_entities|integer|integer}} arguments. It exists in three flow variants: <vp>(o,i)</vp> and <vp>(i,o)</vp>, which are <vp>determ</vp>, and <vp>(o,o)</vp>, which is <vp>nondeterm</vp>.
}}

===== Calling Convention =====

The calling convention determines how arguments, etc. are passed to the predicate, it also determines how the link name is derived from a predicate name.

<vipbnf><CallingConvention>:
language <CallingConventionKind></vipbnf>

<vipbnf><CallingConventionKind>: one of
c thiscall stdcall apicall prolog</vipbnf>

If a calling convention is not stated, then the <vp>prolog</vp> convention is assumed. The <vp>prolog</vp> calling convention is the standard convention used for Prolog predicates.

The calling convention <vp>c</vp> follows the C/C++ standard calling convention. The link name of a predicate is created from the predicate name by adding a leading underscore (<vp>_</vp>).

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:

{|{{prettytable}}
|-
!Feature
!Implementation
|-
|Argument-passing order
|Right to left.
|-
|Argument-passing convention
|By value, unless a compound domain term is passed. So it cannot be used to predicates with variable number of arguments.
|-
|Stack-maintenance responsibility
|Called predicate pops its own arguments from the stack.
|-
|Name-decoration convention
|An underscore (<vp>_</vp>) is prefixed to the predicate name.
|-
|Case-translation convention
|No case translation of the predicate name is performed.
|}

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;
*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>@</vp>' is suffixed;
*the number of bytes pushed on the call stack is suffixed.

{{Example|
<vip>predicates
predicateName : (integer, string) language apicall</vip>

The argument types of this predicate indicates that it is a Unicode predicate (as {{lang2|Built-in_entities|string|string}} is the domain of Unicode strings). An {{lang2|Built-in_entities|integer|integer}} and a {{lang2|Built-in_entities|string|string}} each occupies 4 bytes on the call stack and, therefore, the link name becomes:

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

If <vp>apicall</vp> is used together with the "<vp>as</vp>" construction the name stated in the "<vp>as</vp>" construction is decorated in the same manner.

<vp>apicall</vp> can only be used directly in a predicate declaration, not in a predicate domain definition. In predicate domain definitions <vp>stdcall</vp>, must be used instead. A predicate declared with <vp>apicall</vp> calling convention cannot have clauses and it also cannot be resolved externally without explicit DLL name.

The following table compares implementations of <vp>c</vp>, <vp>apicall</vp>, and <vp>stdcall</vp> calling conventions (the <vp>prolog</vp> calling convention has the special implementation, which is not discussed here):

{|{{prettytable}}
|-
!Keyword
!Stack cleanup
!Predicate name case-translation
!Link predicate name decoration convention
|-
|<vp>c</vp>
|'''Calling''' predicate pops the arguments from the stack.
|None.
|An underscore (<vp>_</vp>) is prefixed to the predicate name.
|-
|<vp>thiscall</vp>
|'''Calling''' predicate pops the arguments from the stack except the implicit '''This''' argument which is passed in the register.
|None.
|<vp>c</vp> link name strategy is used.
|-
|<vp>stdcall</vp>
|'''Called''' predicate pops its own arguments from the stack.
|None.
|An underscore (<vp>_</vp>) is prefixed to the predicate name.
|-
|<vp>apicall</vp>
|'''Called''' predicate pops its own arguments from the stack.
|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.
|}

Visual Prolog notion of predicate domains covers both class and object members. Class members are handled straight forward, but the handling of object members requires attention. The invocation of an object predicate will get "back" in the context of the object to which the member belongs.

{{Example| Assume the following declarations:

<vip>interface actionEventSource
domains
actionListener = (actionEventSource Source) procedure (i).
predicates
addActionListener : (actionListener Listener) procedure (i).
... end interface</vip>

Also assume a class <vp>button_class</vp> which supports the <vp>actionEventSource</vp>. The event is sent when the button is pressed. In <vp>myDialog_class</vp> class, which implements a dialog, I create a button and I want to listen to its action events, so that I can react on button presses:

<vip>implement myDialog_class
clauses
new() :-
OkButton = button_class::new(...),
OkButton:addActionListener(onOk),
...
facts
okPressed : () determ.
predicates
onOk : actionListener.
clauses
onOk(Source) :-
assert(okPressed()).
end implement</vip>

The important thing about the example is that <vp>onOk</vp> is an object member and that, when the button is pressed, the invocation of the registered <vp>onOk</vp> will bring us back in the object that owns <vp>onOk</vp>. This means that we have access to the object fact <vp>okPressed</vp>, so that we can assert it.
}}

===== Format Strings =====

A formal parameter to a predicate can be marked as format string using the attribute {{lang2|Attributes|formatString|formatString}}. The format string can contain ordinary characters which are printed without modification, and format fields, that % begins with the percent '%' sign. If the percent sign is followed % by some unknown character (not the format specifier) - then % this character will be printed without modifications.

<vip>predicates
writef : (string Format [formatstring], ...).</vip>

The format fields specification is:

[-][0][width][.precision][type]

All fields are optional.

[-] Hyphen indicates that the field is to be left justified; right justified is the default. Having no effect when width value is not set, or the number of characters in the actual value is greater than width value.

[0] Zero before width means for values that zeros will be added until the minimum width is reached. If 0(zero) and -(hyphen) appear, the 0 is ignored

[width] Positive decimal number specifying a minimum field size. If the number of characters in the actual value is less than width value - then the required number of space ' ' characters will be added before the value (or after it, if '-' field was set). No changes occurs if number of characters in the actual value is greater than the width value.

[.precision] The point '.' with the following unsigned decimal number can specify either the precision of a floating-point image or the maximum number of characters to be printed from a string.

[type] Specifies other format then the default for the given. For example, in the type field, you can give a specifier that says an integer will be formatted as an unsigned. The possible values are:

:{|{{prettytable}}
|-
| f || Format real's in fixed-decimal notation (such as 123.4 or 0.004321). This is the default for real's.
|-
| e || Format real's in exponential notation (such as 1.234e+002 or 4.321e-003).
|-
| g || Format real's in the shortest of f and e format, but always in e format if exponent of the value is less than -4 or greater than or equal to the precision. Trailing zeros are truncated.
|-
| d or D || Format as a signed decimal number.
|-
| u or U || Format as an unsigned integer.
|-
| x or X || Format as a hexadecimal number.
|-
| o or O || Format as an octal number.
|-
| c || Format as a char.
|-
| B || Format as the Visual Prolog binary type.
|-
| R || Format as a database reference number.
|-
| p || Format as the presented value.
|-
| P || Format as a procedure parameter.
|-
| s || Format as a string.
|}

==== Integral Domains ====

Integral domains are used for representing integral numbers. They are divided in two main categories for signed and unsigned numbers. Integral domains can also have different representation size. The predefined domains {{lang2|Built-in_entities|integer|integer}} and {{lang2|Built-in_entities|unsigned|unsigned}} represent signed and unsigned numbers with natural representation length for the processor architecture (i.e. 32bit on a 32bit machine, etc).

<vipbnf><IntegralDomain>:
<DomainName>-opt <IntegralDomainProperties></vipbnf>

If a <vpbnf><DomainName></vpbnf> is stated in front of the <vpbnf><IntegralDomainProperties></vpbnf>, then this domain must itself be an integral domain and the resulting domain will be child-type (i.e. subtype) of this domain. In that case <vpbnf><IntegralDomainProperties></vpbnf> may not violate the possibility of being a subtype, i.e. the range cannot be extended and the size cannot be changed.

<vipbnf><IntegralDomainProperties>:
<IntegralSizeDescription> <IntegralRangeDescription>-opt
<IntegralRangeDescription> <IntegralSizeDescription>-opt

<IntegralSizeDescription>:
bitsize <DomainSize>

<DomainSize>:
<IntegralConstantExpression></vipbnf>

An integral size description declares the size <vpbnf><DomainSize></vpbnf> of the integral domain, measured in bits. The compiler implement such representation to the integral domain, which has no less than the specified number of bits. The value of <vpbnf><DomainSize></vpbnf> should be positive and no greater than the maximal value supported by the compiler.

If integral size description is omitted, then it will become the same as the parent domain. If there is no parent domain, it will become the natural size for the processor.

<vipbnf><IntegralRangeDescription>:
[ <MinimalBoundary>-opt .. <MaximalBoundary>-opt ]

<MinimalBoundary>:
<IntegralConstantExpression>

<MaximalBoundary>:
<IntegralConstantExpression></vipbnf>

An integral range description declares the minimal <vpbnf><MinimalBoundary></vpbnf> and the maximal <vpbnf><MaximalBoundary></vpbnf> limits for the integral domain. If a limit is omitted, then the range of the parent domain is used. If there is no parent domain, then the <vpbnf><DomainSize></vpbnf> is used to determine respectively maximum or minimum value.

Notice that the specified minimum value should not exceed the specified maximum value. That is:

<vipbnf><MinimalBoundary> <= <MaximalBoundary></vipbnf>

Also the minimal <vpbnf><MinimalBoundary></vpbnf> and the maximal <vpbnf><MaximalBoundary></vpbnf> limits should satisfy the limits implied by the specified bit size <vp>bitsize</vp>.

The domain bit size <vpbnf><DomainSize></vpbnf> value and values of the minimal <vpbnf><MinimalBoundary></vpbnf> and the maximal <vpbnf><MaximalBoundary></vpbnf> limits must be calculated while compiling time.

==== Real Domains ====

Real domains are used to represent numbers with fractional parts (i.e. floating point numbers). Real domains can be used to represent very large and very small numbers. The built-in domain ''real'' have the natural precision for the processor architecture (or the precision given by the compiler).

<vipbnf><RealDomain>:
<DomainName>-opt <RealDomainProperties></vipbnf>

If a <vpbnf><DomainName></vpbnf> is stated in front of the <vpbnf><RealDomainProperties></vpbnf>, then this domain must itself be a real domain and the resulting domain will be a subtype of this domain. In that case <vpbnf><RealDomainProperties></vpbnf> may not violate the possibility of being a subtype, i.e. the range cannot be extended and the precision cannot be increased.

<vipbnf><RealDomainProperties>: one of
<RealPrecisionDescription> <RealRangeDescription>-opt
<RealRangeDescription> <RealPrecisionDescription></vipbnf>

<vipbnf><RealPrecisionDescription>:
digits <IntegralConstantExpression></vipbnf>

The real precision description declares precision of the real domain, measured in number of decimal digits. If precision is omitted then it will become the same as for the parent domain. If there is no parent domain, then it will be the natural precision for the processor or given by the compiler (in Visual Prolog v.6 the compiler limit is 15 digits). Precision have an upper and a lower limits given by the compiler, if the precisions larger than that limit is used the numbers will only obtain the processor (compiler) specified precision anyway.

<vipbnf><RealRangeDescription>:
[ <MinimalRealBoundary>-opt .. <MaximalRealBoundary>-opt ]

<MinimalRealBoundary>:
<RealConstantExpression>

<MaximalRealBoundary>:
<RealConstantExpression></vipbnf>

Here <vpbnf><RealConstantExpression></vpbnf> is an expression, which must be compile time evaluated to a floating point value. That is the real domain precision and limits must be calculated while compiling time.

The real range description declares minimal and maximal limits for the real domain. If a limit is omitted then it will be the same as for the parent domain. If there is no parent domain then the largest possible range for the precision will be used.

Notice that the specified minimum value should not exceed the specified maximum value. That is:

<vipbnf><MinimalBoundary> <= <MaximalBoundary></vipbnf>

==== Generic Domains ====

This section contains the formal syntax for generic domains, for a more complete introduction to generics please see the tutorial {{lang|Objects and Polymorphism|Objects and Polymorphism}} and the section {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

<vipbnf><FormalTypeParameterList>:
<TypeVariable>-comma-sep-list-opt</vipbnf>

A formalTypeParameterList is a list of typeVariables

<vipbnf><TypeVariable>:
<UpperCaseIdentifier></vipbnf>

A <vpbnf><TypeVariable></vpbnf> is an upper case identifier. In a domain declaration the type variable must be bound in the <vpbnf><FormalTypeParameterList></vpbnf> on the left hand side of the domain definition. In a predicate declaration all free type variables are implicitly bound and scoped to that predicate declaration.

<vipbnf><TypeApplication>:
<TypeName> {<TypeExpression>-comma-sep-list-opt }</vipbnf>

A <vpbnf><TypeApplication></vpbnf> is the application of a {{lang2|Domains|Type_Names|typeName}} to a list of types. The type name must be generic and the number of formal type parameters must match the number of type expressions.

=== Universal and Root Types ===

Visual Prolog uses some internal types, called ''root'' types and ''universal'' types.

==== Universal Types ====

A number literal like <vp>1</vp> does not have any particular type, it can be used as a value of any type that contains <vp>1</vp>, including real types.

We say that <vp>1</vp> have a universal type. Having a universal type means that it have any type, which can represent its value.

Arithmetic operations also return universal types.

==== Root Types ====

Arithmetic operations are very liberal with their operand requirements: You can add integers of any integer domain with each other.

We say that arithmetic operands takes root types as arguments. The integer root type is super-type of any integer type (regardless that it is not mentioned in their declarations). Hence any integer type can be converted to the integer root type, and, since the arithmetic operations exist for the root types, it means one of them will work on any integer domains.

The actual number of root types and which operands exist is a matter of library facilities, and outside the scope of this document to describe.

Language Reference/Built-in entities/Domains

2020-12-19T16:23:49Z

Joachim Tilsted Kristensen: /* compareResult */

{|{{prettytable}}
|-
|[[#any|any]]
|Universal term type.
|-
|[[#char|char]]
|Wide (two-bytes) character.
|-
|[[#string|string]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#string8|string8]]
|Zero-terminated sequence of ASCII (one-byte) characters.
|-
|[[#symbol|symbol]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#binary|binary]]
|Sequence of bytes.
|-
|[[#binaryNonAtomic|binaryNonAtomic]]
|Sequence of bytes.
|-
|[[#integer|integer]]
|32 bit signed integer.
|-
|[[#integer64|integer64]]
|64 bit signed integer.
|-
|[[#integerNative|integerNative]]
|Signed integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#unsigned|unsigned]]
|32 bit unsigned integer.
|-
|[[#unsigned64|unsigned64]]
|64 bit unsigned integer.
|-
|[[#unsignedNative|unsignedNative]]
|Unsigned integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#real|real]]
|Float-pointing number.
|-
|[[#real32|real32]]
|Float-pointing number.
|-
|[[#pointer|pointer]]
|pointer to a memory address.
|-
|[[#handle|handle]]
|a handle (e.g. native file and windows handles).
|-
|[[#boolean|boolean]]
|Boolean values.
|-
|[[#factDB|factDB]]
|Descriptors of named internal databases.
|-
|[[#compareResult|compareResult]]
|Values of comparison result.
|}

==== any ====

Universal term type.

<vip>any</vip>

The values of this domain are any terms. Such a value contains the reference to the term type library and a term itself.

==== char ====

Wide character.

<vip>char</vip>

The values of this domain are UNICODE characters. Implemented as 2 unsigned bytes.

Only assignment and comparison (in the lexicographical sense) operations are applied to the values of this domain. The image of a character has the following syntax:

<vipbnf><Char_image> :
' Char_value '
<Char_value> :
<Letter>
<Digit>
<Graphical_symbol>
\ <Escape_seq>
<Escape_seq>:
t
n
r
\
'
"
u <HHHH></vipbnf>

In the syntax above <vpbnf><HHHH></vpbnf> correspond to 4 hexadecimal digits. Also, the backslash symbol and the single quote can be represented by an escape-sequence only.

==== compareResult ====

The result of a comparison. For instance, the built-in procedure {{lang2|Built-in entities|compare|compare/2->}} has "compareResult" as the domain of its result.
<vip>domains
compareResult = less; equal; greater.
</vip>

==== string ====

Wide zero terminated sequence of wide characters.

<vip>string</vip>

A string is a sequence of UNICODE characters. It's implemented as a pointer to the wide zero-terminated array of wide characters. Only assignment and comparison (in the lexicographical sense) operations are applied to values of this domain.

In source code a string literal can be specified as a set of sequences of characters surrounded by the double quotes.

<vipbnf><StringLiteral>:
<StringLiteralPart>-list</vipbnf>

<vipbnf><StringLiteralPart> :
@" AnyCharacter-list-opt "
" CharacterValue-list-opt "</vipbnf>

A string literal consists of one or more <vpbnf><StringLiteralPart></vpbnf>'s, which are concatenated. <vpbnf><StringLiteralPart></vpbnf>'s starting with <vp>@</vp> does not use escape sequences, whereas <vpbnf><StringLiteralPart></vpbnf>'s without <vp>@</vp> uses the following escape sequences:

*<vp>\\</vp> representing <vp>\</vp>
*<vp>\t</vp> representing Tab-character
*<vp>\n</vp> representing newline-character
*<vp>\r</vp> representing carriage return
*<vp>\'</vp> representing single quote
*<vp>\"</vp> representing double quote
*<vp>\u</vp> followed by exactly four <vpbnf><HexadecimalDigit></vpbnf>'s representing the Unicode character corresponding to the digits.

The double quotes in the string can be represented by the escape-sequence only (the single quote can be represented both with an escape-sequence and a graphical symbol).

==== string8 ====

A built-in domain who's elements are sequences of (one-byte) ASCII-characters. It is implemented as a pointer to the zero terminated array of ASCII characters. Only assignment and comparison for equality (in the lexicographical sense) operations are applied to the values of this domain. Currently no literals are allowed for this domain.

==== symbol ====

Wide zero terminated sequence of wide characters.

<vip>symbol</vip>

Similar to a string, a symbol is also a sequence of the UNICODE characters. It's implemented as a pointer to an entry in a symbol table that contains strings. The operations that can be applied to symbols are the same as for strings.

The image of a symbol is represented with a ''<string_literal>'' (any string surrounded by the double quotes).

Symbols and strings are largely interchangeable but they are stored differently. Symbols are kept in a look-up table and their addresses, rather than the symbols themselves, are stored to represent objects. This means that symbols can be matched very quickly and, if a symbol occurs repeatedly in a program, it can be stored very compactly. Strings are not kept in a look-up table. Visual Prolog examines strings character-by-character whenever they are to be matched.

==== binary ====

Sequence of bytes.

<vip>binary</vip>

Values of this domain are used for holding binary data. A binary value is implemented as a pointer to the sequence of bytes that represents the contents of a binary term.

The length of a binary term is situated in the '''4 bytes''' immediately preceding this sequence of bytes. The 4 bytes contains:

<vip>TotalNumberOfBytesOccupiedByBinary = ByteLen + 4 </vip>

where <vp>ByteLen</vp> - is the length of the binary term and 4 is number of bytes occupied by size field.

Only assignment and comparison operations are applied to values of '''binary domain'''.

Two binary terms are compared in the following way:

*If they are of different sizes, the bigger is considered larger.
*Otherwise, they are compared byte by byte, as unsigned values. Comparison stops when two differing bytes are found and the result of their comparison is the result of the comparison of the binary terms. Two binary terms are equal if they have the same sizes and all bytes are equal.

The text syntax for binary images is determined by the <vpbnf><Binary></vpbnf> rules:

<vipbnf><Binary> :
$ [ <Byte_value>-comma-sep-list-opt ]
<Byte_value> :
<Expression></vipbnf>

Each ''expression'' should be calculate on compiling time and its value should be in the range from <vp>0</vp> to <vp>255</vp>.

==== binaryNonAtomic ====

Sequence of bytes.

<vip>binaryNonAtomic</vip>

Same as [[#binary|binary]], but can contain pointers because it is scanned by the garbage collector.

==== integer ====

32 bit signed integer.

<vip>integer</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|quot/2->}}, and {{lang2|Built-in entities|Operators|rem/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>-2147483648</vp> to <vp>2147483647</vp>.

The syntax for the <vp>integer</vp> literal is determined by the <vpbnf><Integer></vpbnf> rule:

<vipbnf><Integer> :
<Add_operation>-opt 0o <Oct_number>
<Add_operation>-opt <Dec_number>
<Add_operation>-opt 0x <Hex_number>
<Add_operation> :
+
-
<Oct_number> :
<Oct_digit>-list
<Oct_digit> : one of
0 1 2 3 4 5 6 7
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
<Oct_digit> 8 9
<Hex_number> :
<Hex_digit>-list
<Hex_digit> : one of
<Dec_digit> a b c d e f A B C D E F</vipbnf>

==== integer64 ====

64 bit signed integers.

<vip>integer64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>-2^63 = -9223372036854775808</vp> to <vp>2^63-1 = 9223372036854775807</vp>.

The syntax for <vp>integer64</vp> literal is the same as <vpbnf><Integer></vpbnf> rule.

The set of operations for <vp>integer64</vp> is similar to the one for <vpbnf><Integer></vpbnf>.

==== integerNative ====

Signed integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>integerNative</vip>

==== unsigned ====

32 bit unsigned integer.

<vip>unsigned</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|rem/2->}}, and {{lang2|Built-in entities|Operators|quot/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>0</vp> to <vp>4294967295</vp>.

The syntax for <vp>unsigned</vp> number images is the same as for <vp>integer</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned</vp> number.

==== unsigned64 ====

64 bit unsigned integer.

<vip>unsigned64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>0</vp> to <vp>2^64-1 = 18,446,744,073,709,551,615</vp>.

The syntax for <vp>unsigned64</vp> number images is the same as for <vp>integer64</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned64</vp> number.

The set of operations for <vp>unsigned64</vp> is similar to the one for <vpbnf><Unsigned></vpbnf>.

==== unsignedNative ====

Unsigned integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>unsignedNative</vip>

==== real ====

Float-pointing number.

<vip>real</vip>

Values of this domain occupy 8 bytes. This numerical real domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations are applied to values of <vp>real</vp> domain.

The permitted number range is <vp>-1.7e+308</vp> to <vp>1.7e+308</vp>. Values from integral domains are automatically converted to real numbers when necessary.

The syntax for the floating-point number literal is determined by the <vpbnf><Real></vpbnf> rule:

<vipbnf><Real> :
<Add_operation>-opt <Fraction> <Exponent>-opt
<Fraction> :
<Dec_number> <Fractional_part>-opt
<Fractional_part> :
. <Dec_number>
<Exponent> :
<Exp> <Add_operation>-opt <Dec_number>
<Exp> :
e
E
<Add_operation> :
+
-
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
0 1 2 3 4 5 6 7 8 9</vipbnf>

==== real32 ====

Float-pointing number.

<vip>real32</vip>

Values of this domain occupy 4 bytes. This numerical <vp>real32</vp> domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations can be applied to values of <vp>real32</vp> domain.

The permitted number range is <vp>-3.4e+38</vp> to <vp>3.4e+38</vp>.

The syntax of real32 literals is the same as <vp>real</vp> lietrals.

==== pointer ====

A pointer to a memory address.

<vip>pointer</vip>

A pointer directly corresponds to memory addresses. Only the equality operation can be applied to the values of this domain. There is a built-in '''null''' constant for this type

==== handle ====

A handle is used for Windows API function call. Values of this domain has the same size as a pointer (i.e. 4 on 32bit platfor and 8 on 64bit platform).

There are no operations for this domain and cannot be converted (except uncheckedConvert) to/from other domains.

There is a built-in [[#nullHandle|nullHandle]] and [[#invalidHandle|invalidHandle]] constant for this type

==== boolean ====

Boolean values.

<vip>boolean</vip>

This domain is introduced for the user convenience only. It is treated as usual compound domain with the following definition:

<vip>domains
boolean = false(); true().</vip>

==== factDB ====

Descriptors of named internal databases.

<vip>factDB</vip>

This domain has the following hidden meta-declaration:

<vip>domains
factDB = struct @factdb( named_internal_database_domain, object ).</vip>

All user-defined names of facts sections are the constants of this domain. The compiler automatically builds the corresponding compound terms from such constants whenever it's in need. At the runtime the 1st field of this structure contains the address of the corresponding domain descriptor and the 2nd field contains either zero (for class facts sections) or pointer to an object (i.e. <vp>This</vp>, for object facts sections).
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Domains}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T16:21:22Z

Joachim Tilsted Kristensen: /* invalidHandle */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A constant of type <vp>pointer</vp> with the value <vp>0</vp>.

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A constant of type <vp>handle</vp> with the value <vp>0</vp>.

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A constant of type <vp>handle</vp> with the invalid (for a handle) value <vp>-1</vp>.

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T16:20:53Z

Joachim Tilsted Kristensen: /* nullHandle */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A constant of type <vp>pointer</vp> with the value <vp>0</vp>.

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A constant of type <vp>handle</vp> with the value <vp>0</vp>.

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A constant of type "handle" with the invalid (for a handle) value "-1".

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T16:20:19Z

Joachim Tilsted Kristensen: /* null */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A constant of type <vp>pointer</vp> with the value <vp>0</vp>.

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A constant of type "handle" with the value "0".

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A constant of type "handle" with the invalid (for a handle) value "-1".

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T16:19:57Z

Joachim Tilsted Kristensen: /* null */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A constant of type <vp>pointer</vp> with the value "0".

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A constant of type "handle" with the value "0".

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A constant of type "handle" with the invalid (for a handle) value "-1".

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>

Language Reference/Built-in entities/Domains

2020-12-19T16:18:26Z

Joachim Tilsted Kristensen: /* integer64 */

{|{{prettytable}}
|-
|[[#any|any]]
|Universal term type.
|-
|[[#char|char]]
|Wide (two-bytes) character.
|-
|[[#string|string]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#string8|string8]]
|Zero-terminated sequence of ASCII (one-byte) characters.
|-
|[[#symbol|symbol]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#binary|binary]]
|Sequence of bytes.
|-
|[[#binaryNonAtomic|binaryNonAtomic]]
|Sequence of bytes.
|-
|[[#integer|integer]]
|32 bit signed integer.
|-
|[[#integer64|integer64]]
|64 bit signed integer.
|-
|[[#integerNative|integerNative]]
|Signed integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#unsigned|unsigned]]
|32 bit unsigned integer.
|-
|[[#unsigned64|unsigned64]]
|64 bit unsigned integer.
|-
|[[#unsignedNative|unsignedNative]]
|Unsigned integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#real|real]]
|Float-pointing number.
|-
|[[#real32|real32]]
|Float-pointing number.
|-
|[[#pointer|pointer]]
|pointer to a memory address.
|-
|[[#handle|handle]]
|a handle (e.g. native file and windows handles).
|-
|[[#boolean|boolean]]
|Boolean values.
|-
|[[#factDB|factDB]]
|Descriptors of named internal databases.
|-
|[[#compareResult|compareResult]]
|Values of comparison result.
|}

==== any ====

Universal term type.

<vip>any</vip>

The values of this domain are any terms. Such a value contains the reference to the term type library and a term itself.

==== char ====

Wide character.

<vip>char</vip>

The values of this domain are UNICODE characters. Implemented as 2 unsigned bytes.

Only assignment and comparison (in the lexicographical sense) operations are applied to the values of this domain. The image of a character has the following syntax:

<vipbnf><Char_image> :
' Char_value '
<Char_value> :
<Letter>
<Digit>
<Graphical_symbol>
\ <Escape_seq>
<Escape_seq>:
t
n
r
\
'
"
u <HHHH></vipbnf>

In the syntax above <vpbnf><HHHH></vpbnf> correspond to 4 hexadecimal digits. Also, the backslash symbol and the single quote can be represented by an escape-sequence only.

==== compareResult ====

A built-in domain that represents the result of a comparison. For instance, the built-in procedure {{lang2|Built-in entities|compare|compare/2->}} has "compareResult" as the domain of its result.
<vip>domains
compareResult = less; equal; greater.
</vip>

==== string ====

Wide zero terminated sequence of wide characters.

<vip>string</vip>

A string is a sequence of UNICODE characters. It's implemented as a pointer to the wide zero-terminated array of wide characters. Only assignment and comparison (in the lexicographical sense) operations are applied to values of this domain.

In source code a string literal can be specified as a set of sequences of characters surrounded by the double quotes.

<vipbnf><StringLiteral>:
<StringLiteralPart>-list</vipbnf>

<vipbnf><StringLiteralPart> :
@" AnyCharacter-list-opt "
" CharacterValue-list-opt "</vipbnf>

A string literal consists of one or more <vpbnf><StringLiteralPart></vpbnf>'s, which are concatenated. <vpbnf><StringLiteralPart></vpbnf>'s starting with <vp>@</vp> does not use escape sequences, whereas <vpbnf><StringLiteralPart></vpbnf>'s without <vp>@</vp> uses the following escape sequences:

*<vp>\\</vp> representing <vp>\</vp>
*<vp>\t</vp> representing Tab-character
*<vp>\n</vp> representing newline-character
*<vp>\r</vp> representing carriage return
*<vp>\'</vp> representing single quote
*<vp>\"</vp> representing double quote
*<vp>\u</vp> followed by exactly four <vpbnf><HexadecimalDigit></vpbnf>'s representing the Unicode character corresponding to the digits.

The double quotes in the string can be represented by the escape-sequence only (the single quote can be represented both with an escape-sequence and a graphical symbol).

==== string8 ====

A built-in domain who's elements are sequences of (one-byte) ASCII-characters. It is implemented as a pointer to the zero terminated array of ASCII characters. Only assignment and comparison for equality (in the lexicographical sense) operations are applied to the values of this domain. Currently no literals are allowed for this domain.

==== symbol ====

Wide zero terminated sequence of wide characters.

<vip>symbol</vip>

Similar to a string, a symbol is also a sequence of the UNICODE characters. It's implemented as a pointer to an entry in a symbol table that contains strings. The operations that can be applied to symbols are the same as for strings.

The image of a symbol is represented with a ''<string_literal>'' (any string surrounded by the double quotes).

Symbols and strings are largely interchangeable but they are stored differently. Symbols are kept in a look-up table and their addresses, rather than the symbols themselves, are stored to represent objects. This means that symbols can be matched very quickly and, if a symbol occurs repeatedly in a program, it can be stored very compactly. Strings are not kept in a look-up table. Visual Prolog examines strings character-by-character whenever they are to be matched.

==== binary ====

Sequence of bytes.

<vip>binary</vip>

Values of this domain are used for holding binary data. A binary value is implemented as a pointer to the sequence of bytes that represents the contents of a binary term.

The length of a binary term is situated in the '''4 bytes''' immediately preceding this sequence of bytes. The 4 bytes contains:

<vip>TotalNumberOfBytesOccupiedByBinary = ByteLen + 4 </vip>

where <vp>ByteLen</vp> - is the length of the binary term and 4 is number of bytes occupied by size field.

Only assignment and comparison operations are applied to values of '''binary domain'''.

Two binary terms are compared in the following way:

*If they are of different sizes, the bigger is considered larger.
*Otherwise, they are compared byte by byte, as unsigned values. Comparison stops when two differing bytes are found and the result of their comparison is the result of the comparison of the binary terms. Two binary terms are equal if they have the same sizes and all bytes are equal.

The text syntax for binary images is determined by the <vpbnf><Binary></vpbnf> rules:

<vipbnf><Binary> :
$ [ <Byte_value>-comma-sep-list-opt ]
<Byte_value> :
<Expression></vipbnf>

Each ''expression'' should be calculate on compiling time and its value should be in the range from <vp>0</vp> to <vp>255</vp>.

==== binaryNonAtomic ====

Sequence of bytes.

<vip>binaryNonAtomic</vip>

Same as [[#binary|binary]], but can contain pointers because it is scanned by the garbage collector.

==== integer ====

32 bit signed integer.

<vip>integer</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|quot/2->}}, and {{lang2|Built-in entities|Operators|rem/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>-2147483648</vp> to <vp>2147483647</vp>.

The syntax for the <vp>integer</vp> literal is determined by the <vpbnf><Integer></vpbnf> rule:

<vipbnf><Integer> :
<Add_operation>-opt 0o <Oct_number>
<Add_operation>-opt <Dec_number>
<Add_operation>-opt 0x <Hex_number>
<Add_operation> :
+
-
<Oct_number> :
<Oct_digit>-list
<Oct_digit> : one of
0 1 2 3 4 5 6 7
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
<Oct_digit> 8 9
<Hex_number> :
<Hex_digit>-list
<Hex_digit> : one of
<Dec_digit> a b c d e f A B C D E F</vipbnf>

==== integer64 ====

64 bit signed integers.

<vip>integer64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>-2^63 = -9223372036854775808</vp> to <vp>2^63-1 = 9223372036854775807</vp>.

The syntax for <vp>integer64</vp> literal is the same as <vpbnf><Integer></vpbnf> rule.

The set of operations for <vp>integer64</vp> is similar to the one for <vpbnf><Integer></vpbnf>.

==== integerNative ====

Signed integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>integerNative</vip>

==== unsigned ====

32 bit unsigned integer.

<vip>unsigned</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|rem/2->}}, and {{lang2|Built-in entities|Operators|quot/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>0</vp> to <vp>4294967295</vp>.

The syntax for <vp>unsigned</vp> number images is the same as for <vp>integer</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned</vp> number.

==== unsigned64 ====

64 bit unsigned integer.

<vip>unsigned64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>0</vp> to <vp>2^64-1 = 18,446,744,073,709,551,615</vp>.

The syntax for <vp>unsigned64</vp> number images is the same as for <vp>integer64</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned64</vp> number.

The set of operations for <vp>unsigned64</vp> is similar to the one for <vpbnf><Unsigned></vpbnf>.

==== unsignedNative ====

Unsigned integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>unsignedNative</vip>

==== real ====

Float-pointing number.

<vip>real</vip>

Values of this domain occupy 8 bytes. This numerical real domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations are applied to values of <vp>real</vp> domain.

The permitted number range is <vp>-1.7e+308</vp> to <vp>1.7e+308</vp>. Values from integral domains are automatically converted to real numbers when necessary.

The syntax for the floating-point number literal is determined by the <vpbnf><Real></vpbnf> rule:

<vipbnf><Real> :
<Add_operation>-opt <Fraction> <Exponent>-opt
<Fraction> :
<Dec_number> <Fractional_part>-opt
<Fractional_part> :
. <Dec_number>
<Exponent> :
<Exp> <Add_operation>-opt <Dec_number>
<Exp> :
e
E
<Add_operation> :
+
-
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
0 1 2 3 4 5 6 7 8 9</vipbnf>

==== real32 ====

Float-pointing number.

<vip>real32</vip>

Values of this domain occupy 4 bytes. This numerical <vp>real32</vp> domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations can be applied to values of <vp>real32</vp> domain.

The permitted number range is <vp>-3.4e+38</vp> to <vp>3.4e+38</vp>.

The syntax of real32 literals is the same as <vp>real</vp> lietrals.

==== pointer ====

A pointer to a memory address.

<vip>pointer</vip>

A pointer directly corresponds to memory addresses. Only the equality operation can be applied to the values of this domain. There is a built-in '''null''' constant for this type

==== handle ====

A handle is used for Windows API function call. Values of this domain has the same size as a pointer (i.e. 4 on 32bit platfor and 8 on 64bit platform).

There are no operations for this domain and cannot be converted (except uncheckedConvert) to/from other domains.

There is a built-in [[#nullHandle|nullHandle]] and [[#invalidHandle|invalidHandle]] constant for this type

==== boolean ====

Boolean values.

<vip>boolean</vip>

This domain is introduced for the user convenience only. It is treated as usual compound domain with the following definition:

<vip>domains
boolean = false(); true().</vip>

==== factDB ====

Descriptors of named internal databases.

<vip>factDB</vip>

This domain has the following hidden meta-declaration:

<vip>domains
factDB = struct @factdb( named_internal_database_domain, object ).</vip>

All user-defined names of facts sections are the constants of this domain. The compiler automatically builds the corresponding compound terms from such constants whenever it's in need. At the runtime the 1st field of this structure contains the address of the corresponding domain descriptor and the 2nd field contains either zero (for class facts sections) or pointer to an object (i.e. <vp>This</vp>, for object facts sections).
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Domains}}</noinclude>

Language Reference/Built-in entities/Domains

2020-12-19T16:18:02Z

Joachim Tilsted Kristensen: /* binaryNonAtomic */

{|{{prettytable}}
|-
|[[#any|any]]
|Universal term type.
|-
|[[#char|char]]
|Wide (two-bytes) character.
|-
|[[#string|string]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#string8|string8]]
|Zero-terminated sequence of ASCII (one-byte) characters.
|-
|[[#symbol|symbol]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#binary|binary]]
|Sequence of bytes.
|-
|[[#binaryNonAtomic|binaryNonAtomic]]
|Sequence of bytes.
|-
|[[#integer|integer]]
|32 bit signed integer.
|-
|[[#integer64|integer64]]
|64 bit signed integer.
|-
|[[#integerNative|integerNative]]
|Signed integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#unsigned|unsigned]]
|32 bit unsigned integer.
|-
|[[#unsigned64|unsigned64]]
|64 bit unsigned integer.
|-
|[[#unsignedNative|unsignedNative]]
|Unsigned integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#real|real]]
|Float-pointing number.
|-
|[[#real32|real32]]
|Float-pointing number.
|-
|[[#pointer|pointer]]
|pointer to a memory address.
|-
|[[#handle|handle]]
|a handle (e.g. native file and windows handles).
|-
|[[#boolean|boolean]]
|Boolean values.
|-
|[[#factDB|factDB]]
|Descriptors of named internal databases.
|-
|[[#compareResult|compareResult]]
|Values of comparison result.
|}

==== any ====

Universal term type.

<vip>any</vip>

The values of this domain are any terms. Such a value contains the reference to the term type library and a term itself.

==== char ====

Wide character.

<vip>char</vip>

The values of this domain are UNICODE characters. Implemented as 2 unsigned bytes.

Only assignment and comparison (in the lexicographical sense) operations are applied to the values of this domain. The image of a character has the following syntax:

<vipbnf><Char_image> :
' Char_value '
<Char_value> :
<Letter>
<Digit>
<Graphical_symbol>
\ <Escape_seq>
<Escape_seq>:
t
n
r
\
'
"
u <HHHH></vipbnf>

In the syntax above <vpbnf><HHHH></vpbnf> correspond to 4 hexadecimal digits. Also, the backslash symbol and the single quote can be represented by an escape-sequence only.

==== compareResult ====

A built-in domain that represents the result of a comparison. For instance, the built-in procedure {{lang2|Built-in entities|compare|compare/2->}} has "compareResult" as the domain of its result.
<vip>domains
compareResult = less; equal; greater.
</vip>

==== string ====

Wide zero terminated sequence of wide characters.

<vip>string</vip>

A string is a sequence of UNICODE characters. It's implemented as a pointer to the wide zero-terminated array of wide characters. Only assignment and comparison (in the lexicographical sense) operations are applied to values of this domain.

In source code a string literal can be specified as a set of sequences of characters surrounded by the double quotes.

<vipbnf><StringLiteral>:
<StringLiteralPart>-list</vipbnf>

<vipbnf><StringLiteralPart> :
@" AnyCharacter-list-opt "
" CharacterValue-list-opt "</vipbnf>

A string literal consists of one or more <vpbnf><StringLiteralPart></vpbnf>'s, which are concatenated. <vpbnf><StringLiteralPart></vpbnf>'s starting with <vp>@</vp> does not use escape sequences, whereas <vpbnf><StringLiteralPart></vpbnf>'s without <vp>@</vp> uses the following escape sequences:

*<vp>\\</vp> representing <vp>\</vp>
*<vp>\t</vp> representing Tab-character
*<vp>\n</vp> representing newline-character
*<vp>\r</vp> representing carriage return
*<vp>\'</vp> representing single quote
*<vp>\"</vp> representing double quote
*<vp>\u</vp> followed by exactly four <vpbnf><HexadecimalDigit></vpbnf>'s representing the Unicode character corresponding to the digits.

The double quotes in the string can be represented by the escape-sequence only (the single quote can be represented both with an escape-sequence and a graphical symbol).

==== string8 ====

A built-in domain who's elements are sequences of (one-byte) ASCII-characters. It is implemented as a pointer to the zero terminated array of ASCII characters. Only assignment and comparison for equality (in the lexicographical sense) operations are applied to the values of this domain. Currently no literals are allowed for this domain.

==== symbol ====

Wide zero terminated sequence of wide characters.

<vip>symbol</vip>

Similar to a string, a symbol is also a sequence of the UNICODE characters. It's implemented as a pointer to an entry in a symbol table that contains strings. The operations that can be applied to symbols are the same as for strings.

The image of a symbol is represented with a ''<string_literal>'' (any string surrounded by the double quotes).

Symbols and strings are largely interchangeable but they are stored differently. Symbols are kept in a look-up table and their addresses, rather than the symbols themselves, are stored to represent objects. This means that symbols can be matched very quickly and, if a symbol occurs repeatedly in a program, it can be stored very compactly. Strings are not kept in a look-up table. Visual Prolog examines strings character-by-character whenever they are to be matched.

==== binary ====

Sequence of bytes.

<vip>binary</vip>

Values of this domain are used for holding binary data. A binary value is implemented as a pointer to the sequence of bytes that represents the contents of a binary term.

The length of a binary term is situated in the '''4 bytes''' immediately preceding this sequence of bytes. The 4 bytes contains:

<vip>TotalNumberOfBytesOccupiedByBinary = ByteLen + 4 </vip>

where <vp>ByteLen</vp> - is the length of the binary term and 4 is number of bytes occupied by size field.

Only assignment and comparison operations are applied to values of '''binary domain'''.

Two binary terms are compared in the following way:

*If they are of different sizes, the bigger is considered larger.
*Otherwise, they are compared byte by byte, as unsigned values. Comparison stops when two differing bytes are found and the result of their comparison is the result of the comparison of the binary terms. Two binary terms are equal if they have the same sizes and all bytes are equal.

The text syntax for binary images is determined by the <vpbnf><Binary></vpbnf> rules:

<vipbnf><Binary> :
$ [ <Byte_value>-comma-sep-list-opt ]
<Byte_value> :
<Expression></vipbnf>

Each ''expression'' should be calculate on compiling time and its value should be in the range from <vp>0</vp> to <vp>255</vp>.

==== binaryNonAtomic ====

Sequence of bytes.

<vip>binaryNonAtomic</vip>

Same as [[#binary|binary]], but can contain pointers because it is scanned by the garbage collector.

==== integer ====

32 bit signed integer.

<vip>integer</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|quot/2->}}, and {{lang2|Built-in entities|Operators|rem/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>-2147483648</vp> to <vp>2147483647</vp>.

The syntax for the <vp>integer</vp> literal is determined by the <vpbnf><Integer></vpbnf> rule:

<vipbnf><Integer> :
<Add_operation>-opt 0o <Oct_number>
<Add_operation>-opt <Dec_number>
<Add_operation>-opt 0x <Hex_number>
<Add_operation> :
+
-
<Oct_number> :
<Oct_digit>-list
<Oct_digit> : one of
0 1 2 3 4 5 6 7
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
<Oct_digit> 8 9
<Hex_number> :
<Hex_digit>-list
<Hex_digit> : one of
<Dec_digit> a b c d e f A B C D E F</vipbnf>

==== integer64 ====

64 bit signed integer.

<vip>integer64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>-2^63 = -9223372036854775808</vp> to <vp>2^63-1 = 9223372036854775807</vp>.

The syntax for <vp>integer64</vp> literal is the same as <vpbnf><Integer></vpbnf> rule.

The set of operations for <vp>integer64</vp> is similar to the one for <vpbnf><Integer></vpbnf>.

==== integerNative ====

Signed integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>integerNative</vip>

==== unsigned ====

32 bit unsigned integer.

<vip>unsigned</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|rem/2->}}, and {{lang2|Built-in entities|Operators|quot/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>0</vp> to <vp>4294967295</vp>.

The syntax for <vp>unsigned</vp> number images is the same as for <vp>integer</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned</vp> number.

==== unsigned64 ====

64 bit unsigned integer.

<vip>unsigned64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>0</vp> to <vp>2^64-1 = 18,446,744,073,709,551,615</vp>.

The syntax for <vp>unsigned64</vp> number images is the same as for <vp>integer64</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned64</vp> number.

The set of operations for <vp>unsigned64</vp> is similar to the one for <vpbnf><Unsigned></vpbnf>.

==== unsignedNative ====

Unsigned integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>unsignedNative</vip>

==== real ====

Float-pointing number.

<vip>real</vip>

Values of this domain occupy 8 bytes. This numerical real domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations are applied to values of <vp>real</vp> domain.

The permitted number range is <vp>-1.7e+308</vp> to <vp>1.7e+308</vp>. Values from integral domains are automatically converted to real numbers when necessary.

The syntax for the floating-point number literal is determined by the <vpbnf><Real></vpbnf> rule:

<vipbnf><Real> :
<Add_operation>-opt <Fraction> <Exponent>-opt
<Fraction> :
<Dec_number> <Fractional_part>-opt
<Fractional_part> :
. <Dec_number>
<Exponent> :
<Exp> <Add_operation>-opt <Dec_number>
<Exp> :
e
E
<Add_operation> :
+
-
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
0 1 2 3 4 5 6 7 8 9</vipbnf>

==== real32 ====

Float-pointing number.

<vip>real32</vip>

Values of this domain occupy 4 bytes. This numerical <vp>real32</vp> domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations can be applied to values of <vp>real32</vp> domain.

The permitted number range is <vp>-3.4e+38</vp> to <vp>3.4e+38</vp>.

The syntax of real32 literals is the same as <vp>real</vp> lietrals.

==== pointer ====

A pointer to a memory address.

<vip>pointer</vip>

A pointer directly corresponds to memory addresses. Only the equality operation can be applied to the values of this domain. There is a built-in '''null''' constant for this type

==== handle ====

A handle is used for Windows API function call. Values of this domain has the same size as a pointer (i.e. 4 on 32bit platfor and 8 on 64bit platform).

There are no operations for this domain and cannot be converted (except uncheckedConvert) to/from other domains.

There is a built-in [[#nullHandle|nullHandle]] and [[#invalidHandle|invalidHandle]] constant for this type

==== boolean ====

Boolean values.

<vip>boolean</vip>

This domain is introduced for the user convenience only. It is treated as usual compound domain with the following definition:

<vip>domains
boolean = false(); true().</vip>

==== factDB ====

Descriptors of named internal databases.

<vip>factDB</vip>

This domain has the following hidden meta-declaration:

<vip>domains
factDB = struct @factdb( named_internal_database_domain, object ).</vip>

All user-defined names of facts sections are the constants of this domain. The compiler automatically builds the corresponding compound terms from such constants whenever it's in need. At the runtime the 1st field of this structure contains the address of the corresponding domain descriptor and the 2nd field contains either zero (for class facts sections) or pointer to an object (i.e. <vp>This</vp>, for object facts sections).
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Domains}}</noinclude>

Language Reference/Built-in entities/Domains

2020-12-19T16:17:46Z

Joachim Tilsted Kristensen: /* binary */

{|{{prettytable}}
|-
|[[#any|any]]
|Universal term type.
|-
|[[#char|char]]
|Wide (two-bytes) character.
|-
|[[#string|string]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#string8|string8]]
|Zero-terminated sequence of ASCII (one-byte) characters.
|-
|[[#symbol|symbol]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#binary|binary]]
|Sequence of bytes.
|-
|[[#binaryNonAtomic|binaryNonAtomic]]
|Sequence of bytes.
|-
|[[#integer|integer]]
|32 bit signed integer.
|-
|[[#integer64|integer64]]
|64 bit signed integer.
|-
|[[#integerNative|integerNative]]
|Signed integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#unsigned|unsigned]]
|32 bit unsigned integer.
|-
|[[#unsigned64|unsigned64]]
|64 bit unsigned integer.
|-
|[[#unsignedNative|unsignedNative]]
|Unsigned integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#real|real]]
|Float-pointing number.
|-
|[[#real32|real32]]
|Float-pointing number.
|-
|[[#pointer|pointer]]
|pointer to a memory address.
|-
|[[#handle|handle]]
|a handle (e.g. native file and windows handles).
|-
|[[#boolean|boolean]]
|Boolean values.
|-
|[[#factDB|factDB]]
|Descriptors of named internal databases.
|-
|[[#compareResult|compareResult]]
|Values of comparison result.
|}

==== any ====

Universal term type.

<vip>any</vip>

The values of this domain are any terms. Such a value contains the reference to the term type library and a term itself.

==== char ====

Wide character.

<vip>char</vip>

The values of this domain are UNICODE characters. Implemented as 2 unsigned bytes.

Only assignment and comparison (in the lexicographical sense) operations are applied to the values of this domain. The image of a character has the following syntax:

<vipbnf><Char_image> :
' Char_value '
<Char_value> :
<Letter>
<Digit>
<Graphical_symbol>
\ <Escape_seq>
<Escape_seq>:
t
n
r
\
'
"
u <HHHH></vipbnf>

In the syntax above <vpbnf><HHHH></vpbnf> correspond to 4 hexadecimal digits. Also, the backslash symbol and the single quote can be represented by an escape-sequence only.

==== compareResult ====

A built-in domain that represents the result of a comparison. For instance, the built-in procedure {{lang2|Built-in entities|compare|compare/2->}} has "compareResult" as the domain of its result.
<vip>domains
compareResult = less; equal; greater.
</vip>

==== string ====

Wide zero terminated sequence of wide characters.

<vip>string</vip>

A string is a sequence of UNICODE characters. It's implemented as a pointer to the wide zero-terminated array of wide characters. Only assignment and comparison (in the lexicographical sense) operations are applied to values of this domain.

In source code a string literal can be specified as a set of sequences of characters surrounded by the double quotes.

<vipbnf><StringLiteral>:
<StringLiteralPart>-list</vipbnf>

<vipbnf><StringLiteralPart> :
@" AnyCharacter-list-opt "
" CharacterValue-list-opt "</vipbnf>

A string literal consists of one or more <vpbnf><StringLiteralPart></vpbnf>'s, which are concatenated. <vpbnf><StringLiteralPart></vpbnf>'s starting with <vp>@</vp> does not use escape sequences, whereas <vpbnf><StringLiteralPart></vpbnf>'s without <vp>@</vp> uses the following escape sequences:

*<vp>\\</vp> representing <vp>\</vp>
*<vp>\t</vp> representing Tab-character
*<vp>\n</vp> representing newline-character
*<vp>\r</vp> representing carriage return
*<vp>\'</vp> representing single quote
*<vp>\"</vp> representing double quote
*<vp>\u</vp> followed by exactly four <vpbnf><HexadecimalDigit></vpbnf>'s representing the Unicode character corresponding to the digits.

The double quotes in the string can be represented by the escape-sequence only (the single quote can be represented both with an escape-sequence and a graphical symbol).

==== string8 ====

A built-in domain who's elements are sequences of (one-byte) ASCII-characters. It is implemented as a pointer to the zero terminated array of ASCII characters. Only assignment and comparison for equality (in the lexicographical sense) operations are applied to the values of this domain. Currently no literals are allowed for this domain.

==== symbol ====

Wide zero terminated sequence of wide characters.

<vip>symbol</vip>

Similar to a string, a symbol is also a sequence of the UNICODE characters. It's implemented as a pointer to an entry in a symbol table that contains strings. The operations that can be applied to symbols are the same as for strings.

The image of a symbol is represented with a ''<string_literal>'' (any string surrounded by the double quotes).

Symbols and strings are largely interchangeable but they are stored differently. Symbols are kept in a look-up table and their addresses, rather than the symbols themselves, are stored to represent objects. This means that symbols can be matched very quickly and, if a symbol occurs repeatedly in a program, it can be stored very compactly. Strings are not kept in a look-up table. Visual Prolog examines strings character-by-character whenever they are to be matched.

==== binary ====

Sequence of bytes.

<vip>binary</vip>

Values of this domain are used for holding binary data. A binary value is implemented as a pointer to the sequence of bytes that represents the contents of a binary term.

The length of a binary term is situated in the '''4 bytes''' immediately preceding this sequence of bytes. The 4 bytes contains:

<vip>TotalNumberOfBytesOccupiedByBinary = ByteLen + 4 </vip>

where <vp>ByteLen</vp> - is the length of the binary term and 4 is number of bytes occupied by size field.

Only assignment and comparison operations are applied to values of '''binary domain'''.

Two binary terms are compared in the following way:

*If they are of different sizes, the bigger is considered larger.
*Otherwise, they are compared byte by byte, as unsigned values. Comparison stops when two differing bytes are found and the result of their comparison is the result of the comparison of the binary terms. Two binary terms are equal if they have the same sizes and all bytes are equal.

The text syntax for binary images is determined by the <vpbnf><Binary></vpbnf> rules:

<vipbnf><Binary> :
$ [ <Byte_value>-comma-sep-list-opt ]
<Byte_value> :
<Expression></vipbnf>

Each ''expression'' should be calculate on compiling time and its value should be in the range from <vp>0</vp> to <vp>255</vp>.

==== binaryNonAtomic ====

Sequence of N bytes.

<vip>binaryNonAtomic</vip>

Same as [[#binary|binary]], but can contain pointers because it is scanned by the garbage collector.

==== integer ====

32 bit signed integer.

<vip>integer</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|quot/2->}}, and {{lang2|Built-in entities|Operators|rem/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>-2147483648</vp> to <vp>2147483647</vp>.

The syntax for the <vp>integer</vp> literal is determined by the <vpbnf><Integer></vpbnf> rule:

<vipbnf><Integer> :
<Add_operation>-opt 0o <Oct_number>
<Add_operation>-opt <Dec_number>
<Add_operation>-opt 0x <Hex_number>
<Add_operation> :
+
-
<Oct_number> :
<Oct_digit>-list
<Oct_digit> : one of
0 1 2 3 4 5 6 7
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
<Oct_digit> 8 9
<Hex_number> :
<Hex_digit>-list
<Hex_digit> : one of
<Dec_digit> a b c d e f A B C D E F</vipbnf>

==== integer64 ====

64 bit signed integer.

<vip>integer64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>-2^63 = -9223372036854775808</vp> to <vp>2^63-1 = 9223372036854775807</vp>.

The syntax for <vp>integer64</vp> literal is the same as <vpbnf><Integer></vpbnf> rule.

The set of operations for <vp>integer64</vp> is similar to the one for <vpbnf><Integer></vpbnf>.

==== integerNative ====

Signed integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>integerNative</vip>

==== unsigned ====

32 bit unsigned integer.

<vip>unsigned</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|rem/2->}}, and {{lang2|Built-in entities|Operators|quot/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>0</vp> to <vp>4294967295</vp>.

The syntax for <vp>unsigned</vp> number images is the same as for <vp>integer</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned</vp> number.

==== unsigned64 ====

64 bit unsigned integer.

<vip>unsigned64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>0</vp> to <vp>2^64-1 = 18,446,744,073,709,551,615</vp>.

The syntax for <vp>unsigned64</vp> number images is the same as for <vp>integer64</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned64</vp> number.

The set of operations for <vp>unsigned64</vp> is similar to the one for <vpbnf><Unsigned></vpbnf>.

==== unsignedNative ====

Unsigned integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>unsignedNative</vip>

==== real ====

Float-pointing number.

<vip>real</vip>

Values of this domain occupy 8 bytes. This numerical real domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations are applied to values of <vp>real</vp> domain.

The permitted number range is <vp>-1.7e+308</vp> to <vp>1.7e+308</vp>. Values from integral domains are automatically converted to real numbers when necessary.

The syntax for the floating-point number literal is determined by the <vpbnf><Real></vpbnf> rule:

<vipbnf><Real> :
<Add_operation>-opt <Fraction> <Exponent>-opt
<Fraction> :
<Dec_number> <Fractional_part>-opt
<Fractional_part> :
. <Dec_number>
<Exponent> :
<Exp> <Add_operation>-opt <Dec_number>
<Exp> :
e
E
<Add_operation> :
+
-
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
0 1 2 3 4 5 6 7 8 9</vipbnf>

==== real32 ====

Float-pointing number.

<vip>real32</vip>

Values of this domain occupy 4 bytes. This numerical <vp>real32</vp> domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations can be applied to values of <vp>real32</vp> domain.

The permitted number range is <vp>-3.4e+38</vp> to <vp>3.4e+38</vp>.

The syntax of real32 literals is the same as <vp>real</vp> lietrals.

==== pointer ====

A pointer to a memory address.

<vip>pointer</vip>

A pointer directly corresponds to memory addresses. Only the equality operation can be applied to the values of this domain. There is a built-in '''null''' constant for this type

==== handle ====

A handle is used for Windows API function call. Values of this domain has the same size as a pointer (i.e. 4 on 32bit platfor and 8 on 64bit platform).

There are no operations for this domain and cannot be converted (except uncheckedConvert) to/from other domains.

There is a built-in [[#nullHandle|nullHandle]] and [[#invalidHandle|invalidHandle]] constant for this type

==== boolean ====

Boolean values.

<vip>boolean</vip>

This domain is introduced for the user convenience only. It is treated as usual compound domain with the following definition:

<vip>domains
boolean = false(); true().</vip>

==== factDB ====

Descriptors of named internal databases.

<vip>factDB</vip>

This domain has the following hidden meta-declaration:

<vip>domains
factDB = struct @factdb( named_internal_database_domain, object ).</vip>

All user-defined names of facts sections are the constants of this domain. The compiler automatically builds the corresponding compound terms from such constants whenever it's in need. At the runtime the 1st field of this structure contains the address of the corresponding domain descriptor and the 2nd field contains either zero (for class facts sections) or pointer to an object (i.e. <vp>This</vp>, for object facts sections).
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Domains}}</noinclude>

Language Reference/Built-in entities/Domains

2020-12-19T16:17:13Z

Joachim Tilsted Kristensen: /* string8 */

{|{{prettytable}}
|-
|[[#any|any]]
|Universal term type.
|-
|[[#char|char]]
|Wide (two-bytes) character.
|-
|[[#string|string]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#string8|string8]]
|Zero-terminated sequence of ASCII (one-byte) characters.
|-
|[[#symbol|symbol]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#binary|binary]]
|Sequence of bytes.
|-
|[[#binaryNonAtomic|binaryNonAtomic]]
|Sequence of bytes.
|-
|[[#integer|integer]]
|32 bit signed integer.
|-
|[[#integer64|integer64]]
|64 bit signed integer.
|-
|[[#integerNative|integerNative]]
|Signed integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#unsigned|unsigned]]
|32 bit unsigned integer.
|-
|[[#unsigned64|unsigned64]]
|64 bit unsigned integer.
|-
|[[#unsignedNative|unsignedNative]]
|Unsigned integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#real|real]]
|Float-pointing number.
|-
|[[#real32|real32]]
|Float-pointing number.
|-
|[[#pointer|pointer]]
|pointer to a memory address.
|-
|[[#handle|handle]]
|a handle (e.g. native file and windows handles).
|-
|[[#boolean|boolean]]
|Boolean values.
|-
|[[#factDB|factDB]]
|Descriptors of named internal databases.
|-
|[[#compareResult|compareResult]]
|Values of comparison result.
|}

==== any ====

Universal term type.

<vip>any</vip>

The values of this domain are any terms. Such a value contains the reference to the term type library and a term itself.

==== char ====

Wide character.

<vip>char</vip>

The values of this domain are UNICODE characters. Implemented as 2 unsigned bytes.

Only assignment and comparison (in the lexicographical sense) operations are applied to the values of this domain. The image of a character has the following syntax:

<vipbnf><Char_image> :
' Char_value '
<Char_value> :
<Letter>
<Digit>
<Graphical_symbol>
\ <Escape_seq>
<Escape_seq>:
t
n
r
\
'
"
u <HHHH></vipbnf>

In the syntax above <vpbnf><HHHH></vpbnf> correspond to 4 hexadecimal digits. Also, the backslash symbol and the single quote can be represented by an escape-sequence only.

==== compareResult ====

A built-in domain that represents the result of a comparison. For instance, the built-in procedure {{lang2|Built-in entities|compare|compare/2->}} has "compareResult" as the domain of its result.
<vip>domains
compareResult = less; equal; greater.
</vip>

==== string ====

Wide zero terminated sequence of wide characters.

<vip>string</vip>

A string is a sequence of UNICODE characters. It's implemented as a pointer to the wide zero-terminated array of wide characters. Only assignment and comparison (in the lexicographical sense) operations are applied to values of this domain.

In source code a string literal can be specified as a set of sequences of characters surrounded by the double quotes.

<vipbnf><StringLiteral>:
<StringLiteralPart>-list</vipbnf>

<vipbnf><StringLiteralPart> :
@" AnyCharacter-list-opt "
" CharacterValue-list-opt "</vipbnf>

A string literal consists of one or more <vpbnf><StringLiteralPart></vpbnf>'s, which are concatenated. <vpbnf><StringLiteralPart></vpbnf>'s starting with <vp>@</vp> does not use escape sequences, whereas <vpbnf><StringLiteralPart></vpbnf>'s without <vp>@</vp> uses the following escape sequences:

*<vp>\\</vp> representing <vp>\</vp>
*<vp>\t</vp> representing Tab-character
*<vp>\n</vp> representing newline-character
*<vp>\r</vp> representing carriage return
*<vp>\'</vp> representing single quote
*<vp>\"</vp> representing double quote
*<vp>\u</vp> followed by exactly four <vpbnf><HexadecimalDigit></vpbnf>'s representing the Unicode character corresponding to the digits.

The double quotes in the string can be represented by the escape-sequence only (the single quote can be represented both with an escape-sequence and a graphical symbol).

==== string8 ====

A built-in domain who's elements are sequences of (one-byte) ASCII-characters. It is implemented as a pointer to the zero terminated array of ASCII characters. Only assignment and comparison for equality (in the lexicographical sense) operations are applied to the values of this domain. Currently no literals are allowed for this domain.

==== symbol ====

Wide zero terminated sequence of wide characters.

<vip>symbol</vip>

Similar to a string, a symbol is also a sequence of the UNICODE characters. It's implemented as a pointer to an entry in a symbol table that contains strings. The operations that can be applied to symbols are the same as for strings.

The image of a symbol is represented with a ''<string_literal>'' (any string surrounded by the double quotes).

Symbols and strings are largely interchangeable but they are stored differently. Symbols are kept in a look-up table and their addresses, rather than the symbols themselves, are stored to represent objects. This means that symbols can be matched very quickly and, if a symbol occurs repeatedly in a program, it can be stored very compactly. Strings are not kept in a look-up table. Visual Prolog examines strings character-by-character whenever they are to be matched.

==== binary ====

Sequence of N bytes.

<vip>binary</vip>

Values of this domain are used for holding binary data. A binary value is implemented as a pointer to the sequence of bytes that represents the contents of a binary term.

The length of a binary term is situated in the '''4 bytes''' immediately preceding this sequence of bytes. The 4 bytes contains:

<vip>TotalNumberOfBytesOccupiedByBinary = ByteLen + 4 </vip>

where <vp>ByteLen</vp> - is the length of the binary term and 4 is number of bytes occupied by size field.

Only assignment and comparison operations are applied to values of '''binary domain'''.

Two binary terms are compared in the following way:

*If they are of different sizes, the bigger is considered larger.
*Otherwise, they are compared byte by byte, as unsigned values. Comparison stops when two differing bytes are found and the result of their comparison is the result of the comparison of the binary terms. Two binary terms are equal if they have the same sizes and all bytes are equal.

The text syntax for binary images is determined by the <vpbnf><Binary></vpbnf> rules:

<vipbnf><Binary> :
$ [ <Byte_value>-comma-sep-list-opt ]
<Byte_value> :
<Expression></vipbnf>

Each ''expression'' should be calculate on compiling time and its value should be in the range from <vp>0</vp> to <vp>255</vp>.

==== binaryNonAtomic ====

Sequence of N bytes.

<vip>binaryNonAtomic</vip>

Same as [[#binary|binary]], but can contain pointers because it is scanned by the garbage collector.

==== integer ====

32 bit signed integer.

<vip>integer</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|quot/2->}}, and {{lang2|Built-in entities|Operators|rem/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>-2147483648</vp> to <vp>2147483647</vp>.

The syntax for the <vp>integer</vp> literal is determined by the <vpbnf><Integer></vpbnf> rule:

<vipbnf><Integer> :
<Add_operation>-opt 0o <Oct_number>
<Add_operation>-opt <Dec_number>
<Add_operation>-opt 0x <Hex_number>
<Add_operation> :
+
-
<Oct_number> :
<Oct_digit>-list
<Oct_digit> : one of
0 1 2 3 4 5 6 7
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
<Oct_digit> 8 9
<Hex_number> :
<Hex_digit>-list
<Hex_digit> : one of
<Dec_digit> a b c d e f A B C D E F</vipbnf>

==== integer64 ====

64 bit signed integer.

<vip>integer64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>-2^63 = -9223372036854775808</vp> to <vp>2^63-1 = 9223372036854775807</vp>.

The syntax for <vp>integer64</vp> literal is the same as <vpbnf><Integer></vpbnf> rule.

The set of operations for <vp>integer64</vp> is similar to the one for <vpbnf><Integer></vpbnf>.

==== integerNative ====

Signed integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>integerNative</vip>

==== unsigned ====

32 bit unsigned integer.

<vip>unsigned</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|rem/2->}}, and {{lang2|Built-in entities|Operators|quot/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>0</vp> to <vp>4294967295</vp>.

The syntax for <vp>unsigned</vp> number images is the same as for <vp>integer</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned</vp> number.

==== unsigned64 ====

64 bit unsigned integer.

<vip>unsigned64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>0</vp> to <vp>2^64-1 = 18,446,744,073,709,551,615</vp>.

The syntax for <vp>unsigned64</vp> number images is the same as for <vp>integer64</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned64</vp> number.

The set of operations for <vp>unsigned64</vp> is similar to the one for <vpbnf><Unsigned></vpbnf>.

==== unsignedNative ====

Unsigned integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>unsignedNative</vip>

==== real ====

Float-pointing number.

<vip>real</vip>

Values of this domain occupy 8 bytes. This numerical real domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations are applied to values of <vp>real</vp> domain.

The permitted number range is <vp>-1.7e+308</vp> to <vp>1.7e+308</vp>. Values from integral domains are automatically converted to real numbers when necessary.

The syntax for the floating-point number literal is determined by the <vpbnf><Real></vpbnf> rule:

<vipbnf><Real> :
<Add_operation>-opt <Fraction> <Exponent>-opt
<Fraction> :
<Dec_number> <Fractional_part>-opt
<Fractional_part> :
. <Dec_number>
<Exponent> :
<Exp> <Add_operation>-opt <Dec_number>
<Exp> :
e
E
<Add_operation> :
+
-
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
0 1 2 3 4 5 6 7 8 9</vipbnf>

==== real32 ====

Float-pointing number.

<vip>real32</vip>

Values of this domain occupy 4 bytes. This numerical <vp>real32</vp> domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations can be applied to values of <vp>real32</vp> domain.

The permitted number range is <vp>-3.4e+38</vp> to <vp>3.4e+38</vp>.

The syntax of real32 literals is the same as <vp>real</vp> lietrals.

==== pointer ====

A pointer to a memory address.

<vip>pointer</vip>

A pointer directly corresponds to memory addresses. Only the equality operation can be applied to the values of this domain. There is a built-in '''null''' constant for this type

==== handle ====

A handle is used for Windows API function call. Values of this domain has the same size as a pointer (i.e. 4 on 32bit platfor and 8 on 64bit platform).

There are no operations for this domain and cannot be converted (except uncheckedConvert) to/from other domains.

There is a built-in [[#nullHandle|nullHandle]] and [[#invalidHandle|invalidHandle]] constant for this type

==== boolean ====

Boolean values.

<vip>boolean</vip>

This domain is introduced for the user convenience only. It is treated as usual compound domain with the following definition:

<vip>domains
boolean = false(); true().</vip>

==== factDB ====

Descriptors of named internal databases.

<vip>factDB</vip>

This domain has the following hidden meta-declaration:

<vip>domains
factDB = struct @factdb( named_internal_database_domain, object ).</vip>

All user-defined names of facts sections are the constants of this domain. The compiler automatically builds the corresponding compound terms from such constants whenever it's in need. At the runtime the 1st field of this structure contains the address of the corresponding domain descriptor and the 2nd field contains either zero (for class facts sections) or pointer to an object (i.e. <vp>This</vp>, for object facts sections).
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Domains}}</noinclude>

Language Reference/Built-in entities/Domains

2020-12-19T16:16:03Z

Joachim Tilsted Kristensen: /* string8 */

{|{{prettytable}}
|-
|[[#any|any]]
|Universal term type.
|-
|[[#char|char]]
|Wide (two-bytes) character.
|-
|[[#string|string]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#string8|string8]]
|Zero-terminated sequence of ASCII (one-byte) characters.
|-
|[[#symbol|symbol]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#binary|binary]]
|Sequence of bytes.
|-
|[[#binaryNonAtomic|binaryNonAtomic]]
|Sequence of bytes.
|-
|[[#integer|integer]]
|32 bit signed integer.
|-
|[[#integer64|integer64]]
|64 bit signed integer.
|-
|[[#integerNative|integerNative]]
|Signed integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#unsigned|unsigned]]
|32 bit unsigned integer.
|-
|[[#unsigned64|unsigned64]]
|64 bit unsigned integer.
|-
|[[#unsignedNative|unsignedNative]]
|Unsigned integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#real|real]]
|Float-pointing number.
|-
|[[#real32|real32]]
|Float-pointing number.
|-
|[[#pointer|pointer]]
|pointer to a memory address.
|-
|[[#handle|handle]]
|a handle (e.g. native file and windows handles).
|-
|[[#boolean|boolean]]
|Boolean values.
|-
|[[#factDB|factDB]]
|Descriptors of named internal databases.
|-
|[[#compareResult|compareResult]]
|Values of comparison result.
|}

==== any ====

Universal term type.

<vip>any</vip>

The values of this domain are any terms. Such a value contains the reference to the term type library and a term itself.

==== char ====

Wide character.

<vip>char</vip>

The values of this domain are UNICODE characters. Implemented as 2 unsigned bytes.

Only assignment and comparison (in the lexicographical sense) operations are applied to the values of this domain. The image of a character has the following syntax:

<vipbnf><Char_image> :
' Char_value '
<Char_value> :
<Letter>
<Digit>
<Graphical_symbol>
\ <Escape_seq>
<Escape_seq>:
t
n
r
\
'
"
u <HHHH></vipbnf>

In the syntax above <vpbnf><HHHH></vpbnf> correspond to 4 hexadecimal digits. Also, the backslash symbol and the single quote can be represented by an escape-sequence only.

==== compareResult ====

A built-in domain that represents the result of a comparison. For instance, the built-in procedure {{lang2|Built-in entities|compare|compare/2->}} has "compareResult" as the domain of its result.
<vip>domains
compareResult = less; equal; greater.
</vip>

==== string ====

Wide zero terminated sequence of wide characters.

<vip>string</vip>

A string is a sequence of UNICODE characters. It's implemented as a pointer to the wide zero-terminated array of wide characters. Only assignment and comparison (in the lexicographical sense) operations are applied to values of this domain.

In source code a string literal can be specified as a set of sequences of characters surrounded by the double quotes.

<vipbnf><StringLiteral>:
<StringLiteralPart>-list</vipbnf>

<vipbnf><StringLiteralPart> :
@" AnyCharacter-list-opt "
" CharacterValue-list-opt "</vipbnf>

A string literal consists of one or more <vpbnf><StringLiteralPart></vpbnf>'s, which are concatenated. <vpbnf><StringLiteralPart></vpbnf>'s starting with <vp>@</vp> does not use escape sequences, whereas <vpbnf><StringLiteralPart></vpbnf>'s without <vp>@</vp> uses the following escape sequences:

*<vp>\\</vp> representing <vp>\</vp>
*<vp>\t</vp> representing Tab-character
*<vp>\n</vp> representing newline-character
*<vp>\r</vp> representing carriage return
*<vp>\'</vp> representing single quote
*<vp>\"</vp> representing double quote
*<vp>\u</vp> followed by exactly four <vpbnf><HexadecimalDigit></vpbnf>'s representing the Unicode character corresponding to the digits.

The double quotes in the string can be represented by the escape-sequence only (the single quote can be represented both with an escape-sequence and a graphical symbol).

==== string8 ====

A built-in domain inhabited by sequences of (one-byte) ASCII-characters. It is implemented as a pointer to the zero terminated array of ASCII characters. Only assignment and comparison for equality (in the lexicographical sense) operations are applied to the values of this domain. Currently no literals are allowed for this domain.

==== symbol ====

Wide zero terminated sequence of wide characters.

<vip>symbol</vip>

Similar to a string, a symbol is also a sequence of the UNICODE characters. It's implemented as a pointer to an entry in a symbol table that contains strings. The operations that can be applied to symbols are the same as for strings.

The image of a symbol is represented with a ''<string_literal>'' (any string surrounded by the double quotes).

Symbols and strings are largely interchangeable but they are stored differently. Symbols are kept in a look-up table and their addresses, rather than the symbols themselves, are stored to represent objects. This means that symbols can be matched very quickly and, if a symbol occurs repeatedly in a program, it can be stored very compactly. Strings are not kept in a look-up table. Visual Prolog examines strings character-by-character whenever they are to be matched.

==== binary ====

Sequence of N bytes.

<vip>binary</vip>

Values of this domain are used for holding binary data. A binary value is implemented as a pointer to the sequence of bytes that represents the contents of a binary term.

The length of a binary term is situated in the '''4 bytes''' immediately preceding this sequence of bytes. The 4 bytes contains:

<vip>TotalNumberOfBytesOccupiedByBinary = ByteLen + 4 </vip>

where <vp>ByteLen</vp> - is the length of the binary term and 4 is number of bytes occupied by size field.

Only assignment and comparison operations are applied to values of '''binary domain'''.

Two binary terms are compared in the following way:

*If they are of different sizes, the bigger is considered larger.
*Otherwise, they are compared byte by byte, as unsigned values. Comparison stops when two differing bytes are found and the result of their comparison is the result of the comparison of the binary terms. Two binary terms are equal if they have the same sizes and all bytes are equal.

The text syntax for binary images is determined by the <vpbnf><Binary></vpbnf> rules:

<vipbnf><Binary> :
$ [ <Byte_value>-comma-sep-list-opt ]
<Byte_value> :
<Expression></vipbnf>

Each ''expression'' should be calculate on compiling time and its value should be in the range from <vp>0</vp> to <vp>255</vp>.

==== binaryNonAtomic ====

Sequence of N bytes.

<vip>binaryNonAtomic</vip>

Same as [[#binary|binary]], but can contain pointers because it is scanned by the garbage collector.

==== integer ====

32 bit signed integer.

<vip>integer</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|quot/2->}}, and {{lang2|Built-in entities|Operators|rem/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>-2147483648</vp> to <vp>2147483647</vp>.

The syntax for the <vp>integer</vp> literal is determined by the <vpbnf><Integer></vpbnf> rule:

<vipbnf><Integer> :
<Add_operation>-opt 0o <Oct_number>
<Add_operation>-opt <Dec_number>
<Add_operation>-opt 0x <Hex_number>
<Add_operation> :
+
-
<Oct_number> :
<Oct_digit>-list
<Oct_digit> : one of
0 1 2 3 4 5 6 7
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
<Oct_digit> 8 9
<Hex_number> :
<Hex_digit>-list
<Hex_digit> : one of
<Dec_digit> a b c d e f A B C D E F</vipbnf>

==== integer64 ====

64 bit signed integer.

<vip>integer64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>-2^63 = -9223372036854775808</vp> to <vp>2^63-1 = 9223372036854775807</vp>.

The syntax for <vp>integer64</vp> literal is the same as <vpbnf><Integer></vpbnf> rule.

The set of operations for <vp>integer64</vp> is similar to the one for <vpbnf><Integer></vpbnf>.

==== integerNative ====

Signed integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>integerNative</vip>

==== unsigned ====

32 bit unsigned integer.

<vip>unsigned</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|rem/2->}}, and {{lang2|Built-in entities|Operators|quot/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>0</vp> to <vp>4294967295</vp>.

The syntax for <vp>unsigned</vp> number images is the same as for <vp>integer</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned</vp> number.

==== unsigned64 ====

64 bit unsigned integer.

<vip>unsigned64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>0</vp> to <vp>2^64-1 = 18,446,744,073,709,551,615</vp>.

The syntax for <vp>unsigned64</vp> number images is the same as for <vp>integer64</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned64</vp> number.

The set of operations for <vp>unsigned64</vp> is similar to the one for <vpbnf><Unsigned></vpbnf>.

==== unsignedNative ====

Unsigned integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>unsignedNative</vip>

==== real ====

Float-pointing number.

<vip>real</vip>

Values of this domain occupy 8 bytes. This numerical real domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations are applied to values of <vp>real</vp> domain.

The permitted number range is <vp>-1.7e+308</vp> to <vp>1.7e+308</vp>. Values from integral domains are automatically converted to real numbers when necessary.

The syntax for the floating-point number literal is determined by the <vpbnf><Real></vpbnf> rule:

<vipbnf><Real> :
<Add_operation>-opt <Fraction> <Exponent>-opt
<Fraction> :
<Dec_number> <Fractional_part>-opt
<Fractional_part> :
. <Dec_number>
<Exponent> :
<Exp> <Add_operation>-opt <Dec_number>
<Exp> :
e
E
<Add_operation> :
+
-
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
0 1 2 3 4 5 6 7 8 9</vipbnf>

==== real32 ====

Float-pointing number.

<vip>real32</vip>

Values of this domain occupy 4 bytes. This numerical <vp>real32</vp> domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations can be applied to values of <vp>real32</vp> domain.

The permitted number range is <vp>-3.4e+38</vp> to <vp>3.4e+38</vp>.

The syntax of real32 literals is the same as <vp>real</vp> lietrals.

==== pointer ====

A pointer to a memory address.

<vip>pointer</vip>

A pointer directly corresponds to memory addresses. Only the equality operation can be applied to the values of this domain. There is a built-in '''null''' constant for this type

==== handle ====

A handle is used for Windows API function call. Values of this domain has the same size as a pointer (i.e. 4 on 32bit platfor and 8 on 64bit platform).

There are no operations for this domain and cannot be converted (except uncheckedConvert) to/from other domains.

There is a built-in [[#nullHandle|nullHandle]] and [[#invalidHandle|invalidHandle]] constant for this type

==== boolean ====

Boolean values.

<vip>boolean</vip>

This domain is introduced for the user convenience only. It is treated as usual compound domain with the following definition:

<vip>domains
boolean = false(); true().</vip>

==== factDB ====

Descriptors of named internal databases.

<vip>factDB</vip>

This domain has the following hidden meta-declaration:

<vip>domains
factDB = struct @factdb( named_internal_database_domain, object ).</vip>

All user-defined names of facts sections are the constants of this domain. The compiler automatically builds the corresponding compound terms from such constants whenever it's in need. At the runtime the 1st field of this structure contains the address of the corresponding domain descriptor and the 2nd field contains either zero (for class facts sections) or pointer to an object (i.e. <vp>This</vp>, for object facts sections).
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Domains}}</noinclude>

Language Reference/Built-in entities/Domains

2020-12-19T16:12:22Z

Joachim Tilsted Kristensen: /* compareResult */

{|{{prettytable}}
|-
|[[#any|any]]
|Universal term type.
|-
|[[#char|char]]
|Wide (two-bytes) character.
|-
|[[#string|string]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#string8|string8]]
|Zero-terminated sequence of ASCII (one-byte) characters.
|-
|[[#symbol|symbol]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#binary|binary]]
|Sequence of bytes.
|-
|[[#binaryNonAtomic|binaryNonAtomic]]
|Sequence of bytes.
|-
|[[#integer|integer]]
|32 bit signed integer.
|-
|[[#integer64|integer64]]
|64 bit signed integer.
|-
|[[#integerNative|integerNative]]
|Signed integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#unsigned|unsigned]]
|32 bit unsigned integer.
|-
|[[#unsigned64|unsigned64]]
|64 bit unsigned integer.
|-
|[[#unsignedNative|unsignedNative]]
|Unsigned integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#real|real]]
|Float-pointing number.
|-
|[[#real32|real32]]
|Float-pointing number.
|-
|[[#pointer|pointer]]
|pointer to a memory address.
|-
|[[#handle|handle]]
|a handle (e.g. native file and windows handles).
|-
|[[#boolean|boolean]]
|Boolean values.
|-
|[[#factDB|factDB]]
|Descriptors of named internal databases.
|-
|[[#compareResult|compareResult]]
|Values of comparison result.
|}

==== any ====

Universal term type.

<vip>any</vip>

The values of this domain are any terms. Such a value contains the reference to the term type library and a term itself.

==== char ====

Wide character.

<vip>char</vip>

The values of this domain are UNICODE characters. Implemented as 2 unsigned bytes.

Only assignment and comparison (in the lexicographical sense) operations are applied to the values of this domain. The image of a character has the following syntax:

<vipbnf><Char_image> :
' Char_value '
<Char_value> :
<Letter>
<Digit>
<Graphical_symbol>
\ <Escape_seq>
<Escape_seq>:
t
n
r
\
'
"
u <HHHH></vipbnf>

In the syntax above <vpbnf><HHHH></vpbnf> correspond to 4 hexadecimal digits. Also, the backslash symbol and the single quote can be represented by an escape-sequence only.

==== compareResult ====

A built-in domain that represents the result of a comparison. For instance, the built-in procedure {{lang2|Built-in entities|compare|compare/2->}} has "compareResult" as the domain of its result.
<vip>domains
compareResult = less; equal; greater.
</vip>

==== string ====

Wide zero terminated sequence of wide characters.

<vip>string</vip>

A string is a sequence of UNICODE characters. It's implemented as a pointer to the wide zero-terminated array of wide characters. Only assignment and comparison (in the lexicographical sense) operations are applied to values of this domain.

In source code a string literal can be specified as a set of sequences of characters surrounded by the double quotes.

<vipbnf><StringLiteral>:
<StringLiteralPart>-list</vipbnf>

<vipbnf><StringLiteralPart> :
@" AnyCharacter-list-opt "
" CharacterValue-list-opt "</vipbnf>

A string literal consists of one or more <vpbnf><StringLiteralPart></vpbnf>'s, which are concatenated. <vpbnf><StringLiteralPart></vpbnf>'s starting with <vp>@</vp> does not use escape sequences, whereas <vpbnf><StringLiteralPart></vpbnf>'s without <vp>@</vp> uses the following escape sequences:

*<vp>\\</vp> representing <vp>\</vp>
*<vp>\t</vp> representing Tab-character
*<vp>\n</vp> representing newline-character
*<vp>\r</vp> representing carriage return
*<vp>\'</vp> representing single quote
*<vp>\"</vp> representing double quote
*<vp>\u</vp> followed by exactly four <vpbnf><HexadecimalDigit></vpbnf>'s representing the Unicode character corresponding to the digits.

The double quotes in the string can be represented by the escape-sequence only (the single quote can be represented both with an escape-sequence and a graphical symbol).

==== string8 ====

A term of the built-in <vp>string8</vp> domain is a sequence of ASCII (one-byte) characters. It is implemented as a pointer to the zero terminated array of ASCII characters. Only assignment and comparison for equality (in the lexicographical sense) operations are applied to the values of this domain. Currently no literals are allowed for this domain.

==== symbol ====

Wide zero terminated sequence of wide characters.

<vip>symbol</vip>

Similar to a string, a symbol is also a sequence of the UNICODE characters. It's implemented as a pointer to an entry in a symbol table that contains strings. The operations that can be applied to symbols are the same as for strings.

The image of a symbol is represented with a ''<string_literal>'' (any string surrounded by the double quotes).

Symbols and strings are largely interchangeable but they are stored differently. Symbols are kept in a look-up table and their addresses, rather than the symbols themselves, are stored to represent objects. This means that symbols can be matched very quickly and, if a symbol occurs repeatedly in a program, it can be stored very compactly. Strings are not kept in a look-up table. Visual Prolog examines strings character-by-character whenever they are to be matched.

==== binary ====

Sequence of N bytes.

<vip>binary</vip>

Values of this domain are used for holding binary data. A binary value is implemented as a pointer to the sequence of bytes that represents the contents of a binary term.

The length of a binary term is situated in the '''4 bytes''' immediately preceding this sequence of bytes. The 4 bytes contains:

<vip>TotalNumberOfBytesOccupiedByBinary = ByteLen + 4 </vip>

where <vp>ByteLen</vp> - is the length of the binary term and 4 is number of bytes occupied by size field.

Only assignment and comparison operations are applied to values of '''binary domain'''.

Two binary terms are compared in the following way:

*If they are of different sizes, the bigger is considered larger.
*Otherwise, they are compared byte by byte, as unsigned values. Comparison stops when two differing bytes are found and the result of their comparison is the result of the comparison of the binary terms. Two binary terms are equal if they have the same sizes and all bytes are equal.

The text syntax for binary images is determined by the <vpbnf><Binary></vpbnf> rules:

<vipbnf><Binary> :
$ [ <Byte_value>-comma-sep-list-opt ]
<Byte_value> :
<Expression></vipbnf>

Each ''expression'' should be calculate on compiling time and its value should be in the range from <vp>0</vp> to <vp>255</vp>.

==== binaryNonAtomic ====

Sequence of N bytes.

<vip>binaryNonAtomic</vip>

Same as [[#binary|binary]], but can contain pointers because it is scanned by the garbage collector.

==== integer ====

32 bit signed integer.

<vip>integer</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|quot/2->}}, and {{lang2|Built-in entities|Operators|rem/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>-2147483648</vp> to <vp>2147483647</vp>.

The syntax for the <vp>integer</vp> literal is determined by the <vpbnf><Integer></vpbnf> rule:

<vipbnf><Integer> :
<Add_operation>-opt 0o <Oct_number>
<Add_operation>-opt <Dec_number>
<Add_operation>-opt 0x <Hex_number>
<Add_operation> :
+
-
<Oct_number> :
<Oct_digit>-list
<Oct_digit> : one of
0 1 2 3 4 5 6 7
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
<Oct_digit> 8 9
<Hex_number> :
<Hex_digit>-list
<Hex_digit> : one of
<Dec_digit> a b c d e f A B C D E F</vipbnf>

==== integer64 ====

64 bit signed integer.

<vip>integer64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>-2^63 = -9223372036854775808</vp> to <vp>2^63-1 = 9223372036854775807</vp>.

The syntax for <vp>integer64</vp> literal is the same as <vpbnf><Integer></vpbnf> rule.

The set of operations for <vp>integer64</vp> is similar to the one for <vpbnf><Integer></vpbnf>.

==== integerNative ====

Signed integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>integerNative</vip>

==== unsigned ====

32 bit unsigned integer.

<vip>unsigned</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|rem/2->}}, and {{lang2|Built-in entities|Operators|quot/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>0</vp> to <vp>4294967295</vp>.

The syntax for <vp>unsigned</vp> number images is the same as for <vp>integer</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned</vp> number.

==== unsigned64 ====

64 bit unsigned integer.

<vip>unsigned64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>0</vp> to <vp>2^64-1 = 18,446,744,073,709,551,615</vp>.

The syntax for <vp>unsigned64</vp> number images is the same as for <vp>integer64</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned64</vp> number.

The set of operations for <vp>unsigned64</vp> is similar to the one for <vpbnf><Unsigned></vpbnf>.

==== unsignedNative ====

Unsigned integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>unsignedNative</vip>

==== real ====

Float-pointing number.

<vip>real</vip>

Values of this domain occupy 8 bytes. This numerical real domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations are applied to values of <vp>real</vp> domain.

The permitted number range is <vp>-1.7e+308</vp> to <vp>1.7e+308</vp>. Values from integral domains are automatically converted to real numbers when necessary.

The syntax for the floating-point number literal is determined by the <vpbnf><Real></vpbnf> rule:

<vipbnf><Real> :
<Add_operation>-opt <Fraction> <Exponent>-opt
<Fraction> :
<Dec_number> <Fractional_part>-opt
<Fractional_part> :
. <Dec_number>
<Exponent> :
<Exp> <Add_operation>-opt <Dec_number>
<Exp> :
e
E
<Add_operation> :
+
-
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
0 1 2 3 4 5 6 7 8 9</vipbnf>

==== real32 ====

Float-pointing number.

<vip>real32</vip>

Values of this domain occupy 4 bytes. This numerical <vp>real32</vp> domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations can be applied to values of <vp>real32</vp> domain.

The permitted number range is <vp>-3.4e+38</vp> to <vp>3.4e+38</vp>.

The syntax of real32 literals is the same as <vp>real</vp> lietrals.

==== pointer ====

A pointer to a memory address.

<vip>pointer</vip>

A pointer directly corresponds to memory addresses. Only the equality operation can be applied to the values of this domain. There is a built-in '''null''' constant for this type

==== handle ====

A handle is used for Windows API function call. Values of this domain has the same size as a pointer (i.e. 4 on 32bit platfor and 8 on 64bit platform).

There are no operations for this domain and cannot be converted (except uncheckedConvert) to/from other domains.

There is a built-in [[#nullHandle|nullHandle]] and [[#invalidHandle|invalidHandle]] constant for this type

==== boolean ====

Boolean values.

<vip>boolean</vip>

This domain is introduced for the user convenience only. It is treated as usual compound domain with the following definition:

<vip>domains
boolean = false(); true().</vip>

==== factDB ====

Descriptors of named internal databases.

<vip>factDB</vip>

This domain has the following hidden meta-declaration:

<vip>domains
factDB = struct @factdb( named_internal_database_domain, object ).</vip>

All user-defined names of facts sections are the constants of this domain. The compiler automatically builds the corresponding compound terms from such constants whenever it's in need. At the runtime the 1st field of this structure contains the address of the corresponding domain descriptor and the 2nd field contains either zero (for class facts sections) or pointer to an object (i.e. <vp>This</vp>, for object facts sections).
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Domains}}</noinclude>

Language Reference/Built-in entities/Domains

2020-12-19T16:08:27Z

Joachim Tilsted Kristensen: /* compareResult */

{|{{prettytable}}
|-
|[[#any|any]]
|Universal term type.
|-
|[[#char|char]]
|Wide (two-bytes) character.
|-
|[[#string|string]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#string8|string8]]
|Zero-terminated sequence of ASCII (one-byte) characters.
|-
|[[#symbol|symbol]]
|Wide zero-terminated sequence of wide characters.
|-
|[[#binary|binary]]
|Sequence of bytes.
|-
|[[#binaryNonAtomic|binaryNonAtomic]]
|Sequence of bytes.
|-
|[[#integer|integer]]
|32 bit signed integer.
|-
|[[#integer64|integer64]]
|64 bit signed integer.
|-
|[[#integerNative|integerNative]]
|Signed integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#unsigned|unsigned]]
|32 bit unsigned integer.
|-
|[[#unsigned64|unsigned64]]
|64 bit unsigned integer.
|-
|[[#unsignedNative|unsignedNative]]
|Unsigned integer with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).
|-
|[[#real|real]]
|Float-pointing number.
|-
|[[#real32|real32]]
|Float-pointing number.
|-
|[[#pointer|pointer]]
|pointer to a memory address.
|-
|[[#handle|handle]]
|a handle (e.g. native file and windows handles).
|-
|[[#boolean|boolean]]
|Boolean values.
|-
|[[#factDB|factDB]]
|Descriptors of named internal databases.
|-
|[[#compareResult|compareResult]]
|Values of comparison result.
|}

==== any ====

Universal term type.

<vip>any</vip>

The values of this domain are any terms. Such a value contains the reference to the term type library and a term itself.

==== char ====

Wide character.

<vip>char</vip>

The values of this domain are UNICODE characters. Implemented as 2 unsigned bytes.

Only assignment and comparison (in the lexicographical sense) operations are applied to the values of this domain. The image of a character has the following syntax:

<vipbnf><Char_image> :
' Char_value '
<Char_value> :
<Letter>
<Digit>
<Graphical_symbol>
\ <Escape_seq>
<Escape_seq>:
t
n
r
\
'
"
u <HHHH></vipbnf>

In the syntax above <vpbnf><HHHH></vpbnf> correspond to 4 hexadecimal digits. Also, the backslash symbol and the single quote can be represented by an escape-sequence only.

==== compareResult ====

A built-in domain that represents the result of a comparison. For instance, the built-in procedure {{lang2|Built-in entities|compare|compare/2->}} has a "compareResult" as its result.
<vip>domains
compareResult = less; equal; greater.
</vip>

==== string ====

Wide zero terminated sequence of wide characters.

<vip>string</vip>

A string is a sequence of UNICODE characters. It's implemented as a pointer to the wide zero-terminated array of wide characters. Only assignment and comparison (in the lexicographical sense) operations are applied to values of this domain.

In source code a string literal can be specified as a set of sequences of characters surrounded by the double quotes.

<vipbnf><StringLiteral>:
<StringLiteralPart>-list</vipbnf>

<vipbnf><StringLiteralPart> :
@" AnyCharacter-list-opt "
" CharacterValue-list-opt "</vipbnf>

A string literal consists of one or more <vpbnf><StringLiteralPart></vpbnf>'s, which are concatenated. <vpbnf><StringLiteralPart></vpbnf>'s starting with <vp>@</vp> does not use escape sequences, whereas <vpbnf><StringLiteralPart></vpbnf>'s without <vp>@</vp> uses the following escape sequences:

*<vp>\\</vp> representing <vp>\</vp>
*<vp>\t</vp> representing Tab-character
*<vp>\n</vp> representing newline-character
*<vp>\r</vp> representing carriage return
*<vp>\'</vp> representing single quote
*<vp>\"</vp> representing double quote
*<vp>\u</vp> followed by exactly four <vpbnf><HexadecimalDigit></vpbnf>'s representing the Unicode character corresponding to the digits.

The double quotes in the string can be represented by the escape-sequence only (the single quote can be represented both with an escape-sequence and a graphical symbol).

==== string8 ====

A term of the built-in <vp>string8</vp> domain is a sequence of ASCII (one-byte) characters. It is implemented as a pointer to the zero terminated array of ASCII characters. Only assignment and comparison for equality (in the lexicographical sense) operations are applied to the values of this domain. Currently no literals are allowed for this domain.

==== symbol ====

Wide zero terminated sequence of wide characters.

<vip>symbol</vip>

Similar to a string, a symbol is also a sequence of the UNICODE characters. It's implemented as a pointer to an entry in a symbol table that contains strings. The operations that can be applied to symbols are the same as for strings.

The image of a symbol is represented with a ''<string_literal>'' (any string surrounded by the double quotes).

Symbols and strings are largely interchangeable but they are stored differently. Symbols are kept in a look-up table and their addresses, rather than the symbols themselves, are stored to represent objects. This means that symbols can be matched very quickly and, if a symbol occurs repeatedly in a program, it can be stored very compactly. Strings are not kept in a look-up table. Visual Prolog examines strings character-by-character whenever they are to be matched.

==== binary ====

Sequence of N bytes.

<vip>binary</vip>

Values of this domain are used for holding binary data. A binary value is implemented as a pointer to the sequence of bytes that represents the contents of a binary term.

The length of a binary term is situated in the '''4 bytes''' immediately preceding this sequence of bytes. The 4 bytes contains:

<vip>TotalNumberOfBytesOccupiedByBinary = ByteLen + 4 </vip>

where <vp>ByteLen</vp> - is the length of the binary term and 4 is number of bytes occupied by size field.

Only assignment and comparison operations are applied to values of '''binary domain'''.

Two binary terms are compared in the following way:

*If they are of different sizes, the bigger is considered larger.
*Otherwise, they are compared byte by byte, as unsigned values. Comparison stops when two differing bytes are found and the result of their comparison is the result of the comparison of the binary terms. Two binary terms are equal if they have the same sizes and all bytes are equal.

The text syntax for binary images is determined by the <vpbnf><Binary></vpbnf> rules:

<vipbnf><Binary> :
$ [ <Byte_value>-comma-sep-list-opt ]
<Byte_value> :
<Expression></vipbnf>

Each ''expression'' should be calculate on compiling time and its value should be in the range from <vp>0</vp> to <vp>255</vp>.

==== binaryNonAtomic ====

Sequence of N bytes.

<vip>binaryNonAtomic</vip>

Same as [[#binary|binary]], but can contain pointers because it is scanned by the garbage collector.

==== integer ====

32 bit signed integer.

<vip>integer</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|quot/2->}}, and {{lang2|Built-in entities|Operators|rem/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>-2147483648</vp> to <vp>2147483647</vp>.

The syntax for the <vp>integer</vp> literal is determined by the <vpbnf><Integer></vpbnf> rule:

<vipbnf><Integer> :
<Add_operation>-opt 0o <Oct_number>
<Add_operation>-opt <Dec_number>
<Add_operation>-opt 0x <Hex_number>
<Add_operation> :
+
-
<Oct_number> :
<Oct_digit>-list
<Oct_digit> : one of
0 1 2 3 4 5 6 7
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
<Oct_digit> 8 9
<Hex_number> :
<Hex_digit>-list
<Hex_digit> : one of
<Dec_digit> a b c d e f A B C D E F</vipbnf>

==== integer64 ====

64 bit signed integer.

<vip>integer64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>-2^63 = -9223372036854775808</vp> to <vp>2^63-1 = 9223372036854775807</vp>.

The syntax for <vp>integer64</vp> literal is the same as <vpbnf><Integer></vpbnf> rule.

The set of operations for <vp>integer64</vp> is similar to the one for <vpbnf><Integer></vpbnf>.

==== integerNative ====

Signed integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>integerNative</vip>

==== unsigned ====

32 bit unsigned integer.

<vip>unsigned</vip>

Values of this domain occupy 4 bytes. Arithmetic operations (<vp>+</vp>, <vp>-</vp>, <vp>/</vp>, <vp>*</vp>, <vp>^</vp>), comparison, assignment, {{lang2|Built-in entities|Operators|div/2->}}, {{lang2|Built-in entities|Operators|mod/2->}}, {{lang2|Built-in entities|Operators|rem/2->}}, and {{lang2|Built-in entities|Operators|quot/2->}} operations are applied to values of this domain.

The permitted number range is from <vp>0</vp> to <vp>4294967295</vp>.

The syntax for <vp>unsigned</vp> number images is the same as for <vp>integer</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned</vp> number.

==== unsigned64 ====

64 bit unsigned integer.

<vip>unsigned64</vip>

Values of this domain occupy 8 bytes.

The permitted number range is from <vp>0</vp> to <vp>2^64-1 = 18,446,744,073,709,551,615</vp>.

The syntax for <vp>unsigned64</vp> number images is the same as for <vp>integer64</vp> numbers. The usage of minus sign (<vpbnf><UnaryMinus></vpbnf>) is not allowed for an image of an <vp>unsigned64</vp> number.

The set of operations for <vp>unsigned64</vp> is similar to the one for <vpbnf><Unsigned></vpbnf>.

==== unsignedNative ====

Unsigned integer number with platform size (32 bit in a 32 bit program; 64 bit in a 64 bit program).

<vip>unsignedNative</vip>

==== real ====

Float-pointing number.

<vip>real</vip>

Values of this domain occupy 8 bytes. This numerical real domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations are applied to values of <vp>real</vp> domain.

The permitted number range is <vp>-1.7e+308</vp> to <vp>1.7e+308</vp>. Values from integral domains are automatically converted to real numbers when necessary.

The syntax for the floating-point number literal is determined by the <vpbnf><Real></vpbnf> rule:

<vipbnf><Real> :
<Add_operation>-opt <Fraction> <Exponent>-opt
<Fraction> :
<Dec_number> <Fractional_part>-opt
<Fractional_part> :
. <Dec_number>
<Exponent> :
<Exp> <Add_operation>-opt <Dec_number>
<Exp> :
e
E
<Add_operation> :
+
-
<Dec_number> :
<Dec_digit>-list
<Dec_digit> : one of
0 1 2 3 4 5 6 7 8 9</vipbnf>

==== real32 ====

Float-pointing number.

<vip>real32</vip>

Values of this domain occupy 4 bytes. This numerical <vp>real32</vp> domain is introduced for the user's convenience only. All arithmetic, comparison, and assignment operations can be applied to values of <vp>real32</vp> domain.

The permitted number range is <vp>-3.4e+38</vp> to <vp>3.4e+38</vp>.

The syntax of real32 literals is the same as <vp>real</vp> lietrals.

==== pointer ====

A pointer to a memory address.

<vip>pointer</vip>

A pointer directly corresponds to memory addresses. Only the equality operation can be applied to the values of this domain. There is a built-in '''null''' constant for this type

==== handle ====

A handle is used for Windows API function call. Values of this domain has the same size as a pointer (i.e. 4 on 32bit platfor and 8 on 64bit platform).

There are no operations for this domain and cannot be converted (except uncheckedConvert) to/from other domains.

There is a built-in [[#nullHandle|nullHandle]] and [[#invalidHandle|invalidHandle]] constant for this type

==== boolean ====

Boolean values.

<vip>boolean</vip>

This domain is introduced for the user convenience only. It is treated as usual compound domain with the following definition:

<vip>domains
boolean = false(); true().</vip>

==== factDB ====

Descriptors of named internal databases.

<vip>factDB</vip>

This domain has the following hidden meta-declaration:

<vip>domains
factDB = struct @factdb( named_internal_database_domain, object ).</vip>

All user-defined names of facts sections are the constants of this domain. The compiler automatically builds the corresponding compound terms from such constants whenever it's in need. At the runtime the 1st field of this structure contains the address of the corresponding domain descriptor and the 2nd field contains either zero (for class facts sections) or pointer to an object (i.e. <vp>This</vp>, for object facts sections).
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Domains}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T15:53:46Z

Joachim Tilsted Kristensen: /* invalidHandle */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A constant of type "pointer" with the value "0".

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A constant of type "handle" with the value "0".

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A constant of type "handle" with the invalid (for a handle) value "-1".

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T15:52:40Z

Joachim Tilsted Kristensen: /* nullHandle */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A constant of type "pointer" with the value "0".

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A constant of type "handle" with the value "0".

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A special constant of a handle type with the invalid (-1) value.

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T15:52:28Z

Joachim Tilsted Kristensen: /* null */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A constant of type "pointer" with the value "0".

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A constant of type "handle" with the value "zero".

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A special constant of a handle type with the invalid (-1) value.

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T15:50:44Z

Joachim Tilsted Kristensen: /* nullHandle */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A constant of type pointer with the value zero.

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A constant of type "handle" with the value "zero".

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A special constant of a handle type with the invalid (-1) value.

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T15:50:12Z

Joachim Tilsted Kristensen: /* null */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A constant of type pointer with the value zero.

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A special constant of a handle type with the value zero.

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A special constant of a handle type with the invalid (-1) value.

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T15:49:22Z

Joachim Tilsted Kristensen: /* null */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A constant of type <vip> pointer </vip> with the value zero.

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A special constant of a handle type with the value zero.

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A special constant of a handle type with the invalid (-1) value.

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T15:47:36Z

Joachim Tilsted Kristensen: /* null */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A constant of a pointer type with the value zero.

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A special constant of a handle type with the value zero.

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A special constant of a handle type with the invalid (-1) value.

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T15:46:33Z

Joachim Tilsted Kristensen: /* nullHandle */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A special constant of a pointer type with the value zero.

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A special constant of a handle type with the value zero.

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A special constant of a handle type with the invalid (-1) value.

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>

Language Reference/Built-in entities/Constants

2020-12-19T15:46:06Z

Joachim Tilsted Kristensen: /* null */

{|{{prettytable}}
|-
|[[#compilation_date|compilation_date]]
|Compilation date.
|-
|[[#compilation_time|compilation_time]]
|Compilation time.
|-
|[[#compiler_buildDate|compiler_buildDate]]
|Build date of a compiler.
|-
|[[#compiler_version|compiler_version]]
|A compiler version.
|-
|[[#maxFloatDigits|maxFloatDigits]]
|Defines the maximal value of "digits", which is supported by the compiler.
|-
|[[#null|null]]
|The default NULL pointer.
|-
|[[#nullHandle|nullHandle]]
|A special constant of a handle type with the zero value.
|-
|[[#invalidHandle|invalidHandle]]
|A special constant of a handle type with the invalid (-1) value.
|-
|[[#platform_bits|platform_bits]]
|Defines the digital capacity of compilation platform.
|-
|[[#platform_name|platform_name]]
|Defines the target platform name.
|}

==== compilation_date ====

Compilation date. Here ''YYYY'' means the number of a year, ''MM'' means a month number, and ''DD'' means a day number.

<vip>compilation_date : string = "YYYY-MM-DD".</vip>

==== compilation_time ====

Compilation time. Here ''HH'' means hours, ''MM'' means minutes, and ''SS ''means seconds.

<vip>compilation_time : string = "HH:MM:SS".</vip>

==== compiler_buildDate ====

Build date of the compiler.

<vip>compiler_buildDate : string = "YYYY-MM-DD HH:MM".</vip>

==== compiler_version ====

A compiler version. This value depends upon the compiler version.

<vip>compiler_version = 6003.</vip>

==== maxFloatDigits ====

Defines the maximal value of "digits", which is supported by the compiler.

<vip>maxFloatDigits = 16.</vip>

==== null ====

A special constant of a pointer type with the value zero.

<vip>null : pointer = uncheckedConvert(pointer, 0).</vip>

==== nullHandle ====

A special constant of a handle type with the zero value.

<vip>nullHandle : handle = uncheckedConvert(handle, 0).</vip>

==== invalidHandle ====

A special constant of a handle type with the invalid (-1) value.

<vip>invalidHandle : handle = uncheckedConvert(handle, -1).</vip>

==== platform_bits ====

Defines the digital capacity of compilation platform.

<vip>platform_bits = 32.
or
platform_bits = 64.</vip>

==== platform_name ====

Defines the target platform name.

<vip>platform_name : string = "Windows 32bits".
or
platform_name : string = "Windows 64bits".</vip>
<noinclude>{{LanguageReferenceSubarticle|Built-in entities/Constants}}</noinclude>