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

Fundamental Prolog Part 1

2011-02-24T11:56:52Z

Elizabeth Safro: /* PIE: Prolog Inference Engine */

{{FundamentalPrologNavbar}}

In this '''Prolog tutorial''' you will learn about the very fundamental ideas of Prolog language programming.

Visual Prolog is object oriented, strictly typed and mode checked.
You will of course have to master all this to write Visual Prolog programs.
But in this tutorial we will focus on the ''core'' of the code, i.e. the Prolog code when disregarding classes, types and modes.

For this purpose we will use the PIE example that is included in the Visual Prolog distribution.

PIE is a "classical" Prolog interpreter, by using this you can learn and experiment with Prolog without at all being concerned with classes, types, etc.

== Horn Clause Logic ==

Visual Prolog and other Prolog language dialects are based on Horn Clause logic.
Horn Clause logic is a formal system for reasoning about things and the way they relate to each other.

In natural language I can express a statement like:

<pre>John is the father of Bill.</pre>

Here I have two "things": John and Bill, and a "relation" between these, namely that one is the father of the other.
In Horn Clause Logic I can formalize this statement in the following way:

<vip>father("Bill", "John").</vip>

father is a predicate/relation taking two arguments, where the second is the father of the first.

'''Notice''' that '''''I '''''have chosen that the '''second''' person should be the father of the '''first'''.
I might as well have chosen it the other way around: The order of the arguments is the choice of the "designer" of the formalization.
However, once you have chosen, you must be consistent.
So in '''my''' formalization the father must '''always''' be the second person.

I have chosen to represent the persons by their names (which are string literals).
In a more complex world this would not be sufficient because many people have same name.
But for now we will be content with this simple formalization.

With formalizations like the one above I can state any kind of family relation between any persons.
But for this to become really interesting I will also have to formalize '''''rules''''' like this:

<vip>X is the grandfather of Z, if X is the father of Y and Y is the father of Z</vip>

where <vp>X</vp>, <vp>Y</vp> and <vp>Z</vp> are persons.
In Horn Clause Logic I can formalize this rule like this:

<vip>grandFather(Person, GrandFather) :-
father(Person, Father), father(Father, GrandFather).</vip>

I have chosen to use '''''variable''''' names that help understanding better than <vp>X</vp>, <vp>Y</vp> and <vp>Z</vp>.
I have also introduced a predicate for the grandfather relation.
Again I have chosen that the grandfather should be the second argument.
It is wise to be consistent like that, i.e. that the arguments of the different predicates follow some common principle.
When reading rules you should interpret :- as '''''if''''' and the comma that separates the relations as '''''and'''''.

Statements like "John is the father of Bill" are called '''''facts''''', while statements like "<vp>X</vp> is the grandfather of <vp>Z</vp>, if <vp>X</vp> is the father of <vp>Y</vp> and <vp>Y</vp> is the father of <vp>Z</vp>" are called '''''rules'''''.

With facts and rules we are ready to formulate theories.
A '''''theory''''' is a collection of facts and rules.
Let me state a little theory:

<vip>father("Bill", "John").
father("Pam", "Bill").

grandFather(Person, GrandFather) :-
father(Person, Father),
father(Father, GrandFather).</vip>

The purpose of the theory is to answer questions like these:

<vip>Is John the father of Sue?
Who is the father of Pam?
Is John the grandfather of Pam?
...</vip>

Such questions are called goals.
And they can be formalized like this (respectively):

<vip>?- father("Sue", "John").
?- father("Pam", X).
?- grandFather("Pam", "John").</vip>

Such questions are called '''''goal clauses''''' or simply '''''goals'''''.
Together ''facts'', ''rules'' and ''goals'' are called Horn clauses, hence the name Horn Clause Logic.

Some goals like the first and last are answered with a simple ''yes'' or ''no''.
For other goals like the second we seek a '''''solution''''', like <vp>X = "Bill"</vp>.

Some goals may even have many solutions.
For example:

<vip>?- father(X, Y).</vip>

has two solutions:

<vip>X = "Bill", Y = "John".
X = "Pam", Y = "Bill".</vip>

A Prolog program is a theory and a goal.
When the program starts it tries to find a solution to the goal in the theory.

== PIE: Prolog Inference Engine ==

Now we will try the little example above in PIE, the Prolog Inference Engine that comes with Visual Prolog.

Before we start you should install and build the PIE example.

*Select "Install Examples" in the Windows start menu ('''Start -> Visual Prolog -> Install Examples''').
*Open the PIE project in the IDE and '''run''' the program, as it is described in the [[Environment Overview]].

When the program starts it will look like this:

[[Image:Fundamental_Prolog_1_PIE.png|Prolog Inference Engine]]

Select '''File -> New''' and enter the father and grandFather clauses above:

[[Image:Fundamental_Prolog_1_GrandFather.png|Grand Father example]]

While the editor window is active choose '''Engine -> Reconsult'''.
This will load the file into the engine.
In the '''''Dialog''''' window you should receive a message like this:

<pre>Reconsulted from: ....\pie\Exe\FILE4.PRO</pre>

Reconsult loads whatever is in the editor, '''''without''''' saving the contents to the file, if you want to save the contents use '''File -> Save'''.

'''File -> Consult''' will load the disc contents of the file regardless of whether the file is opened for editing or not.

Once you have "consulted" the theory, you can use it to answer goals.

On a blank line in the '''''Dialog''''' window type a goal (without the '''?-''' in front).

For example:

[[Image:Fundamental_Prolog_1_goal1.png|Typing a goal]]

When the caret is placed at the end of the line, press the '''Enter''' key on your keyboard.
PIE will now consider the text from the beginning of the line to the caret as a goal to execute.
You should see a result like this:

[[Image:Fundamental_Prolog_1_goal2.png|Goal result]]

== Extending the family theory ==

It is straight forward to extend the family theory above with predicates like mother and grandMother.
You should try that yourself.
You should also add more persons.
I suggest that you use persons from your own family, because that makes it lot easier to validate, whether some person is indeed the grandMother of some other person, etc.

Given mother and father we can also define a parent predicate.
You are a parent if you are a mother; you are also a parent if you are a father.
Therefore we can define parent using two clauses like this:

<vip>parent(Person, Parent) :- mother(Person, Parent).
parent(Person, Parent) :- father(Person, Parent).</vip>

The first rule reads (recall that the second argument corresponds to the predicate name):

Parent is the parent of Person, if Parent is the mother of Person

You can also define the parent relation using semicolon ";" which means or, like this:

<vip>parent(Person, Parent) :-
mother(Person, Parent);
father(Person, Parent).</vip>

This rule reads:

Parent is the parent of Person, if Parent is the mother of Person '''''or''''' Parent is the father of Person

I will however advise you to use semicolon as little as possible (or actually not at all).
There are several reasons for this:

*The typographical difference "," and ";" is very small, but the semantic difference is rather big. ";" is often a source of confusion, since it is easily misinterpreted as ",", especially when it is on the end of a long line.
*Visual Prolog only allows to use semicolon on the outermost level (PIE will allow arbitrarily deep nesting).

Try creating a sibling predicate! Did that give problems?

You might find that siblings are found '''twice'''.
At least if you say: Two persons are siblings if they have same mother, two persons are also siblings if they have same father.
I.e. if you have rules like this:

<vip>sibling(Person, Sibling) :- mother(Person, Mother), mother(Sibling, Mother).
sibling(Person, Sibling) :- father(Person, Father), father(Sibling, Father).</vip>

The first rule reads:

Sibling is the sibling of Person, if Mother is the mother of Person '''''and''''' Mother is the mother of Sibling

The reason that you receive siblings twice is that most siblings both have same father and mother, and therefore they fulfill both requirements above.
And therefore they are found twice.

We shall not deal with this problem now; currently we will just accept that some rules give too many results.

A fullBlodedSibling predicate does not have the same problem, because it will require that both the father and the mother are the same:

<vip>fullBlodedSibling(Person, Sibling) :-
mother(Person, Mother),
mother(Sibling, Mother),
father(Person, Father),
father(Sibling, Father).</vip>

== Prolog is a Programming Language ==

From the description so far you might think that Prolog is an expert system, rather than a programming language.
And indeed Prolog can be used as an expert system, but it is designed to be a programming language.

We miss two important ingredients to turn Horn Clause logic into a programming language:

*Rigid search order/program control
*Side effects

== Program Control ==

When you try to find a solution to a goal like:

<vip>?- father(X, Y).</vip>

You can do it in many ways.
For example, you might just consider at the second fact in the theory and then you have a solution.

But Prolog does not use a "random" search strategy, instead it always use the same strategy.
The system maintains a '''''current goal''''', which is always solved from '''left to right'''.

I.e. if the current goal is:

<vip>?- grandFather(X, Y), mother(Y, Z).</vip>

Then the system will always try to solve the sub-goal grandFather(X, Y) before it solves mother(Y, Z), if the first (i.e. left-most) sub-goal cannot be solved then there is no solution to the overall problem and then the second sub-goal is not tried at all.

When solving a particular sub-goal, the facts and rules are always tried from '''top to bottom'''.

When a sub-goal is solved by using a rule, the right hand side replaces the sub-goal in the current goal.

I.e. if the current goal is:

<vip>?- grandFather(X, Y), mother(Y, Z).</vip>

And we are using the rule

<vip>grandFather(Person, GrandFather) :- father(Person, Father), father(Father, GrandFather).</vip>

to solve the first sub-goal, then the resulting current goal will be:

<vip>?- father(X, Father), father(Father, Y), mother(Y, Z).</vip>

Notice that some variables in the rule have been replaced by variables from the sub-goal.
I will explain this in details later.

Given this evaluation strategy you can interpret clauses much more '''''procedural'''''. Consider this rule:

<vip>grandFather(Person, GrandFather) :- father(Person, Father), father(Father, GrandFather).</vip>

Given the strict evaluation we can read this rule like this:

To solve grandFather(Person, GrandFather) '''first''' solve father(Person, Father) '''and then '''solve father(Father, GrandFather).

Or even like this:

When grandFather(Person, GrandFather) is '''''called''''', first '''''call''''' father(Person, Father) and then '''''call''''' father(Father, GrandFather).

With this '''''procedural '''''reading you can see that predicates correspond to procedures/subroutines in other languages.
The main difference is that a Prolog predicate can return several solutions to a single invocation or even '''''fail'''''.
This will be discussed in details in the next sections.

== Failing ==

A predicate invocation might not have any solution in the theory.
For example calling parent("Hans", X) has no solution as there are no parent facts or rules that applies to "Hans".
We say that the predicate call '''''fails'''''.
If the goal fails then there is simply no solution to the goal in the theory.
The next section will explain how failing is treated in the general case, i.e. when it is not the goal that fails.

== Backtracking ==

In the procedural interpretation of a Prolog program "or" is treated in a rather special way.
Consider the clause

<vip>parent(Person, Parent) :-
mother(Person, Parent);
father(Person, Parent).</vip>

In the logical reading we interpreted this clause as:

Parent
is the parent of Person '''if'''
Parent is the mother of
Person '''or'''
Parent is the father of Person.

The "or" introduces two possible solutions to an invocation of the parent predicate.
Prolog handles such multiple choices by first trying one choice and later (if necessary) '''''backtracking''''' to the next alternative choice, etc.

During the execution of a program a lot of alternative choices (known as '''''backtrack points''''') might exist from earlier predicate calls.
If some predicate call fails, then we will backtrack to the last backtrack point we met and try the alternative solution instead.
If no further backtrack points exists then the overall goal has failed, meaning that there was no solution to it.

With this in mind we can interpret the clause above like this:

When parent(Person, Parent) is called first record a backtrack point to the second alternative solution (i.e. to the call to father(Person, Parent)) and then call mother(Person, Parent)

A predicate that has several classes behave in a similar fashion.
Consider the clauses:

<vip>father("Bill", "John").
father("Pam", "Bill").</vip>

When father is invoked we first record a backtrack point to the second clause, and then try the first clause.

If there are three or more choices we still only create one backtrack point, but that backtrack point will start by creating another backtrack point.
Consider the clauses:

<vip>father("Bill", "John").
father("Pam", "Bill").
father("Jack", "Bill").</vip>

When father is invoked, we first record a backtrack point.
And then we try the first clause.
The backtrack point we create points to some code, which will itself create a backtrack point (namely to the third clause) and then try the second clause.
Thus all choice points have only two choices, but one choice might itself involve a choice.

'''Example''' To illustrate how programs are executed I will go through an example in details.
Consider these clauses:

<vip>mother("Bill", "Lisa").

father("Bill", "John").
father("Pam", "Bill").
father("Jack", "Bill").

parent(Person, Parent) :-
mother(Person, Parent);
father(Person, Parent).</vip>

And then consider this goal:

<vip>?- father(AA, BB), parent(BB, CC).</vip>

This goal states that we want to find three persons AA, BB and CC, such that BB is the father of AA and CC is a parent of BB.

As mentioned we always solve the goals from left to right, so first we call the father predicate.
When executing the father predicate we first create a backtrack point to the second clause, and then use the first clause.

Using the first clause we find that AA is "Bill" and BB is "John".
So we now effectively have the goal:

<vip>?- parent("John", CC).</vip>

So we call parent, which gives the following goal:

<vip>?- mother("John", CC); father("John", CC).</vip>

You will notice that the variables in the clause have been replaced with the actual parameters of the call (exactly like when you call subroutines in other languages).

The current goal is an "or" goal, so we create a backtrack point to the second alternative and pursuit the first.
We now have two active backtrack points, one to the second alternative in the parent clause, and one to the second clause in the father predicate.

After the creation of this backtrack point we are left with the following goal:

<vip>?- mother("John", CC).</vip>

So we call the mother predicate.
The mother predicate fails when the first argument is "John" (because it has no clauses that match this value in the first argument).

In case of failure we backtrack to the last backtrack point we created.
So we will now pursuit the goal:

<vip>?- father("John", CC).</vip>

When calling father this time, we will again first create a backtrack point to the second father clause.

Recall that we also still have a backtrack point to the second clause of the father predicate, which corresponds to the first call in the original goal.

We now try to use the first father clause on the goal, but that fails, because the first arguments do not match (i.e. "John" does not match "Bill").

Therefore we backtrack to the second clause, but before we use this clause we create a backtrack point to the third clause.

The second clause also fails, since "John" does not match "Pam", so we backtrack to the third clause.
This also fails, since "John" does not match "Jack".

Now we must backtrack all the way back to the first father call in the original goal; here we created a backtrack point to the second father clause.

Using the second clause we find that AA is "Pam" and BB is "Bill".
So we now effectively have the goal:

<vip>?- parent("Bill", CC).</vip>

When calling parent we now get:

<vip>?- mother("Bill", CC); father("Bill", CC).</vip>

Again we create a backtrack point to the second alternative and pursuit the first:

<vip>?- mother("Bill", CC).</vip>

This goal succeeds with CC being "Lisa".
So now we have found a solution to the goal:

<vip>AA = "Pam", BB = "Bill", CC = "Lisa".</vip>

When trying to find additional solutions we backtrack to the last backtrack point, which was the second alternative in the parent predicate:

<vip>?- father("Bill", CC).</vip>

This goal will also succeed with CC being "John".
So now we have found one more solution to the goal:

<vip>AA = "Pam", BB = "Bill", CC = "John".</vip>

If we try to find more solutions we will find:

<vip>AA = "Jack", BB = "Bill", CC = "John".
AA = "Jack", BB = "Bill", CC = "Lisa".</vip>

After that we will experience that everything will eventually fail leaving no more backtrack points.
So all in all there are four solutions to the goal.

== Improving the Family Theory ==

If you continue to work with the family relation above, you will probably find out that you have problems with relations like ''brother'' and ''sister'', because it is rather difficult to determine the sex of a person (unless the person is a father or mother).

The problem is that we have chosen a bad way to formalize our theory.

The reason that we arrived at this theory is because we started by considering the '''''relations''''' between the entities.
If we instead first focus on the '''''entities''''', then the result will naturally become different.

Our main entities are persons.
Persons have a name (in this simple context will still assume that the name identifies the person, in a real scale program this would not be true).
Persons also have a sex.
Persons have many other properties, but none of them have any interest in our context.

Therefore we define a person predicate, like this:

<vip>person("Bill", "male").
person("John", "male").
person("Pam", "female").</vip>

The first argument of the person predicate is the name and the second is the sex.

Instead of using mother and father as facts, I will choose to have parent as facts and mother and father as rules:

<vip>parent("Bill", "John").
parent("Pam", "Bill").

father(Person, Father) :- parent(Person, Father), person(Father, "male").</vip>

Notice that when father is a "derived" relation like this, it is impossible to state ''female'' fathers.
So this theory also has a built-in consistency on this point, which did not exist in the other formulation.

== Recursion ==

Most family relations are easy to construct given the principles above.
But when it comes to "infinite" relations like ''ancestor'' we need something more.
If we follow the principle above, we should define ancestor like this:

<vip>ancestor(Person, Ancestor) :- parent(Person, Ancestor).
ancestor(Person, Ancestor) :- parent(Person, P1), parent(P1, Ancestor).
ancestor(Person, Ancestor) :- parent(Person, P1), parent(P1, P2), parent(P2, Ancestor).
...</vip>

The main problem is that this line of clauses never ends.
The way to overcome this problem is to use a recursive definition, i.e. a definition that is defined in terms of itself. like this:

<vip>ancestor(Person, Ancestor) :- parent(Person, Ancestor).
ancestor(Person, Ancestor) :- parent(Person, P1), ancestor(P1, Ancestor).</vip>

This declaration states that a parent is an ancestor, and that an ancestor to a parent is also an ancestor.

If you are not already familiar with recursion you might find it tricky (in several senses).
Recursion is however fundamental to Prolog programming.
You will use it again and again, so eventually you will find it completely natural.

Let us try to execute an ancestor goal:

<vip>?- ancestor("Pam", AA).</vip>

We create a backtrack point to the second ancestor clause, and then we use the first, finding the new goal:

<vip>?- parent("Pam", AA).</vip>

This succeeds with the solution:

<vip>AA = "Bill".</vip>

Then we try to find another solution by using our backtrack point to the second ancestor clause.
This gives the new
goal:

<vip>?- parent("Pam", P1), ancestor(P1, AA).</vip>

Again "Bill" is the
parent of "Pam",
so we find P1=
"Bill", and then we have the goal:

<vip>?- ancestor("Bill", AA).</vip>

To solve this goal we first create a backtrack point to the second ancestor clause and then we use the first one.
This gives the following goal:

<vip>?- parent("Bill", AA).</vip>

This goal has the gives the solution:

<vip>AA = "John".</vip>

So now we have found two ancestors of "Pam":
* "Bill" and
* "John".

If we use the backtrack point to the second ancestor clause we get the following goal:

<vip>?- parent("Bill", P1), ancestor(P1, AA).</vip>

Here we will again find that
"John" is the parent of
"Bill", and thus that
P1 is
"John".
This gives the goal:

<vip>?- ancestor("John", AA).</vip>

If you pursuit this goal you will find that it will not have any solution.
So all in all we can only find two ancestors of
"Pam".

Recursion is very powerful but it can also be a bit hard to control.
Two things are important to remember:

*the recursion must make progress
*the recursion must terminate

In the code above the first clause ensures that the recursion can terminate, because this clause is not recursive (i.e. it makes no calls to the predicate itself).

In the second clause (which is recursive) we have made sure, that we go one ancestor-step further back, before making the recursive call.
I.e. we have ensured that we make some progress in the problem.

== Side Effects ==

Besides a strict evaluation order Prolog also has side effects.
For example Prolog has a number of predefined predicates for reading and writing.

The following goal will write the found ancestors of "Pam":

<vip>?- ancestor("Pam", AA), write("Ancestor of Pam : ", AA), nl().</vip>

The ancestor call will find an ancestor of "Pam" in AA.

The write call will write the string literal "Ancestor of Pam : ", and then it will write the value of AA.

The nl call will shift to a new line in the output.

When running programs in PIE, PIE itself writes solutions, so the overall effect is that your output and PIE's own output will be mixed.
This might of course not be desirable.

A very simple way to avoid PIE's own output is to make sure that the goal has no solutions.
Consider the following goal:

<vip>?- ancestor("Pam", AA), write("Ancestor of Pam : ", AA), nl(), fail.</vip>

fail is a predefined call that always fails (i.e. it has no solutions).

The first three predicate calls have exactly the same effect as above: an ancestor is found (if such one exists, of course) and then it is written.
But then we call fail this will of course '' fail''. Therefore we must pursuit a backtrack point if we have any.

When pursuing this backtrack point, we will find another ancestor (if such one exists) and write that, and then we will fail again.
And so forth.

So, we will find and write all ancestors. and eventually there will be no more backtrack points, and then the complete goal will fail.

There are a few important points to notice here:

*The goal itself did not have a single solution, but nevertheless all the solutions we wanted was given as side effects.
*Side effects in failing computations are not undone.

These points are two sides of the same thing.
But they represent different level of optimism.
The first optimistically states some possibilities that you can use, while the second is more pessimistic and states that you should be aware about using side effects, because they are not undone even if the current goal does not lead to any solution.

Anybody, who learns Prolog, will sooner or later experience unexpected output coming from failing parts of the program.
Perhaps, this little advice can help you: Separate the "calculating" code from the code that performs input/output.

In our examples above all the stated predicate are "calculating" predicates.
They all calculate some family relation.
If you need to write out, for example, "parents", create a separate predicate for writing parents and let that predicate call the "calculating" parent predicate.

== Conclusion ==

In this tutorial we have looked at some of the basic features of Prolog.
You have seen '''''facts''''', '''''rules''''' and '''''goals'''''.
You learned about the '''''execution strategy '''''for Prolog including the notion of '''''failing''''' and '''''backtracking'''''.
You have also seen that backtracking can give '''''many results '''''to a single question.
And finally you have been introduced to '''''side effects'''''.

== See also ==

* [[Fundamental Prolog Part 2]]

==References==

[[Category:Tutorials]]

Video Tutorials about Visual Prolog

2010-11-26T11:54:36Z

Elizabeth Safro:

== Visual Prolog Video Tutorials Provided by PDC ==

* PDC [http://www.visual-prolog.com/video/HelloWorld/default.htm Hello World! Video Tutorial] covers basic IDE functionality
* PDC [http://www.visual-prolog.com/video/IntelliSpeed/default.htm IntelliSpeed Video Tutorial] demonstrates the context sensitive keyboard accelerator and browse system.
* PDC [http://www.visual-prolog.com/video/formdemo/default.htm FormDemo Video Tutorial] demonstrates how to create a form and link it to a menu item.

== Visual Prolog Video Tutorials Created by Visual Prolog Users==

If you have created a useful video on Visual Prolog, let Visual Prolog community know about it.

* Nestor Sanchez Espinobarros [http://www.youtube.com/watch?v=quHLpnyZTpU Instalacion Visual Prolog] on YouTube. (In Spanish)

[[Category:Tutorials]]

Visual Prolog 7.3 New Features

2010-11-12T13:33:08Z

Elizabeth Safro:

== Language ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify Operator ===

New operator == (must-unify)

=== Universal term type ===

<vp>any</vp> and the predicate <vp>toAny/1-></vp>

=== 64 bit preparation ===

Preparations for supporting 64bit systems: built-in types <vp>integerNative</vp> and <vp>unsignedNative</vp>

=== Foreign language interfacing ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is now possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

== Updates ==

=== Build 7301 ===

'''Visual Prolog 7.3, Build 7301''' fixes [http://kb.visual-prolog.com/fixes/fixes7300.htm#7301 several minor bugs].

The following new feature has been implemented:

* Built-in predicate <vp>toEllipsis : (any* Terms) -> ...</vp>
* The PFC '''treeControl''' has been extended with key down and drag-and-drop handling
* The set of examples for '''Personal Edition''' was extended
* The following GUI controls have been added to the Personal Edition: listViewControl, tabControl, and treeViewControl.

=== Build 7302 ===

'''Visual Prolog 7.3, Build 7302''' fixes [http://kb.visual-prolog.com/fixes/fixes7300.htm#7302 several minor bugs].

=== Build 7303 ===

'''Visual Prolog 7.3, Build 7303''' fixes [http://kb.visual-prolog.com/fixes/fixes7300.htm#7303 several minor bugs].

== See also ==
[http://kb.visual-prolog.com/fixes/fixes7300.htm Bugs Fixed in Visual Prolog 7.3]

[[Visual Prolog 7.3 Upgrade Notes]]

[[Category:Release Notes]]

Visual Prolog for Tyros

2010-09-15T17:31:42Z

Elizabeth Safro:

''Visual Prolog for Tyros'' is a comprehensive book written by ''Eduardo Costa''.

It is a good starting point to study Visual Prolog. And it might be used by teachers for education.

The latest edition of the book is "Visual Prolog 7.3 for Tyros".

The book includes a number of examples illustrating different features of Visual Prolog.

=== Contents ===

'''I Savoir-faire'''

# Introduction
# Forms
# Mouse events
# Less Figures
# Horn Clauses
# Console Applications
# Grammars
# Painting
# Data types
# How to solve it in Prolog
# Facts
# Classes and Objects
# Giuseppe Peano
# L-Systems
# Games
# Animation
# Text Editor
# Printing
# Tab forms and other goodies
# Bugs
# A Data Base Manager
# Books and articles

'''II Artificial Intelligence'''

# Search
# Neural Networks
# Alpha Beta Pruning

=== Download ===
;Visual Prolog 7.3
* [http://download.pdc.dk/vip/73/books/tyros/tyros73.pdf Visual Prolog 7.3 for Tyros] (September, 2010, PDF).
* [http://download.pdc.dk/vip/73/books/tyros/tyros73.zip Examples 7.3] (zip).

;Visual Prolog 7.2
* [http://download.pdc.dk/vip/72/books/tyros/tyros72.pdf Visual Prolog 7.2 for Tyros] (January, 2009, PDF).
* [http://download.pdc.dk/vip/72/books/tyros/tyros72.zip Examples 7.2] (zip).

;Visual Prolog 7.1
* [http://download.pdc.dk/vip/71/Costas-Tyros.pdf Visual Prolog 7.1 for Tyros] (PDF).
* [http://download.pdc.dk/vip/71/Costas-Tyros.zip Examples 7.1] (zip).

=== Translations ===

* [http://wikiru.visual-prolog.com/index.php?title=Visual_Prolog_for_Tyros Russian]
* [[Visual Prolog for Tyros in Chinese|Chinese]]

[[ru:Visual Prolog для чайников]]
[[Category:Tutorials]]

Visual Prolog for Tyros

2010-09-15T16:53:32Z

Elizabeth Safro:

''Visual Prolog for Tyros'' is a comprehensive book written by ''Eduardo Costa''.

It is a good starting point to study Visual Prolog. And it might be used by teachers for education.

The book includes a number of examples illustrating different features of Visual Prolog.

The latest edition of the book is "Visual Prolog 7.3 for Tyros".

=== Contents ===

'''I Savoir-faire'''

# Introduction
# Forms
# Mouse events
# Less Figures
# Horn Clauses
# Console Applications
# Grammars
# Painting
# Data types
# How to solve it in Prolog
# Facts
# Classes and Objects
# Giuseppe Peano
# L-Systems
# Games
# Animation
# Text Editor
# Printing
# Tab forms and other goodies
# Bugs
# A Data Base Manager
# Books and articles

'''II Artificial Intelligence'''

# Search
# Neural Networks
# Alpha Beta Pruning

=== Download ===
;Visual Prolog 7.3
* [http://download.pdc.dk/vip/73/books/tyros/tyros73.pdf Visual Prolog 7.3 for Tyros] (September, 2010, PDF).
* [http://download.pdc.dk/vip/73/books/tyros/tyros73.zip Examples 7.3] (zip).

;Visual Prolog 7.2
* [http://download.pdc.dk/vip/72/books/tyros/tyros72.pdf Visual Prolog 7.2 for Tyros] (January, 2009, PDF).
* [http://download.pdc.dk/vip/72/books/tyros/tyros72.zip Examples 7.2] (zip).

;Visual Prolog 7.1
* [http://download.pdc.dk/vip/71/Costas-Tyros.pdf Visual Prolog 7.1 for Tyros] (PDF).
* [http://download.pdc.dk/vip/71/Costas-Tyros.zip Examples 7.1] (zip).

=== Translations ===

* [http://wikiru.visual-prolog.com/index.php?title=Visual_Prolog_for_Tyros Russian]
* [[Visual Prolog for Tyros in Chinese|Chinese]]

[[ru:Visual Prolog для чайников]]
[[Category:Tutorials]]

Visual Prolog for Tyros

2010-09-10T10:09:17Z

Elizabeth Safro: /* Download */

''Visual Prolog for Tyros'' is a comprehensive book written by ''Eduardo Costa''.

It is a good starting point to study Visual Prolog. And it might be used by teachers for education.

The book includes a number of examples illustrating different features of Visual Prolog.

=== Contents ===

'''I Savoir-faire'''

# Introduction
# Forms
# Mouse events
# Less Figures
# Horn Clauses
# Console Applications
# Grammars
# Painting
# Data types
# How to solve it in Prolog
# Facts
# Classes and Objects
# Giuseppe Peano
# L-Systems
# Games
# Animation
# Text Editor
# Printing
# Tab forms and other goodies
# Bugs
# A Data Base Manager
# Books and articles

'''II Artificial Intelligence'''

<ol start="23">
<li>Search</li>
<li>Neural Networks</li>
<li>Alpha Beta Pruning</li>
</ol>

=== Download ===
;Visual Prolog 7.3
* [http://download.pdc.dk/vip/73/books/tyros/tyros73.pdf Visual Prolog 7.3 for Tyros] (September, 2010, PDF).
* [http://download.pdc.dk/vip/73/books/tyros/tyros73.zip Examples 7.3] (zip).

;Visual Prolog 7.2
* [http://download.pdc.dk/vip/72/books/tyros/tyros72.pdf Visual Prolog 7.2 for Tyros] (January, 2009, PDF).
* [http://download.pdc.dk/vip/72/books/tyros/tyros72.zip Examples 7.2] (zip).

;Visual Prolog 7.1
* [http://download.pdc.dk/vip/71/Costas-Tyros.pdf Visual Prolog 7.1 for Tyros] (PDF).
* [http://download.pdc.dk/vip/71/Costas-Tyros.zip Examples 7.1] (zip).

=== Translations ===

* [http://wikiru.visual-prolog.com/index.php?title=Visual_Prolog_for_Tyros Russian]
* [[Visual Prolog for Tyros in Chinese|Chinese]]

[[ru:Visual Prolog для чайников]]
[[Category:Tutorials]]

Frequently Asked Questions

2010-06-24T12:52:44Z

Elizabeth Safro: What project management software is used for Visual Prolog development?

{{FAQ
|Q=How to get started with Visual Prolog?
|A=Start by reading [[Getting Started]].
}}

{{FAQ
|Q=Which platforms does Visual Prolog support?
|A=Visual Prolog supports Windows 7/Vista/XP/2000.

There are no plans for supporting Linux or any Unix platforms.
}}

{{FAQ
|Q=What are the differences between Visual Prolog and traditional Prolog?
|A=The differences between traditional Prolog and Visual Prolog can be broadly divided into these categories:

#Program structure differences There are distinct, yet easy to understand differences between the structure used in traditional Prolog and that used in Visual Prolog. It essentially comprises of understanding how to mark out the declarations from the definitions, and to indicate the main Goal that the program has to seek using specific keywords.
#File considerations Visual Prolog gives various facilities to organize the structure of the program into different kinds of files.
#Scope access issues A Visual Prolog program can pick up functionality developed in other modules using a concept called scope identification.
#Object orientation A Visual Prolog program can be written as an object-oriented program, using classic object oriented features.
See [[Fundamental Visual Prolog]] tutorial for details.
}}

{{FAQ
|Q=Where can I find examples and demos?
|A=Visual Prolog examples and demos are available in several ways:

Visual Prolog distribution includes sample projects that can be installed from the Integrated Development Environment (IDE) with the help of the command Help | Install Examples.

This site contains examples provided by members of Visual Prolog Community.

Visual Prolog [[:Category:Tutorials|tutorials]] discuss examples that might be downloaded. You will be suggested to download source files while reading these tutorials.
For example, the tutorials [[Fundamental Prolog Part 1]], [[Fundamental Prolog Part 2]], and [[Fundamental Visual Prolog]] discuss a well-known prolog family example in details.
}}

{{FAQ
|Q=How do I make and use COM objects?
|A=Visual Prolog is COM compatible, the IDE can generate necessary wrap classes and interfaces based on a type library supplied with the COM object.
}}
{{FAQ
|Q=What project management software is used for Visual Prolog development?
|A=[http://www.agile-team.com/ Agile-TeamTM project management tool] is being used for Visual Prolog development during many years.
Usage of this project management software makes Visual Prolog especially safe and fast developing programming language, because it helps to manage projects, tasks, fix bugs and resolve various development issues, prioritize tasks, provide extensive support of users, etc.
}}
{{FAQ
|Q=Are there any plans for supporting Linux or any Unix platforms?
|A=There are no plans for supporting Linux or any Unix platforms.
}}
{{FAQ
|Q=Does the current version of Visual Prolog include the Help Maker from Visual Prolog 5.x?
|A=No. Visual Prolog 5.2 Help Maker provided creating Help systems in WinHelp format (.hlp) that is outdated now.

To create Help systems for Visual Prolog applications, please, use MS Help Workshop or third-party tools that create Help systems in MS HTML Help format (.chm) or other modern Help formats.
}}

{{FAQ
|Q=Is it possible to use a DLL, created by Visual Prolog, in a Microsoft.NET project?
|A=Yes. It is possible. Such DLL created by Visual Prolog should have predicates exported with stdcall calling convention. And VB.NET or C#.NET code should call it in the same manner as invocation of an API function.

You are welcome to download How to Use Visual Prolog DLL from .Net example that creates a Visual Prolog DLL and shows how a program, created by Visual Basic .NET, can call a predicate, exported by this DLL.
}}

{{FAQ
|Q=Can I use my registration in the Discussion Forum to have Registered Visual Prolog Personal Edition and vice versa?
|A=No. Registration in the Discussion Forum and registration of Visual Prolog Personal Edition are two different registrations.

To register your Personal Edition you need to use the '''WEB|Register''' menu item in the Integrated Development Environment (IDE).
}}

{{FAQ
|Q=Can I compile my Visual Prolog 5.x program in the current version of Visual Prolog?
|A=No, the current version of Visual Prolog is not backwards compatible with Visual Prolog 5.x. The syntax has been changed in certain respects, and all Visual Prolog code must be in classes. But Visual Prolog contains backwards-libraries that have almost identical interface and behavior.

Prolog Development Center has released the migration tool that can assist in migrating code from Visual Prolog 5.
Please see [[Getting Started]] for details.
}}
{{FAQ
|Q=Can I create a Sudoku solver with Visual Prolog?
|A=Yes,
Please see the following for details:
* [http://www.visual-prolog.com/vip/example/pdcExample/sudoku.htm Sudoku Puzzle - an Exercise in Constraint Programming and Visual Prolog 7] by Carsten Kehler Holst (Prolog Development Center);

* [http://www.visual-prolog.com/vip/example/userExample/sudoku_Cumming/sudoku_Cumming.htm Sudoku Example] by Stuart Cumming.
}}

[[Category:Basic Information]]

Visual Prolog 7.3 New Features

2010-06-22T09:39:04Z

Elizabeth Safro: /* Build 7302 */

== Language ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify Operator ===

New operator == (must-unify)

=== Universal term type ===

<vp>any</vp> and the predicate <vp>toAny/1-></vp>

=== 64 bit preparation ===

Preparations for supporting 64bit systems: built-in types <vp>integerNative</vp> and <vp>unsignedNative</vp>

=== Foreign language interfacing ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is now possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

== Updates ==

=== Build 7301 ===

'''Visual Prolog 7.3, Build 7301''' fixes [http://kb.visual-prolog.com/fixes/fixes7300.htm#7301 several minor bugs].

The following new feature has been implemented:

* Built-in predicate <vp>toEllipsis : (any* Terms) -> ...</vp>
* The PFC '''treeControl''' has been extended with key down and drag-and-drop handling
* The set of examples for '''Personal Edition''' was extended
* The following GUI controls have been added to the Personal Edition: listViewControl, tabControl, and treeViewControl.

=== Build 7302 ===

'''Visual Prolog 7.3, Build 7302''' fixes [http://kb.visual-prolog.com/fixes/fixes7300.htm#7302 several minor bugs].

== See also ==
[http://kb.visual-prolog.com/fixes/fixes7300.htm Bugs Fixed in Visual Prolog 7.3]

[[Visual Prolog 7.3 Upgrade Notes]]

[[Category:Release Notes]]

Language Reference

2010-06-17T12:41:05Z

Elizabeth Safro: Visual Prolog 7.3 Language Reference in Chinese

{{languageReferenceNavbar|{{PAGENAME}}}}

This document describes the syntax and semantics of the Visual Prolog programming language.

Visual Prolog is a strongly typed object oriented programming language based on the logical programming language Prolog.

A Visual Prolog program consists of a ''goal'' and a number of:

* {{lang|Interfaces|Interfaces}}
* {{lang|Classes|Class declarations}} and
* {{lang|Implementations|Class implementations}}

Which contain declarations and definitions of Prolog entities:

* {{lang|Domains|Domains}}
* {{lang|Constants|Constants}}
* {{lang|Predicates|Predicates}}
* {{lang|Properties|Properties}}
* {{lang|Facts|Fact databases}}

The "actual" code of a Visual Prolog is the {{lang|Clauses|clauses}}, which are located in {{lang|Implementations|class implementations}} and which implements {{lang|Predicates|predicates}}.

{{ifLRBook|inBook=|notInBook=
=== Language Reference in other Languages ===
[http://download.pdc.dk/vip/73/documentation/LanguageReference_chinese.pdf Visual Prolog 7.3 Language Reference in Chinese (PDF file)]

[http://download.pdc.dk/vip/72/documentation/LanguageReference_chinese.pdf Visual Prolog 7.2 Language Reference in Chinese (PDF file)]
}}
== See also ==
[[Visual Prolog 7.2 Prolog Foundation Classes (PFC) in Chinese]]

Visual Prolog 7.3 New Features

2010-05-28T09:34:44Z

Elizabeth Safro: /* Build 7301 */

== Language ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify Operator ===

New operator == (must-unify)

=== Universal term type ===

<vp>any</vp> and the predicate <vp>toAny/1-></vp>

=== 64 bit preparation ===

Preparations for supporting 64bit systems: built-in types <vp>integerNative</vp> and <vp>unsignedNative</vp>

=== Foreign language interfacing ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is now possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

== Updates ==

=== Build 7301 ===

'''Visual Prolog 7.3, Build 7301''' fixes [http://kb.visual-prolog.com/fixes/fixes7300.htm#7301 several minor bugs].

The following new feature has been implemented:

* Built-in predicate <vp>toEllipsis : (any* Terms) -> ...</vp>
* The PFC '''treeControl''' has been extended with key down and drag-and-drop handling
* The set of examples for '''Personal Edition''' was extended
* The following GUI controls have been added to the Personal Edition: listViewControl, tabControl, and treeViewControl.

== See also ==
[http://kb.visual-prolog.com/fixes/fixes7300.htm Bugs Fixed in Visual Prolog 7.3]

[[Visual Prolog 7.3 Upgrade Notes]]

[[Category:Release Notes]]

Visual Prolog 7.3 New Features

2010-05-27T15:23:09Z

Elizabeth Safro: /* Build 7301 */

== Language ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify Operator ===

New operator == (must-unify)

=== Universal term type ===

<vp>any</vp> and the predicate <vp>toAny/1-></vp>

=== 64 bit preparation ===

Preparations for supporting 64bit systems: built-in types <vp>integerNative</vp> and <vp>unsignedNative</vp>

=== Foreign language interfacing ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is now possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

== Updates ==

=== Build 7301 ===

'''Visual Prolog 7.3, Build 7301''' fixes several minor bugs.

The following new feature has been implemented:

* Built-in predicate <vp>toEllipsis : (any* Terms) -> ...</vp>
* The PFC '''treeControl''' has been extended with key down and drag-and-drop handling
* The set of examples for '''Personal Edition''' was extended
* The following GUI controls have been added to the Personal Edition: listViewControl, tabControl, and treeViewControl.

== See also ==
[http://kb.visual-prolog.com/fixes/fixes7300.htm Bugs Fixed in Visual Prolog 7.3]

[[Visual Prolog 7.3 Upgrade Notes]]

[[Category:Release Notes]]

Visual Prolog 7.3 New Features

2010-05-27T12:38:49Z

Elizabeth Safro: /* Coming Soon: Build 7301 */

== Language ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify Operator ===

New operator == (must-unify)

=== Universal term type ===

<vp>any</vp> and the predicate <vp>toAny/1-></vp>

=== 64 bit preparation ===

Preparations for supporting 64bit systems: built-in types <vp>integerNative</vp> and <vp>unsignedNative</vp>

=== Foreign language interfacing ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is now possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

== Updates ==

=== Build 7301 ===

'''Visual Prolog 7.3, Build 7301''' fixes several minor bugs.

The following new feature has been implemented:

* Built-in predicate <vp>toEllipsis : (any* Terms) -> ...</vp>
* The PFC '''treeControl''' has been extended with key down and drag-and-drop handling
* The set of examples for '''Personal Edition''' was extended

== See also ==
[http://kb.visual-prolog.com/fixes/fixes7300.htm Bugs Fixed in Visual Prolog 7.3]

[[Visual Prolog 7.3 Upgrade Notes]]

[[Category:Release Notes]]

Language Reference

2010-05-26T12:21:37Z

Elizabeth Safro:

{{languageReferenceNavbar|{{PAGENAME}}}}

This document describes the syntax and semantics of the Visual Prolog programming language.

Visual Prolog is a strongly typed object oriented programming language based on the logical programming language Prolog.

A Visual Prolog program consists of a ''goal'' and a number of:

* {{lang|Interfaces|Interfaces}}
* {{lang|Classes|Class declarations}} and
* {{lang|Implementations|Class implementations}}

Which contain declarations and definitions of Prolog entities:

* {{lang|Domains|Domains}}
* {{lang|Constants|Constants}}
* {{lang|Predicates|Predicates}}
* {{lang|Properties|Properties}}
* {{lang|Facts|Fact databases}}

The "actual" code of a Visual Prolog is the {{lang|Clauses|clauses}}, which are located in {{lang|Implementations|class implementations}} and which implements {{lang|Predicates|predicates}}.

{{ifLRBook|inBook=|notInBook=
=== Language Reference in other Languages ===

[http://download.pdc.dk/vip/72/documentation/LanguageReference_chinese.pdf Visual Prolog 7.2 Language Reference in Chinese (PDF file)]
}}
== See also ==
[[Visual Prolog 7.2 Prolog Foundation Classes (PFC) in Chinese]]

Language Reference

2010-05-26T12:20:09Z

Elizabeth Safro:

{{languageReferenceNavbar|{{PAGENAME}}}}

This document describes the syntax and semantics of the Visual Prolog programming language.

Visual Prolog is a strongly typed object oriented programming language based on the logical programming language Prolog.

A Visual Prolog program consists of a ''goal'' and a number of:

* {{lang|Interfaces|Interfaces}}
* {{lang|Classes|Class declarations}} and
* {{lang|Implementations|Class implementations}}

Which contain declarations and definitions of Prolog entities:

* {{lang|Domains|Domains}}
* {{lang|Constants|Constants}}
* {{lang|Predicates|Predicates}}
* {{lang|Properties|Properties}}
* {{lang|Facts|Fact databases}}

The "actual" code of a Visual Prolog is the {{lang|Clauses|clauses}}, which are located in {{lang|Implementations|class implementations}} and which implements {{lang|Predicates|predicates}}.

{{ifLRBook|inBook=|notInBook=
=== Language Reference in other Languages ===

[http://download.pdc.dk/vip/72/documentation/LanguageReference_chinese.pdf Visual Prolog 7.2 Language Reference in Chinese (PDF file)]
}}
== See also ==
[[Visual Prolog 7.2 Prolog Foundation Classes (PFC) in Chinese (zipped .chm file)]]

Prolog Foundation Classes (PFC) in Chinese

2010-05-25T16:55:06Z

Elizabeth Safro: English-Chinese description of PFC translation

The Prolog Foundation Classes (PFC ) is the set of classes and interfaces that constitutes the foundation for writing various kinds of applications and software components in Visual Prolog.
An English version of PFC is provided as a part of Visual Prolog Help system.

Yi Ding from China has kindly translated Visual Prolog 7.2 PFC to Chinese.

译者说明

这里译出的内容，取自Visual Prlog 7.2安装目录下的\pfc目录及其子目录内的.htm文件，与帮助文件（vip.chm）中的PFC说明部分完全一样。\pfc\5xVIP是有关如何将5.x版本程序转换适应新版本软件的内容，没有译。

Prolog 基础类（PFC）中的重点内容，对初学者来说是vpi和gui。仔细阅读这些内容，对理解 Visual Prolog 的编程方式有很大帮助，至少译者自己有这样的体会和感受。

译者的计算机语言基础知识不是很好，面向对象编程的知识更差。对翻译对象的理解不足，加上英文也不怎么样，译的东西肯定不会好。因此，为方便对照和发现差错，每篇译文后面都附了原文。译者的初衷是为了自己学习 Visual Prolog 时的方便，所以译了这些内容。既然花了些时间有了这个译本，想想放出来对一些 Visual Prolog 的初学者可能多少有些帮助。或有方家不吝赐教，那就更是幸甚啦！

乙丁 its2u@qq.com

2010年5月

== Download ==
[http://download.pdc.dk/vip/72/documentation/VPI_PFC_Chinese.zip 下载 Prolog 基础类（PFC）]

[[Category:Chinese]]

A Guide to Artificial Intelligence with Visual Prolog. Addendum for Version 7.3

2010-05-24T17:18:21Z

Elizabeth Safro: New page: ''Written by Randall Scott'' For both the Sample Program in the Book and the slightly enhanced version of the Sample Program provided by the Supplemental Package, you will need to do the ...

''Written by Randall Scott''

For both the Sample Program in the Book and the slightly enhanced version of the Sample Program provided by the Supplemental Package, you will need to do the following for the Programs to work with the new Visual Prolog version 7.3, if they were already constructed with version 7.2. If on the other hand, you start constructing them with the version 7.3, I don’t think you’ll encounter any problems. This sounds reasonable if you construct all the program yourself entirely, which should happen as you read the book and construct '''GAMegaLotto'''. However, this probably is not true regarding '''LottoV2''' in the Supplemental Package.

# Copy all of the programs from their version 7.2 directories to new directories for version 7.3. Then delete all the ‘OBJ’ files from the ‘OBJ’ directory. Also delete all the files in the EXE directories except the ‘Stats.txt’, ‘ImportInstruction.hlp’, and the ‘MegaMillionsHistory.csv’ files.
# Assuming these Programs were constructed with Version 7.2, Open Visual Prolog version 7.3 and then open the Sample Projects one at a time and make the following changes. Keep in mind Version 7.3 will be opening ‘.prj’ files created by version 7.2.

===a. For GAMegaLotto:===

(1) Try to Build the GAMegaLotto Project and ‘Add’ requested and required items suggested: 

<vp>#include @"pfc\vpi\vpi.ph" in Lotto.pack</vp> 

''Required items''<nowiki>: As you can see a lot of new PFC items were built into version 7.3</nowiki> 

(Note: you could just click on ‘Add All’) 

* collection.pack
* mapM_redBlack.pack
* setM_redBlack.pack
* monitorQueue.pack
* mapMSupport.pack
* collectionMsupport.pack
* redBlackTree.pack
* redBlackSet.pack

(2) Since a lot of new items have now been added to your project, you’ll see a few Errors and warnings.

(3) Select ‘Build All’ to force a total rebuild. This will clear all the errors and just leave warnings and the program should work as it did with Version 7.2.

===b. For LottoV2:===

(1) Try to ‘Build’ the LottoV2 Project and ‘Add’ all required items suggested:

''Required items'': Again, a lot of new PFC items were built into version 7.3

(Note: again you could just click on ‘Add All’)

* collection.pack
* mapM_redBlack.pack
* setM_redBlack.pack
* monitorQueue.pack
* mapMSupport.pack
* collectionMsupport.pack
* redBlackTree.pack
* redBlackSet.pack

(2) A lot of new items have now been added to your project as before, and this time you’ll see only 5 Errors; now select ‘Build All’ to force a total rebuild. This will include these items in the second Build, unfortunately this will not clear the errors - a little more work will need to be done to force visibility of the PFC ‘vpi’ that Visual Prolog 7.3 detected and suggested adding in GAMegaLotto, but not for LottoV2. The solution I chose was as follows:

(a) Open the ‘Numbers.pro’ Class Implementation file and make the following change:

'''Before:'''

<vp>open core, vpiDomains </vp>

'''After:'''

<vp>open core, vpiDomains, vpi</vp>

(b) Save the ‘Numbers.pro’ Class Implementation file then select ‘Build’ again. Select ‘Add’ #include @"pfc\vpi\vpi.ph" when requested; which will now get it included as needed; and when finished rebuilding, the program should now work as it did with Version 7.2.

Visual Prolog 7.3 New Features

2010-05-24T17:03:25Z

Elizabeth Safro: /* Coming soon: Build 7301 */

== Language ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify Operator ===

New operator == (must-unify)

=== Universal term type ===

<vp>any</vp> and the predicate <vp>toAny/1-></vp>

=== 64 bit preparation ===

Preparations for supporting 64bit systems: built-in types <vp>integerNative</vp> and <vp>unsignedNative</vp>

=== Foreign language interfacing ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is now possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

== Updates ==

=== Coming Soon: Build 7301 ===

'''Visual Prolog 7.3, Build 7301''' fixes several minor bugs.

The following new feature has been implemented:

* Built-in predicate <vp>toEllipsis : (any* Terms) -> ...</vp>
* The PFC '''treeControl''' has been extended with key down and drag-and-drop handling
* The set of examples for '''Personal Edition''' was extended

== See also ==
[http://kb.visual-prolog.com/fixes/fixes7300.htm Bugs Fixed in Visual Prolog 7.3]

[[Visual Prolog 7.3 Upgrade Notes]]

[[Category:Release Notes]]

Visual Prolog 7.3 New Features

2010-05-24T12:27:42Z

Elizabeth Safro: /* Build 7301 */

== Language ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify Operator ===

New operator == (must-unify)

=== Universal term type ===

<vp>any</vp> and the predicate <vp>toAny/1-></vp>

=== 64 bit preparation ===

Preparations for supporting 64bit systems: built-in types <vp>integerNative</vp> and <vp>unsignedNative</vp>

=== Foreign language interfacing ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is now possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

== Updates ==

=== Coming soon: Build 7301 ===

'''Visual Prolog 7.3, Build 7301''' fixes several minor bugs.

The following new feature has been implemented:

* Built-in predicate <vp>toEllipsis : (any* Terms) -> ...</vp>
* The PFC '''treeControl''' has been extended with key down and drag-and-drop handling
* The set of examples for '''Personal Edition''' was extended

== See also ==
[http://kb.visual-prolog.com/fixes/fixes7300.htm Bugs Fixed in Visual Prolog 7.3]

[[Visual Prolog 7.3 Upgrade Notes]]

[[Category:Release Notes]]

Visual Prolog 7.3 New Features

2010-05-13T17:29:38Z

Elizabeth Safro: "{{Preliminary Documentation}}" has been removed

== Language ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify Operator ===

New operator == (must-unify)

=== Universal term type ===

<vp>any</vp> and the predicate <vp>toAny/1-></vp>

=== 64 bit preparation ===

Preparations for supporting 64bit systems: built-in types <vp>integerNative</vp> and <vp>unsignedNative</vp>

=== Foreign language interfacing ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is now possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

== See also ==
[http://kb.visual-prolog.com/fixes/fixes7300.htm Bugs Fixed in Visual Prolog 7.3]

[[Visual Prolog 7.3 Upgrade Notes]]

[[Category:Release Notes]]

Visual Prolog 7.3 New Features

2010-04-29T16:14:27Z

Elizabeth Safro: /* Others */

{{Preliminary Documentation}}

== Language ==

=== Generic Interfaces and Classes ===

See {{lang|Generic Interfaces and Classes|Generic Interfaces and Classes}}.

=== Conversion to Generic Type ===

=== Monitors ===

{{lang|Monitors|Monitors}} with {{lang2|Monitors|Guards|guards}}

=== Must Unify Operator ===

New operator == (must-unify)

=== Universal term type ===

<vp>any</vp> and the predicate <vp>toAny/1-></vp>

=== 64 bit preparation ===

Preparations for supporting 64bit systems: built-in types <vp>integerNative</vp> and <vp>unsignedNative</vp>

=== Foreign language interfacing ===

Native interfaces support (attributes):
* {{lang2|Attributes|inline|inline}}: Inline structures and strings.
* {{lang2|Attributes|union|union}}: Functor-less unions.
* {{lang2|Attributes|byVal|byVal}}: Passing parameters by value.

External resolution is default for predicates declared with <vp>apicall</vp> calling convention.
* They cannot have clauses
* explicit externally resolution is only legal when a DLL is stated

=== Other language features ===

* The precedence of unary minus is changed (so that power operator has higher precedence)
* Extended versions of built-in predicates <vp>toTerm/2-></vp> and <vp>tryToTerm/2-></vp> (type as the first parameter).
* New built-in predicate <vp>fromEllipsis : (...) -> any* Terms</vp>
* Runtime distinction between privately and publicly supported interfaces is removed

New attributes
* {{lang2|Attributes|retired|retired}}
* {{lang2|Attributes|noDefaultConstructor|noDefaultConstructor}}
* {{lang2|Attributes|used|used}}

Warnings:
* Local object predicates which do not use <vp>This</vp> (and therefore can be declared as class predicates)
* Unused local constants
* Condition of foreach statement which has no backtrack point (i.e. mode is not <vp>multi</vp> or <vp>nondeterm</vp>)
* <vp>unheckedConversion</vp>'s that would be illegal on 64 bit platforms (e.g. <vp>pointer</vp> -> <vp>integer</vp>)

== IDE ==

=== Project tree ===

The project tree is redesigned and reimplemented. The functionality is more or less unchanged, but the performance is improved.

The '''IncludedIn''' and '''Includes''' windows has been moved to preview pane of project window.

It is not possible to have several packages with same name in a project (which can make much sense when using namespaces).

=== Browse dialog ===

The '''Browse''' dialog is improved in several smaller respects, including:
* It automatically jump to the 1st occurrence of search entity on locate
* The last dialog position is saved for next appearence

=== Find In Files ===

The '''Find In Files''' dialog is improved in several respects, including:
* result window is reused for subsequent searches
* F8 button for next match (Shift+F8 - previous)
* Prolog case sensitive search mode
* state is saved for next appearence

=== Namespace support ===

The '''Namespaces support''' is improved, so that forms, dialogs, etc can be places in namespaces when created.

=== IntelliSense ===

The '''IntelliSense''' feature is improved for better overview, speed typing and convenience of work.

=== Tab navigation dialog ===

The '''tab navigation''' dialog functionality has been extended:
* use ALT button for filtering [ReadOnly] windows
* use Del for closing windows

=== Go to Position on Clipboard ===

The '''Go to Position on Clipboard''' (Shift+F2) has been extended to accept a complete exception dump. F8 will go to the next stack entry.

=== Sorting in various windows ===

The Errors Window, the Break points Window, etc. has been extended with sorting capabilities (clicking on the top banner).
* '''Optimal Set of Includes improved''' (output, local scopes, etc.)

== Debugger ==

* '''Highlighting''' changed values in variable window
* View of '''long lists''' improvement
* '''Speed''' of restarting is improved
* '''Memory break points''' and fact access (for some types)
* '''Multi-threaded''' application debugging is improved (thread names, break points handling)
* Multi-line '''tool tips'''

== PFC ==

=== New entities ===

* [[Collection library]]
** Algebraic: <vp>redBlackSet</vp>, <vp>leftistPriorityQueue</vp>
** Modifiable: <vp>mapM_redBlack</vp>, <vp>priorityQueueM_leftist</vp>, <vp>queueM_fact</vp>, <vp>setM_redBlack</vp>
** Persistent: <vp>mapP_redBlack</vp>, <vp>priorityQueueP_leftist</vp>, <vp>queueP_fact</vp>, <vp>setP_redBlack</vp>
* <vp>varM</vp> modifiable variable
* <vp>linkControl</vp> PFC version of the Link common control
* <vp>richEditControl</vp> PFC version of the RichEdit common control
* <vp>treeControl</vp> PFC model based version of the TreeView common control
* <vp>gdiplus</vp> PFC version of GDI+
* <vp>cryptography</vp> hash, sha1, md5 & base64
* <vp>eventSource</vp> generalization of event notification/listening
* <vp>monitorQueue</vp> thread safe queue class based on the monitor facility
* <vp>reflection</vp> basic functionalty for code reflection
* <vp>inputStream_null</vp> & <vp>outputStream_null</vp> media-less streams (input is exhausted; outpt throws away)
* <vp>lZ_fileSystem_native</vp> Interface to Lempel-Ziv Decompression API functionality
* <vp>shell_api</vp> Api level interface to the Windows Shell
* <vp>winsock2_native</vp> native bindings to Windows Sockets 2

=== Extensions and improvements ===

* <vp>list</vp> package:
** speed: <vp>sort</vp>, <vp>removeDuplicate</vp>, <vp>drop</vp>, <vp>min</vp>/<vp>max</vp>, etc.)
** functionality: <vp>isMemberEq</vp> (and similar predicates) that uses a <vp>determ</vp> predicate as test
* <vp>listControl</vp> with owner-drawing capabilities
* <vp>uxTheme_native</vp> extended with the rest of the functions and the constants from vsStyle.h, etc.
* Add moving listener/responder to <vp>splitTwoControl</vp>
* Add the fraction handling from <vp>format</vp> to <vp>formatTime</vp>
* '''Speed''' improvements for:
** <vp>string</vp>
** <vp>fileName</vp>
** <vp>listViewControl</vp>
* <vp>string::rear/2-></vp> returns the rear part of a string
* '''Math''' package: predicates <vp>roundToInteger64/1-></vp> and <vp>roundToUnsigned64/1-></vp>
* Better handling of '''default button size'''
* <vp>msXLM_api</vp> update to version 6.0 of various COMponent classes

== Others ==

* More efficient '''memory handling'''; using typed memory allocation for compound terms and internal facts chains
* Various optimizations for speed and size of generated code
* New Demo Examples (Commercial Edition only):
** Parser Generator
** LZDecompression
** TreeControlDemo
* Help on built-in entities
* VipBuilder: extra option to ignore <vp>#requires</vp> directives
* Extend '''Win32''' library (with more names from MS libraries).
* More context to consult exceptions
* Linker speed improvement
* Vault Integration updated to version 5.0.1

== See also ==
[http://kb.visual-prolog.com/fixes/fixes7300.htm Bugs Fixed in Visual Prolog 7.3]

[[Visual Prolog 7.3 Upgrade Notes]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-16T13:15:12Z

Elizabeth Safro:

This document describes how to upgrade Visual Prolog projects created by previous versions of Visual Prolog to Visual Prolog 7.3.

If you have problems with upgrading your projects and need additional information, you are welcome to ask questions in [http://discuss.visual-prolog.com/viewforum.php?f=2 Visual Prolog Discussion Forum].

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version of Visual Prolog Commercial Edition (CE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3'''. The new version of Visual Prolog Personal Edition (PE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3PE'''.
You can remove a previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open a project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the messages suggesting adding or removing packages / modules.

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Alongside with the actions described in the section "Upgrading Projects from Visual Prolog 7.1 & 7.2", some additional actions might be required to upgrade projects from the versions earlier than Visual Prolog 7.1.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.3 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.3 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend you reading the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects to the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-16T13:12:53Z

Elizabeth Safro: /* Upgrading from 7.0 & 6.x */

'''''This topic is under construction'''''

This document describes how to upgrade Visual Prolog projects created by previous versions of Visual Prolog to Visual Prolog 7.3.

If you have problems with upgrading your projects and need additional information, you are welcome to ask questions in [http://discuss.visual-prolog.com/viewforum.php?f=2 Visual Prolog Discussion Forum].

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version of Visual Prolog Commercial Edition (CE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3'''. The new version of Visual Prolog Personal Edition (PE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3PE'''.
You can remove a previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open a project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the messages suggesting adding or removing packages / modules.

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Alongside with the actions described in the section "Upgrading Projects from Visual Prolog 7.1 & 7.2", some additional actions might be required to upgrade projects from the versions earlier than Visual Prolog 7.1.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.3 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.3 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend you reading the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects to the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-16T13:11:36Z

Elizabeth Safro: /* Upgrading from 7.1 & 7.2 */

'''''This topic is under construction'''''

This document describes how to upgrade Visual Prolog projects created by previous versions of Visual Prolog to Visual Prolog 7.3.

If you have problems with upgrading your projects and need additional information, you are welcome to ask questions in [http://discuss.visual-prolog.com/viewforum.php?f=2 Visual Prolog Discussion Forum].

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version of Visual Prolog Commercial Edition (CE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3'''. The new version of Visual Prolog Personal Edition (PE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3PE'''.
You can remove a previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open a project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the messages suggesting adding or removing packages / modules.

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Alongside with the actions described in the section "Upgrading Projects from Visual Prolog 7.1 & 7.2", some additional actions might be required to upgrade projects from the versions earlier than Visual Prolog 7.1.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.3 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.3 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects to the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-16T13:09:39Z

Elizabeth Safro: /* Upgrading from 7.1 & 7.2 */

'''''This topic is under construction'''''

This document describes how to upgrade Visual Prolog projects created by previous versions of Visual Prolog to Visual Prolog 7.3.

If you have problems with upgrading your projects and need additional information, you are welcome to ask questions in [http://discuss.visual-prolog.com/viewforum.php?f=2 Visual Prolog Discussion Forum].

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version of Visual Prolog Commercial Edition (CE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3'''. The new version of Visual Prolog Personal Edition (PE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3PE'''.
You can remove a previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open a project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message suggesting to add or remove packages / modules.

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Alongside with the actions described in the section "Upgrading Projects from Visual Prolog 7.1 & 7.2", some additional actions might be required to upgrade projects from the versions earlier than Visual Prolog 7.1.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.3 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.3 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects to the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-16T13:09:14Z

Elizabeth Safro: /* Upgrading from 7.1 & 7.2 */

'''''This topic is under construction'''''

This document describes how to upgrade Visual Prolog projects created by previous versions of Visual Prolog to Visual Prolog 7.3.

If you have problems with upgrading your projects and need additional information, you are welcome to ask questions in [http://discuss.visual-prolog.com/viewforum.php?f=2 Visual Prolog Discussion Forum].

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version of Visual Prolog Commercial Edition CE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3'''. The new version of Visual Prolog Personal Edition (PE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3PE'''.
You can remove a previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open a project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message suggesting to add or remove packages / modules.

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Alongside with the actions described in the section "Upgrading Projects from Visual Prolog 7.1 & 7.2", some additional actions might be required to upgrade projects from the versions earlier than Visual Prolog 7.1.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.3 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.3 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects to the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-16T13:07:20Z

Elizabeth Safro: /* Upgrading from 7.1 & 7.2 */

'''''This topic is under construction'''''

This document describes how to upgrade Visual Prolog projects created by previous versions of Visual Prolog to Visual Prolog 7.3.

If you have problems with upgrading your projects and need additional information, you are welcome to ask questions in [http://discuss.visual-prolog.com/viewforum.php?f=2 Visual Prolog Discussion Forum].

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version of Visual Prolog Commercial Edition(CE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3'''. The new version of Visual Prolog Personal Edition (PE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3PE'''.
You can remove a previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open a project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message suggesting to add or remove packages / modules.

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Alongside with the actions described in the section "Upgrading Projects from Visual Prolog 7.1 & 7.2", some additional actions might be required to upgrade projects from the versions earlier than Visual Prolog 7.1.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.3 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.3 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects to the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-16T13:06:41Z

Elizabeth Safro: /* Upgrading from 7.1 & 7.2 */

'''''This topic is under construction'''''

This document describes how to upgrade Visual Prolog projects created by previous versions of Visual Prolog to Visual Prolog 7.3.

If you have problems with upgrading your projects and need additional information, you are welcome to ask questions in [http://discuss.visual-prolog.com/viewforum.php?f=2 Visual Prolog Discussion Forum].

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version of Visual Prolog Commercial Edition(CE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3'''. The new version of Visual Prolog Personal Edition (PE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3PE'''.
You can remove a previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message suggesting to add or remove packages / modules.

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Alongside with the actions described in the section "Upgrading Projects from Visual Prolog 7.1 & 7.2", some additional actions might be required to upgrade projects from the versions earlier than Visual Prolog 7.1.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.3 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.3 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects to the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-16T13:04:14Z

Elizabeth Safro: /* Upgrading from 7.1 & 7.2 */

'''''This topic is under construction'''''

This document describes how to upgrade Visual Prolog projects created by previous versions of Visual Prolog to Visual Prolog 7.3.

If you have problems with upgrading your projects and need additional information, you are welcome to ask questions in [http://discuss.visual-prolog.com/viewforum.php?f=2 Visual Prolog Discussion Forum].

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions.
The new version of Visual Prolog Commercial Edition(CE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3'''.

The new version of Visual Prolog Personal Edition (PE) will be installed by default to '''C:\Program Files\Visual Prolog 7.3PE'''.

You can remove a previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message suggesting to add or remove packages / modules.

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Alongside with the actions described in the section "Upgrading Projects from Visual Prolog 7.1 & 7.2", some additional actions might be required to upgrade projects from the versions earlier than Visual Prolog 7.1.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.3 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.3 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects to the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-15T13:39:36Z

Elizabeth Safro:

'''''This topic is under construction'''''

This document describes how to upgrade Visual Prolog projects created by previous versions of Visual Prolog to Visual Prolog 7.3.

If you have problems with upgrading your projects and need additional information, you are welcome to ask questions in [http://discuss.visual-prolog.com/viewforum.php?f=2 Visual Prolog Discussion Forum].

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version will be installed by default to '''C:\Program Files\Visual Prolog 7.3CE'''. You can remove the previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message "The new module is required to be added into the project".

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Alongside with the actions described in the section "Upgrading Projects from Visual Prolog 7.1 & 7.2", some additional actions might be required to upgrade projects from the versions earlier than Visual Prolog 7.1.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.3 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.3 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects to the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-15T13:23:59Z

Elizabeth Safro: /* Upgrading from 5.x */

'''''This topic is under construction'''''

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version will be installed by default to '''C:\Program Files\Visual Prolog 7.3CE'''. You can remove the previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message "The new module is required to be added into the project".

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Alongside with the actions described in the section "Upgrading Projects from Visual Prolog 7.1 & 7.2", some additional actions might be required to upgrade projects from the versions earlier than Visual Prolog 7.1.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.3 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.3 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects to the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-15T13:23:25Z

Elizabeth Safro: /* Upgrading from 7.0 & 6.x */

'''''This topic is under construction'''''

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version will be installed by default to '''C:\Program Files\Visual Prolog 7.3CE'''. You can remove the previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message "The new module is required to be added into the project".

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Alongside with the actions described in the section "Upgrading Projects from Visual Prolog 7.1 & 7.2", some additional actions might be required to upgrade projects from the versions earlier than Visual Prolog 7.1.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.3 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.3 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects into the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-15T13:18:32Z

Elizabeth Safro: /* Upgrading from 7.0 & 6.x */

'''''This topic is under construction'''''

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version will be installed by default to '''C:\Program Files\Visual Prolog 7.3CE'''. You can remove the previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message "The new module is required to be added into the project".

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Depending on Visual Prolog version, you are upgrading your projects from, some additional actions might be required.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.3 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.3 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects into the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-15T13:14:23Z

Elizabeth Safro: /* Upgrading from 7.1 & 7.2 */

'''''This topic is under construction'''''

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version will be installed by default to '''C:\Program Files\Visual Prolog 7.3CE'''. You can remove the previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.1 & 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.1 & 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE, it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message "The new module is required to be added into the project".

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Depending on Visual Prolog version, you are upgrading your projects from, some additional actions might be required.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.1 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.2 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects into the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-15T12:45:13Z

Elizabeth Safro: Visual prolog 7.3 Upgrade Notes moved to Visual Prolog 7.3 Upgrade Notes: Incorrect case

'''''This topic is under construction'''''

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version will be installed by default to '''C:\Program Files\Visual Prolog 7.3CE'''. You can remove the previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message "The new module is required to be added into the project".

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Depending on Visual Prolog version, you are upgrading your projects from, some additional actions might be required.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.1 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.2 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects into the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-15T12:33:09Z

Elizabeth Safro: /* See also */

'''''This topic is under construction'''''

== Upgrading from 7.1 & 7.2 ==

# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version will be installed by default to '''C:\Program Files\Visual Prolog 7.3CE'''. You can remove the previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message "The new module is required to be added into the project".

=== Note ===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

== Upgrading from 7.0 & 6.x ==

Depending on Visual Prolog version, you are upgrading your projects from, some additional actions might be required.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.1 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.2 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

== Upgrading from 5.x ==

Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects into the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.3]]

[[Category:Release Notes]]

Visual Prolog 7.3 Upgrade Notes

2010-04-14T17:41:01Z

Elizabeth Safro: /* Upgrading Projects from Visual Prolog 7.1 - 7.2 to Visual Prolog 7.3 */

'''''The topic is under construction'''''
==Upgrading Projects from Visual Prolog 7.1 - 7.2 to Visual Prolog 7.3==
# By default, the installation of Visual Prolog 7.3 will not replace any previously installed versions. The new version will be installed by default to '''C:\Program Files\Visual Prolog 7.3CE'''. You can remove the previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message "The new module is required to be added into the project".

===Note===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

==Upgrading Projects from Visual Prolog 7.0 and Visual Prolog 6.x to Visual Prolog 7.3==

Depending on Visual Prolog version, you are upgrading your projects from, some additional actions might be required.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.1 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.2 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

==Upgrading Projects from Visual Prolog 5.x==
Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects into the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.2]]
* [http://kb.visual-prolog.com/fixes/fixes7201.htm Bugs Fixed in Visual Prolog 7.2]

[[Category:Basic Information]]

Visual Prolog 7.3 Upgrade Notes

2010-04-14T17:37:57Z

Elizabeth Safro: /* Upgrading Projects from Visual Prolog 7.0 and Visual Prolog 6.x to Visual Prolog 7.2 */

'''''The topic is under construction'''''
==Upgrading Projects from Visual Prolog 7.1 - 7.2 to Visual Prolog 7.3==
# By default, the installation of Visual Prolog 7.2 will not replace any previously installed versions. The new version will be installed by default to '''C:\Program Files\Visual Prolog 7.3CE'''. You can remove the previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message "The new module is required to be added into the project".

===Note===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

==Upgrading Projects from Visual Prolog 7.0 and Visual Prolog 6.x to Visual Prolog 7.3==

Depending on Visual Prolog version, you are upgrading your projects from, some additional actions might be required.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.1 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.2 IDE.
# If you are going to use Visual Prolog 7.3 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

==Upgrading Projects from Visual Prolog 5.x==
Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects into the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.2]]
* [http://kb.visual-prolog.com/fixes/fixes7201.htm Bugs Fixed in Visual Prolog 7.2]

[[Category:Basic Information]]

Visual Prolog 7.3 Upgrade Notes

2010-04-14T17:36:59Z

Elizabeth Safro: /* Upgrading Projects from Visual Prolog 7.1 - 7.2 to Visual Prolog 7.3 */

'''''The topic is under construction'''''
==Upgrading Projects from Visual Prolog 7.1 - 7.2 to Visual Prolog 7.3==
# By default, the installation of Visual Prolog 7.2 will not replace any previously installed versions. The new version will be installed by default to '''C:\Program Files\Visual Prolog 7.3CE'''. You can remove the previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message "The new module is required to be added into the project".

===Note===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

==Upgrading Projects from Visual Prolog 7.0 and Visual Prolog 6.x to Visual Prolog 7.2==

Depending on Visual Prolog version, you are upgrading your projects from, some additional actions might be required.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.1 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.2 IDE.
# If you are going to use Visual Prolog 7.2 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

==Upgrading Projects from Visual Prolog 5.x==
Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects into the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.2]]
* [http://kb.visual-prolog.com/fixes/fixes7201.htm Bugs Fixed in Visual Prolog 7.2]

[[Category:Basic Information]]

Visual Prolog 7.3 Upgrade Notes

2010-04-14T16:11:38Z

Elizabeth Safro: New page: '''''The topic is under construction''''' ==Upgrading Projects from Visual Prolog 7.1 - 7.2 to Visual Prolog 7.3== # By default, the installation of Visual Prolog 7.2 will not replace any ...

'''''The topic is under construction'''''
==Upgrading Projects from Visual Prolog 7.1 - 7.2 to Visual Prolog 7.3==
# By default, the installation of Visual Prolog 7.2 will not replace any previously installed versions. The new version will be installed by default to '''C:\Program Files\Visual Prolog 7.3'''. You can remove the previous version or continue working with both.
# Visual Prolog 7.3 projects are backward-compatible with Visual Prolog 7.2 projects.
# If you are going to use different versions of Visual Prolog installed at one computer, avoid opening projects by double-clicking on prj6 files.
# Some changes might require automatic updates in Visual Prolog 7.2 projects. Therefore, it is recommended to make the project file (PRJ6) writable before the first build. Also, it is recommended to make copies for all project files first.
# When your open project in the Visual Prolog 7.3 IDE it will automatically perform necessary updates.
# After this, it is recommended you rebuild the project with the help of the '''Build | Rebuild All command''' and answer "Yes to All" to the message "The new module is required to be added into the project".

===Note===
# Depending on Visual Prolog version, you are upgrading your projects from, some additional actions described below might be required.

==Upgrading Projects from Visual Prolog 7.0 and Visual Prolog 6.x to Visual Prolog 7.2==

Depending on Visual Prolog version, you are upgrading your projects from, some additional actions might be required.

# Visual Prolog 7.3 projects are not fully backward-compatible with Visual Prolog 7.0 and Visual Prolog 6.x projects. Visual Prolog 7.0 and earlier IDE will not allow opening projects modified by Visual Prolog 7.1 IDE. It is recommended to create a backup copy of your project before opening it by the Visual Prolog 7.2 IDE.
# If you are going to use Visual Prolog 7.2 simultaneously with Visual Prolog 7.0 or an earlier version at the same computer, it is recommended to switch the IDE setting "Open Project at Startup" in the previous version OFF, to prevent opening Visual Prolog 7.1 projects in the earlier IDE. Note that beginning with Visual Prolog 7.1, projects are not opened at startup, and, hence, the setting "Open Project at Startup" is not used anymore.
# The following keywords were introduced: 
#* In Visual Prolog 7.1: <vp>properties</vp>, <vp>try</vp>, <vp>catch</vp>, <vp>finally</vp> and <vp>elseif</vp>.
#* In Visual Prolog 7.0: <vp>if</vp>, <vp>then</vp>, <vp>else</vp>, <vp>foreach</vp> and <vp>do</vp> That means that they can no longer be used as identifiers.
# Stronger treatment of types introduced in Visual Prolog 7.0 might require some changes in your program: typically change of declarations or insertions of explicit conversions might be necessary.
# Reference domains are not supported since Visual Prolog 7.0. If your project uses reference domains, we recommend to read the "[http://wiki.visual-prolog.com/index.php?title=How_To_Remove_Reference_Domains_from_a_Project How To Erase Reference Domains from a Project]" tutorial.
# G-stack is not used anymore since Visual Prolog 7.0. Hence, all G-stack related predicates have been removed.
# Beginning with Visual Prolog 7.0 some accelerator keys have been changed to comply with Microsoft standards.
# The format of specifying a fully-qualified (i.e. with an arity) predicate with a return value in <vp>resolve</vp>/<vp>delegate</vp> predicates from qualifications has been changed since Visual Prolog 6.2: <vp>predicateName//N</vp> => <vp>predicateName/N-></vp>. This may cause error messages while building your project in the latest version of Visual Prolog.
# Predicates <vp>div</vp> and <vp>mod</vp> have changed their meaning for negative numbers.

In Visual Prolog 6.1
<vip>-1 = -5 div 3
-2 = -5 mod 3</vip>

Since Visual Prolog 6.2

<vip>-2 = -5 div 3
+1 = -5 mod 3</vip>

So, each file that contains <vp>div</vp> or <vp>mod</vp> in the projects created in Visual Prolog 6.1 should be checked, whether it works correctly. The simplest solution is to replace:

div => quot
mod => rem

in all source files.

==Upgrading Projects from Visual Prolog 5.x==
Prolog Development Center provides the [http://www.visual-prolog.com/vip6/Product/migration.htm Migration Tool] that will assist you to migrate your Visual Prolog 5.x projects into Visual Prolog 6.x projects.

After migrating your projects into Visual Prolog 6.x, follow the recommendations above to upgrade your projects into the latest version of Visual Prolog.

== See also ==

* [[New Features in Visual Prolog 7.2]]
* [http://kb.visual-prolog.com/fixes/fixes7201.htm Bugs Fixed in Visual Prolog 7.2]

[[Category:Basic Information]]

Language Reference/Generic Interfaces and Classes

2010-03-17T18:03:26Z

Elizabeth Safro:

{{Preliminary Documentation}}

{{languageReferenceNavbar|Generic Interfaces and Classes}}

{{lang|Interfaces|Interfaces}} and {{lang|Classes|classes}} can be parametrized with type parameters so that they can be used in different instantiations in different contexts.

This section must be considered as an extension to the individual sections about:
* {{lang|Interfaces|Interfaces}}
* {{lang|Classes|Classes}}
* {{lang|Implementations|Implementations}}

The pragmatic reason to use generic classes and interfaces is to declare '''parametrized object facts''' and implement operations on these facts. As illustrated in the Queue example below.

=== Example: Queue ===

Consider this interface

<vip>interface queue_integer
predicates
insert : (integer Value).
tryGet : () -> integer Value.
end interface queue_integer</vip>

An object of this type is a queue of integers, if you replace "integer" with "string" you would have a type describing queues of strings.

A generic interface can be used to describe all such interfaces in a single interface definition:

<vip>interface queue{@Elem}
predicates
insert : (@Elem Value).
tryGet : () -> @Elem Value.
end interface queue</vip>

<vp>@Elem</vp> is a ''scope type variable'' (distinguished from local type variables by the <vp>@</vp>).

<vp>queue{integer}</vp> represents integer-queues; <vp>queue{string}</vp> represents string-queues; and so forth.

We can declare a generic queue class like this:

<vip>class queueClass{@Elem} : queue{@Elem}
end class queueClass</vip>

<vp>queueClass{@Elem}</vp> constructs objects type <vp>queue{@Elem}</vp> for any instantiation of <vp>@Elem</vp>.

The implementation can look like this:

<vip>implement queueClass{@Elem}
facts
queue_fact : (@Elem Value).
clauses
insert(Value) :-
assert(queue_fact(Value)).
clauses
tryGet() = Value :-
retract(queue_fact(Value)),
!.
end implement queueClass</vip>

This piece of code illustrates how to create an integer queue and insert an element in it:

<vip>..., Q = queueClass{integer}::new(), Q:insert(17), ...</vip>

It is not necessary to apply the type explicitly, instead the compiler can infer it from the context:

<vip>..., Q = queueClass::new(), Q:insert(17), ...</vip>

The compiler sees that <vp>Q</vp> must be an integer queue, because we insert 17 into it.

=== Generic Interfaces ===

==== Syntax ====

Generic interfaces have a list of type parameters:

<vipbnf><InterfaceDeclaration> :
interface <InterfaceName> { <ScopeTypeVariable>-comma-sep-list-opt } <ScopeQualifications> <Sections> end interface <InterfaceName>-opt
...

<ScopeTypeParameter> :
@ <UppercaseName></vipbnf>

The scope type parameters can be used in any declaration/definition in the interface.

==== Semantics ====

A generic interface defines all the interfaces that can be obtained by instantiating the type parameters with actual types. The scope type parameters from the opening are bound in the entire interface.

==== Restrictions ====

Then closing name should not have parameters:

<vip>interface xxx{@A}
...
end interface xxx % no parameters here</vip>

It is illegal to use same interface name for interfaces with different arity (in the same namespace):

<vip>interface xxx % xxx/0
...
end interface xxx

interface xxx{@A, @B} % error: Several classes, interfaces and/or namespaces have the same name 'xxx'
...
end interface xxx</vip>

Parameters can be used in supported interfaces:

<vip>interface xxx{@P} supports yyy{@P} % legal: @P is bound
...
end interface xxx

interface xxx supports yyy{@P} % illegal: @P must be bound
...
end interface xxx</vip>

Supported interfaces can be instantiated with any type expressions (as long as parameters are bound):

<vip>interface xxx{@A} supports yyy{integer, @A*}
...</vip>

=== Generic Classes ===

==== Syntax ====

Generic classes have a list of type parameters, and constructs objects of an interface type uses the these parameters.

<vipbnf><ClassDeclaration> :
class <ClassName> { <ScopeTypeVariable>-comma-sep-list-opt } <ConstructionType> <ScopeQualifications> <Sections> end class <ClassName>-opt
...

<ScopeTypeParameter> :
@ <UppercaseName>

<ConstructionType> :
: <TypeExpression></vipbnf>

The construction type must be generic (i.e. a generic interface).

==== Semantics ====

A generic class declares a class with a generic constructor. The type of the constructed object will be inferred from the usage of the constructor.

==== Restrictions ====

Then closing name should not have parameters:

<vip>class xxx{@A} : xxx{@AAA}
...
end class xxx % no parameters here</vip>

It is illegal to use same class name for class with different arity (in the same namespace):

<vip>class xxx % xxx/0
...
end class xxx

class xxx{@A} : yyy{@A} % error: Several classes, interfaces and/or namespaces have the same name 'xxx'
...
end class xxx</vip>

If a class and interface can have the same name, the class must construct objects of that interface.

<vip>interface xxx{@A}
...
end interface xxx

class xxx{@Q, @P} : object % error: Several classes, interfaces and/or namespaces have the same name 'xxx'
...
end class xxx</vip>

Parameters in the construction type, etc must be bound:

<vip>class bbb : xxx{@Q} % error: Free parameter '@Q' is used in type expression
...</vip>

All the parameters from the class must be used in the construction type:

<vip>class xxx{@P} : object % error: Unused type parameter '@P'
...</vip>

In class declarations scope parameter can only be used in constructors, domains and constants.

<vip>class xxx{@P} : xxx{@P}
domains
list = @P*. % legal
constants
empty : @P* = []. % legal
constructors
new : (@P Init). % legal
predicates
p : (@P X). % error: Scope parameter '@P' used in a class entity
end class xxx</vip>

=== Generic Implmentations ===

==== Syntax ====

Generic implementations have a list of type parameters.

<vipbnf><ClassImplementation> :
implement <ClassName> { <ScopeTypeVariable>-comma-sep-list-opt } <ScopeQualifications> <Sections> end implement <ClassName>-opt
...

<ScopeTypeParameter> :
@ <UppercaseName></vipbnf>

==== Semantics ====

A generic class declares a class with a generic constructor. The type of the constructed object will be inferred from the usage of the constructor.

==== Restrictions ====

Then closing name should not have parameters:

<vip>implement xxx{@A}
...
end implement xxx % no parameters here</vip>

The parameters must be the same as in the corresponding class declaration and have same order.

<vip>class xxx{@A} : aaa{@A}
...
end class xxx

implement xxx{@B} % error: The parameter '@B' is not the same as in the declaration '@A'
...
end implement xxx</vip>

In class implementations scope parameter can be used in constructors, domains, constants and in object entities (i.e. object facts, object predicates and object properties).

<vip>implement xxx{@P}
domains
list = @P*. % legal
constants
empty : @P* = []. % legal
constructors
new : (@P Init). % legal
predicates
op : (@P X). % legal
class predicates
cp : (@P X). % error: Scope parameter '@P' used in a class entity
facts
ofct : (@P). % legal
class facts
cfct : (@P). % error: Scope parameter '@P' used in a class entity
...
end implement xxx</vip>

Language Reference/Monitors

2010-03-17T17:51:31Z

Elizabeth Safro: /* Shared output streams */

{{Preliminary Documentation}}

{{languageReferenceNavbar|Monitors}}

A monitor is a language construction to synchronize two or more threads that use a shared resource, usually a hardware device or a set of variables. The compiler transparently inserts locking and unlocking code to appropriately designated procedures, instead of the programmer having to access concurrency primitives explicitly.

Visual Prolog monitor entrances can be controlled by guard predicates (conditions).

=== Syntax ===

Monitor interfaces and monitor classes are scopes:
<source lang="vipbnf"><Scope> : one of
...
<MonitorInterface>
<MonitorClass>
...
</source>
A monitor interface is defined by writing the keyword '''monitor''' in front of a regular interface definition:
<source lang="vipbnf"><MonitorInterface> :
monitor <IntertfaceDefinition></source>

A monitor class is declared by writing the keyword '''monitor''' in front of a regular class declaration:
<source lang="vipbnf"><MonitorClass> :
monitor <ClassDeclaration></source>
Monitor classes and interfaces cannot declare '''multi''' and '''nondeterm''' predicate members.

=== Restrictions ===

* A regular interface cannot support a monitor interface
* A monitor class cannot construct objects.
* It is not legal to inherit from a monitor (i.e. from a class that implements a monitor interface).

=== Semantics ===

The predicates and properties declared in a monitor are the '''''entrances''''' to the monitor. A thread enters the monitor through an entrance and is in the monitor until it leaves that entrance again. Only one thread is allowed to be in the monitor at the time. So each entry is protected as a critical region.

The semantics is simplest to understand as a program transformation (which is how it is implemented). Consider this academic example:
<vip>monitor class mmmm
predicates
e1 : (a1 A1).
e2 : (a2 A2).
...
en : (an An).
end class mmmm

implement mmmm
clauses
e1(A1) :- <B1>.

clauses
e2(A2) :- <B2>.

...
clauses
en(An) :- <Bn>.
end implement mmmm</vip> Where <B1>, <B2>, ..., <Bn> are clause bodies. This code corresponds to the following "normal" code:
<vip>class mmmm
predicates
e1 : (a1 A1).
e2 : (a2 A2).
...
en : (an An).
end class mmmm

implement mmmm
class facts
monitorRegion : mutex := mutex::create(false).

clauses
e1(A1) :-
_W = monitorRegion:wait(),
try
<B1>
finally
monitorRegion:release()
end try.

clauses
e2(A2) :-
_W = monitorRegion:wait(),
try
<B2>
finally
monitorRegion:release()
end try.
...
clauses
en(An) :-
_W = monitorRegion:wait(),
try
<Bn>
finally
monitorRegion:release()
end try.
end implement mmmm</vip>
So each monitor class is extended with a mutex, which is used to create a critical region around each entry body.

The code for monitor objects are similar, except that the mutex object is owned by the object.

=== Guards ===

Consider a monitor protected queue: some threads (''producers'') inserts elements in the queue and others (''consumers'') pick-out elements. However, you cannot pick-out elements if the queue is empty.

If we implement the queue using a monitor, the "pick-out" entry could be determ, failing if the queue is empty. But then the consumers would have to "poll" the queue until an element can be obtained. Such polling uses system resources, and normally it is desirable to avoid polling. This problem can be solved by guard predicates.

Each entry can have a guard associated in the implementation. The guard is added as a special guard-clause before the other clauses of the entry.

<vipbnf><Clause> : one of
...
<GuardClause>.</vipbnf>

<vipbnf><GuardClause> : one of
<LowerCaseIdentifier> guard <LowerCaseIdentifier> .
<LowerCaseIdentifier> guard <AnonymousPredicate> .</vipbnf>

{{Example| The guard can be the name of a predicate
<vip>
clauses
remove guard remove_guard.
remove() = ...</vip>}}

{{Example| The guard can also be an anonymous predicate
<vip>
clauses
remove guard { :- element_fact(_), ! }.
remove() = ...
</vip>}}

The guard predicates are evaluated when the monitor is created. For monitor classes this means at program start, for object predicates this is immediately after the construction of the object. The guard predicates are also evaluated whenever a tread leaves the monitor. But they are '''''not''''' evaluated at any other time.

If a certain guard succeeds the corresponding entry is ''open'', if it fails the entry is ''closed''.

It is only possible to enter open entries.

{{Example| Here is a queue class that solves the pick-out problem using a guard predicate on the '''remove''' operation:
<vip>monitor class queue
predicates
insert : (integer Element).
predicates
remove : () -> integer Element.
end class queue

implement queue
class facts
element_fact : (integer Element) nondeterm.

clauses
insert(Element) :-
assert(element_fact(Element)).

clauses
remove guard remove_guard.
remove() = Element :-
retract(element_fact(Element)),
!;
common_exception::raise_error(common_exception::classInfo, predicate_name(),
"The guard should have ensured that the queue is not empty").

predicates
remove_quard : () determ.
clauses
remove_guard() :-
element_fact(_),
!.
end implement queue</vip>
Notice that '''remove''' is a procedure, because threads that call remove will '''''wait''''' until there is an element for them. The guard predicate '''remove_guard''' succeeds if there is an element in the queue.

So '''remove_guard''' is evaluated each time a thread leaves the monitor, and the '''element_fact''' fact database can only be changed by a thread that is inside the monitor. Therefore the guard value stays sensible all the time (i.e. when there are no threads in the monitor). It is important to ensure such "stays sensible" condition for guards.
}}

Guard predicates are handled in the transformation mentioned above. The queue example is effectively the same as this "monitor-free" code:
<vip>class queue
predicates
insert : (integer Element).
predicates
remove : () -> integer Element.
end class queue

implement queue
class facts
monitorRegion : mutex := mutex::create(false).
remove_guard_event : event := event::create(true, toBoolean(remove_guard())).
element_fact : (integer Element) nondeterm.

clauses
insert(Element) :-
_W = monitorRegion:wait(),
try
assert(element_fact(Element))
finally
setGuardEvents(),
monitorRegion:release()
end try.

clauses
remove() = Element :-
_W = syncObject::waitAll([monitorRegion, remove_guard_event]),
try
retract(element_fact(Element)),
!;
common_exception::raise_error(common_exception::classInfo, predicate_name(),
"The guard should have ensured that the queue is not empty")
finally
setGuardEvents(),
monitorRegion:release()
end try.

class predicates
remove_guard : () determ.
clauses
remove_guard() :-
element_fact(_),
!.

class predicates
setGuardEvents : ().
clauses
setGuardEvents() :-
remove_guard_event:setSignaled(toBoolean(remove_guard())).
end implement queue</vip>
An '''event''' is created for each guard predicate; this event is set to ''signaled'' if the guard predicate succeeds. As mentioned it is set during the creation of the monitor and each time a predicate leaves the monitor (before it leaves the critical region).

When entering an entry the threads waits '''''both''''' for the '''monitorRegion''' and for the guard event to be in signalled state.

In the code above the initialization of the class itself and the guard events are done in an undetermined order. But actually it is ensured that the guard events are initialized after all other class/object initialization is performed.

=== Examples of practical usage ===

This section shows a few cases where monitors are handy.

==== Writing to a log file ====

Several threads needs to log information to a single log file.

<vip>monitor class log
properties
logStream : outputStream.
predicates
write : (...).
end class log

implement log
class facts
logStream : outputStream := erroneous.
clauses
write(...) :-
logStream:write(time::new():formatShortDate(), ": "),
logStream:write(...),
logStream:nl().
end implement log</vip>

The monitor ensures that writing of a log lines are not mixed with each other, and that stream changes only takes place between writing of log lines.

==== Shared output streams ====

This monitor can be used to thread protect the operations of an output stream:
<vip>monitor interface outputStream_sync
supports outputStream
end interface outputStream_sync

class outputStream_sync : outputStream_sync
constructors
new : (outputStream Stream).
end class outputStream_sync

implement outputStream_sync
delegate interface outputStream to stream

facts
stream : outputStream.

clauses
new(Stream) :- stream := Stream.
end implement outputStream_sync</vip>

You should realize however that with code like this:

<vip> clauses
write(...) :-
logStream:write(time::new():formatShortDate(), ": "),
logStream:write(...),
logStream:nl().</vip>

consists of '''''three separate''''' operations, so it can still be the case (fx) that two threads first write the time and then one writes the "...", etc.

==== Queue ====

The queue above is fine, but actually it may be better to create queue objects. Using generic interfaces we can create a very general queue:

<vip>monitor interface queue{@Elem}
predicates
enqueue : (@Elem Value).
predicates
dequeue : () -> @Elem Value.
end interface queue

class queue{@Elem} : queue{@Elem}
end class queue

implement queue{@Elem}
facts
value_fact : (@Elem Value).

clauses
enqueue(V) :-
assert(value_fact(V)).

clauses
dequeue guard { value_fact(_), ! }.
dequeue() = V :-
value_fact(V),
!.
dequeue() = V :-
common_exception::raise_error(....).
end implement queue</vip>

=== References ===

*[[wikipedia:Monitor (synchronization)]]

Language Reference/Monitors

2010-03-17T17:49:13Z

Elizabeth Safro: /* Guards */

{{Preliminary Documentation}}

{{languageReferenceNavbar|Monitors}}

A monitor is a language construction to synchronize two or more threads that use a shared resource, usually a hardware device or a set of variables. The compiler transparently inserts locking and unlocking code to appropriately designated procedures, instead of the programmer having to access concurrency primitives explicitly.

Visual Prolog monitor entrances can be controlled by guard predicates (conditions).

=== Syntax ===

Monitor interfaces and monitor classes are scopes:
<source lang="vipbnf"><Scope> : one of
...
<MonitorInterface>
<MonitorClass>
...
</source>
A monitor interface is defined by writing the keyword '''monitor''' in front of a regular interface definition:
<source lang="vipbnf"><MonitorInterface> :
monitor <IntertfaceDefinition></source>

A monitor class is declared by writing the keyword '''monitor''' in front of a regular class declaration:
<source lang="vipbnf"><MonitorClass> :
monitor <ClassDeclaration></source>
Monitor classes and interfaces cannot declare '''multi''' and '''nondeterm''' predicate members.

=== Restrictions ===

* A regular interface cannot support a monitor interface
* A monitor class cannot construct objects.
* It is not legal to inherit from a monitor (i.e. from a class that implements a monitor interface).

=== Semantics ===

The predicates and properties declared in a monitor are the '''''entrances''''' to the monitor. A thread enters the monitor through an entrance and is in the monitor until it leaves that entrance again. Only one thread is allowed to be in the monitor at the time. So each entry is protected as a critical region.

The semantics is simplest to understand as a program transformation (which is how it is implemented). Consider this academic example:
<vip>monitor class mmmm
predicates
e1 : (a1 A1).
e2 : (a2 A2).
...
en : (an An).
end class mmmm

implement mmmm
clauses
e1(A1) :- <B1>.

clauses
e2(A2) :- <B2>.

...
clauses
en(An) :- <Bn>.
end implement mmmm</vip> Where <B1>, <B2>, ..., <Bn> are clause bodies. This code corresponds to the following "normal" code:
<vip>class mmmm
predicates
e1 : (a1 A1).
e2 : (a2 A2).
...
en : (an An).
end class mmmm

implement mmmm
class facts
monitorRegion : mutex := mutex::create(false).

clauses
e1(A1) :-
_W = monitorRegion:wait(),
try
<B1>
finally
monitorRegion:release()
end try.

clauses
e2(A2) :-
_W = monitorRegion:wait(),
try
<B2>
finally
monitorRegion:release()
end try.
...
clauses
en(An) :-
_W = monitorRegion:wait(),
try
<Bn>
finally
monitorRegion:release()
end try.
end implement mmmm</vip>
So each monitor class is extended with a mutex, which is used to create a critical region around each entry body.

The code for monitor objects are similar, except that the mutex object is owned by the object.

=== Guards ===

Consider a monitor protected queue: some threads (''producers'') inserts elements in the queue and others (''consumers'') pick-out elements. However, you cannot pick-out elements if the queue is empty.

If we implement the queue using a monitor, the "pick-out" entry could be determ, failing if the queue is empty. But then the consumers would have to "poll" the queue until an element can be obtained. Such polling uses system resources, and normally it is desirable to avoid polling. This problem can be solved by guard predicates.

Each entry can have a guard associated in the implementation. The guard is added as a special guard-clause before the other clauses of the entry.

<vipbnf><Clause> : one of
...
<GuardClause>.</vipbnf>

<vipbnf><GuardClause> : one of
<LowerCaseIdentifier> guard <LowerCaseIdentifier> .
<LowerCaseIdentifier> guard <AnonymousPredicate> .</vipbnf>

{{Example| The guard can be the name of a predicate
<vip>
clauses
remove guard remove_guard.
remove() = ...</vip>}}

{{Example| The guard can also be an anonymous predicate
<vip>
clauses
remove guard { :- element_fact(_), ! }.
remove() = ...
</vip>}}

The guard predicates are evaluated when the monitor is created. For monitor classes this means at program start, for object predicates this is immediately after the construction of the object. The guard predicates are also evaluated whenever a tread leaves the monitor. But they are '''''not''''' evaluated at any other time.

If a certain guard succeeds the corresponding entry is ''open'', if it fails the entry is ''closed''.

It is only possible to enter open entries.

{{Example| Here is a queue class that solves the pick-out problem using a guard predicate on the '''remove''' operation:
<vip>monitor class queue
predicates
insert : (integer Element).
predicates
remove : () -> integer Element.
end class queue

implement queue
class facts
element_fact : (integer Element) nondeterm.

clauses
insert(Element) :-
assert(element_fact(Element)).

clauses
remove guard remove_guard.
remove() = Element :-
retract(element_fact(Element)),
!;
common_exception::raise_error(common_exception::classInfo, predicate_name(),
"The guard should have ensured that the queue is not empty").

predicates
remove_quard : () determ.
clauses
remove_guard() :-
element_fact(_),
!.
end implement queue</vip>
Notice that '''remove''' is a procedure, because threads that call remove will '''''wait''''' until there is an element for them. The guard predicate '''remove_guard''' succeeds if there is an element in the queue.

So '''remove_guard''' is evaluated each time a thread leaves the monitor, and the '''element_fact''' fact database can only be changed by a thread that is inside the monitor. Therefore the guard value stays sensible all the time (i.e. when there are no threads in the monitor). It is important to ensure such "stays sensible" condition for guards.
}}

Guard predicates are handled in the transformation mentioned above. The queue example is effectively the same as this "monitor-free" code:
<vip>class queue
predicates
insert : (integer Element).
predicates
remove : () -> integer Element.
end class queue

implement queue
class facts
monitorRegion : mutex := mutex::create(false).
remove_guard_event : event := event::create(true, toBoolean(remove_guard())).
element_fact : (integer Element) nondeterm.

clauses
insert(Element) :-
_W = monitorRegion:wait(),
try
assert(element_fact(Element))
finally
setGuardEvents(),
monitorRegion:release()
end try.

clauses
remove() = Element :-
_W = syncObject::waitAll([monitorRegion, remove_guard_event]),
try
retract(element_fact(Element)),
!;
common_exception::raise_error(common_exception::classInfo, predicate_name(),
"The guard should have ensured that the queue is not empty")
finally
setGuardEvents(),
monitorRegion:release()
end try.

class predicates
remove_guard : () determ.
clauses
remove_guard() :-
element_fact(_),
!.

class predicates
setGuardEvents : ().
clauses
setGuardEvents() :-
remove_guard_event:setSignaled(toBoolean(remove_guard())).
end implement queue</vip>
An '''event''' is created for each guard predicate; this event is set to ''signaled'' if the guard predicate succeeds. As mentioned it is set during the creation of the monitor and each time a predicate leaves the monitor (before it leaves the critical region).

When entering an entry the threads waits '''''both''''' for the '''monitorRegion''' and for the guard event to be in signalled state.

In the code above the initialization of the class itself and the guard events are done in an undetermined order. But actually it is ensured that the guard events are initialized after all other class/object initialization is performed.

=== Examples of practical usage ===

This section shows a few cases where monitors are handy.

==== Writing to a log file ====

Several threads needs to log information to a single log file.

<vip>monitor class log
properties
logStream : outputStream.
predicates
write : (...).
end class log

implement log
class facts
logStream : outputStream := erroneous.
clauses
write(...) :-
logStream:write(time::new():formatShortDate(), ": "),
logStream:write(...),
logStream:nl().
end implement log</vip>

The monitor ensures that writing of a log lines are not mixed with each other, and that stream changes only takes place between writing of log lines.

==== Shared output streams ====

This monitor can be used to thread protect the operations of an output stream:
<vip>monitor interface outputStream_sync
supports outputStream
end interface outputStream_sync

class outputStream_sync : outputStream_sync
constructors
new : (outputStream Stream).
end class outputStream_sync

implement outputStream_sync
delegate interface outputStream to stream

facts
stream : outputStream.

clauses
new(Stream) :- stream := Stream.
end implement outputStream_sync</vip>

You should realize however that with code like this:

<vip> clauses
write(...) :-
logStream:write(time::new():formatShortDate(), ": "),
logStream:write(...),
logStream:nl().</vip>

consists of '''''three separate''''' opeations, so it can still be the case (fx) that two threads first write the time and then one writes the "...", etc.

==== Queue ====

The queue above is fine, but actually it may be better to create queue objects. Using generic interfaces we can create a very general queue:

<vip>monitor interface queue{@Elem}
predicates
enqueue : (@Elem Value).
predicates
dequeue : () -> @Elem Value.
end interface queue

class queue{@Elem} : queue{@Elem}
end class queue

implement queue{@Elem}
facts
value_fact : (@Elem Value).

clauses
enqueue(V) :-
assert(value_fact(V)).

clauses
dequeue guard { value_fact(_), ! }.
dequeue() = V :-
value_fact(V),
!.
dequeue() = V :-
common_exception::raise_error(....).
end implement queue</vip>

=== References ===

*[[wikipedia:Monitor (synchronization)]]

Language Reference/Monitors

2010-03-17T17:42:43Z

Elizabeth Safro: /* Guards */

{{Preliminary Documentation}}

{{languageReferenceNavbar|Monitors}}

A monitor is a language construction to synchronize two or more threads that use a shared resource, usually a hardware device or a set of variables. The compiler transparently inserts locking and unlocking code to appropriately designated procedures, instead of the programmer having to access concurrency primitives explicitly.

Visual Prolog monitor entrances can be controlled by guard predicates (conditions).

=== Syntax ===

Monitor interfaces and monitor classes are scopes:
<source lang="vipbnf"><Scope> : one of
...
<MonitorInterface>
<MonitorClass>
...
</source>
A monitor interface is defined by writing the keyword '''monitor''' in front of a regular interface definition:
<source lang="vipbnf"><MonitorInterface> :
monitor <IntertfaceDefinition></source>

A monitor class is declared by writing the keyword '''monitor''' in front of a regular class declaration:
<source lang="vipbnf"><MonitorClass> :
monitor <ClassDeclaration></source>
Monitor classes and interfaces cannot declare '''multi''' and '''nondeterm''' predicate members.

=== Restrictions ===

* A regular interface cannot support a monitor interface
* A monitor class cannot construct objects.
* It is not legal to inherit from a monitor (i.e. from a class that implements a monitor interface).

=== Semantics ===

The predicates and properties declared in a monitor are the '''''entrances''''' to the monitor. A thread enters the monitor through an entrance and is in the monitor until it leaves that entrance again. Only one thread is allowed to be in the monitor at the time. So each entry is protected as a critical region.

The semantics is simplest to understand as a program transformation (which is how it is implemented). Consider this academic example:
<vip>monitor class mmmm
predicates
e1 : (a1 A1).
e2 : (a2 A2).
...
en : (an An).
end class mmmm

implement mmmm
clauses
e1(A1) :- <B1>.

clauses
e2(A2) :- <B2>.

...
clauses
en(An) :- <Bn>.
end implement mmmm</vip> Where <B1>, <B2>, ..., <Bn> are clause bodies. This code corresponds to the following "normal" code:
<vip>class mmmm
predicates
e1 : (a1 A1).
e2 : (a2 A2).
...
en : (an An).
end class mmmm

implement mmmm
class facts
monitorRegion : mutex := mutex::create(false).

clauses
e1(A1) :-
_W = monitorRegion:wait(),
try
<B1>
finally
monitorRegion:release()
end try.

clauses
e2(A2) :-
_W = monitorRegion:wait(),
try
<B2>
finally
monitorRegion:release()
end try.
...
clauses
en(An) :-
_W = monitorRegion:wait(),
try
<Bn>
finally
monitorRegion:release()
end try.
end implement mmmm</vip>
So each monitor class is extended with a mutex, which is used to create a critical region around each entry body.

The code for monitor objects are similar, except that the mutex object is owned by the object.

=== Guards ===

Consider a monitor protected queue: some threads (''producers'') inserts elements in the queue and others (''consumers'') pick-out elements. However, you cannot pick-out elements if the queue is empty.

If we implement the queue using a monitor, the "pick-out" entry could be determ, failing if the queue is empty. But then the consumers would have to "poll" the queue until an element can be obtained. Such polling uses system resources, and normally it is desirable to avoid polling. This problem can be solved by guard predicates.

Each entry can have a guard associated in the implementation. The guard is added as a special guard-clause before the other clauses of the entry.

<vipbnf><Clause> : one of
...
<GuardClause>.</vipbnf>

<vipbnf><GuardClause> : one of
<LowerCaseIdentifier> guard <LowerCaseIdentifier> .
<LowerCaseIdentifier> guard <AnonymousPredicate> .</vipbnf>

{{Example| The guard can be the name of a predicate
<vip>
clauses
remove guard remove_guard.
remove() = ...</vip>}}

{{Example| The guard can also be an anonymous predicate
<vip>
clauses
remove guard { :- element_fact(_), ! }.
remove() = ...
</vip>}}

The guard predicates are evaluated when the monitor is created. For monitor classes this means at program start, for object predicates this is immediately after the construction of the object. The guard predicates are also evaluated whenever a tread leaves the monitor. But they are '''''not''''' evaluated at any other time.

If a certain guard succeeds the corresponding entry is ''open'', if it fails the entry is ''closed''.

It is only possible to enter open entries.

{{Example| Here is a queue class that solves the pick-out problem using a guard predicate on the '''remove''' operation:
<vip>monitor class queue
predicates
insert : (integer Element).
predicates
remove : () -> integer Element.
end class queue

implement queue
class facts
element_fact : (integer Element) nondeterm.

clauses
insert(Element) :-
assert(element_fact(Element)).

clauses
remove guard remove_guard.
remove() = Element :-
retract(element_fact(Element)),
!;
common_exception::raise_error(common_exception::classInfo, predicate_name(),
"The guard should have ensured that the queue is not empty").

predicates
remove_quard : () determ.
clauses
remove_guard() :-
element_fact(_),
!.
end implement queue</vip>
Notice that '''remove''' is a procedure, because threads that call remove will '''''wait''''' until there is an element for them. The guard predicate '''remove_guard''' succeeds if there is an element in the queue.

So '''remove_guard''' is evaluated each time a thread leaves the monitor, and the '''element_fact''' fact database can only be changed by a thread that is inside the monitor. Therefore the guard value stays sensible all the time (i.e. when there are no threads in the monitor). It is important to ensure such "stays sensible" condition for guards.
}}

Guard predicates are handled in the transformation mentioned above. The queue example is effectively the same as this "monitor-free" code:
<vip>class queue
predicates
insert : (integer Element).
predicates
remove : () -> integer Element.
end class queue

implement queue
class facts
monitorRegion : mutex := mutex::create(false).
remove_guard_event : event := event::create(true, toBoolean(remove_guard())).
element_fact : (integer Element) nondeterm.

clauses
insert(Element) :-
_W = monitorRegion:wait(),
try
assert(element_fact(Element))
finally
setGuardEvents(),
monitorRegion:release()
end try.

clauses
remove() = Element :-
_W = syncObject::waitAll([monitorRegion, remove_guard_event]),
try
retract(element_fact(Element)),
!;
common_exception::raise_error(common_exception::classInfo, predicate_name(),
"The guard should have ensured that the queue is not empty")
finally
setGuardEvents(),
monitorRegion:release()
end try.

class predicates
remove_guard : () determ.
clauses
remove_guard() :-
element_fact(_),
!.

class predicates
setGuardEvents : ().
clauses
setGuardEvents() :-
remove_guard_event:setSignaled(toBoolean(remove_guard())).
end implement queue</vip>
An '''event''' is created for each guard predicate; this event is set to ''signaled'' if the guard predicate succeeds. As mentioned it is set during the creation of the monitor and each time a predicate leaves the monitor (before it leaves the critical region).

When entering an entry the threads waits '''''both''''' for the '''monitorRegion''' and for the guard event to be in signalled state.

In the code above the initialization of the class itself and the guard events are done in an undetermined order. But actually it is ensured that the guard events are initialized after all ohter class/object initialization is performed.

=== Examples of practical usage ===

This section shows a few cases where monitors are handy.

==== Writing to a log file ====

Several threads needs to log information to a single log file.

<vip>monitor class log
properties
logStream : outputStream.
predicates
write : (...).
end class log

implement log
class facts
logStream : outputStream := erroneous.
clauses
write(...) :-
logStream:write(time::new():formatShortDate(), ": "),
logStream:write(...),
logStream:nl().
end implement log</vip>

The monitor ensures that writing of a log lines are not mixed with each other, and that stream changes only takes place between writing of log lines.

==== Shared output streams ====

This monitor can be used to thread protect the operations of an output stream:
<vip>monitor interface outputStream_sync
supports outputStream
end interface outputStream_sync

class outputStream_sync : outputStream_sync
constructors
new : (outputStream Stream).
end class outputStream_sync

implement outputStream_sync
delegate interface outputStream to stream

facts
stream : outputStream.

clauses
new(Stream) :- stream := Stream.
end implement outputStream_sync</vip>

You should realize however that with code like this:

<vip> clauses
write(...) :-
logStream:write(time::new():formatShortDate(), ": "),
logStream:write(...),
logStream:nl().</vip>

consists of '''''three separate''''' opeations, so it can still be the case (fx) that two threads first write the time and then one writes the "...", etc.

==== Queue ====

The queue above is fine, but actually it may be better to create queue objects. Using generic interfaces we can create a very general queue:

<vip>monitor interface queue{@Elem}
predicates
enqueue : (@Elem Value).
predicates
dequeue : () -> @Elem Value.
end interface queue

class queue{@Elem} : queue{@Elem}
end class queue

implement queue{@Elem}
facts
value_fact : (@Elem Value).

clauses
enqueue(V) :-
assert(value_fact(V)).

clauses
dequeue guard { value_fact(_), ! }.
dequeue() = V :-
value_fact(V),
!.
dequeue() = V :-
common_exception::raise_error(....).
end implement queue</vip>

=== References ===

*[[wikipedia:Monitor (synchronization)]]

Language Reference/Monitors

2010-03-17T17:38:39Z

Elizabeth Safro: /* Guards */

{{Preliminary Documentation}}

{{languageReferenceNavbar|Monitors}}

A monitor is a language construction to synchronize two or more threads that use a shared resource, usually a hardware device or a set of variables. The compiler transparently inserts locking and unlocking code to appropriately designated procedures, instead of the programmer having to access concurrency primitives explicitly.

Visual Prolog monitor entrances can be controlled by guard predicates (conditions).

=== Syntax ===

Monitor interfaces and monitor classes are scopes:
<source lang="vipbnf"><Scope> : one of
...
<MonitorInterface>
<MonitorClass>
...
</source>
A monitor interface is defined by writing the keyword '''monitor''' in front of a regular interface definition:
<source lang="vipbnf"><MonitorInterface> :
monitor <IntertfaceDefinition></source>

A monitor class is declared by writing the keyword '''monitor''' in front of a regular class declaration:
<source lang="vipbnf"><MonitorClass> :
monitor <ClassDeclaration></source>
Monitor classes and interfaces cannot declare '''multi''' and '''nondeterm''' predicate members.

=== Restrictions ===

* A regular interface cannot support a monitor interface
* A monitor class cannot construct objects.
* It is not legal to inherit from a monitor (i.e. from a class that implements a monitor interface).

=== Semantics ===

The predicates and properties declared in a monitor are the '''''entrances''''' to the monitor. A thread enters the monitor through an entrance and is in the monitor until it leaves that entrance again. Only one thread is allowed to be in the monitor at the time. So each entry is protected as a critical region.

The semantics is simplest to understand as a program transformation (which is how it is implemented). Consider this academic example:
<vip>monitor class mmmm
predicates
e1 : (a1 A1).
e2 : (a2 A2).
...
en : (an An).
end class mmmm

implement mmmm
clauses
e1(A1) :- <B1>.

clauses
e2(A2) :- <B2>.

...
clauses
en(An) :- <Bn>.
end implement mmmm</vip> Where <B1>, <B2>, ..., <Bn> are clause bodies. This code corresponds to the following "normal" code:
<vip>class mmmm
predicates
e1 : (a1 A1).
e2 : (a2 A2).
...
en : (an An).
end class mmmm

implement mmmm
class facts
monitorRegion : mutex := mutex::create(false).

clauses
e1(A1) :-
_W = monitorRegion:wait(),
try
<B1>
finally
monitorRegion:release()
end try.

clauses
e2(A2) :-
_W = monitorRegion:wait(),
try
<B2>
finally
monitorRegion:release()
end try.
...
clauses
en(An) :-
_W = monitorRegion:wait(),
try
<Bn>
finally
monitorRegion:release()
end try.
end implement mmmm</vip>
So each monitor class is extended with a mutex, which is used to create a critical region around each entry body.

The code for monitor objects are similar, except that the mutex object is owned by the object.

=== Guards ===

Consider a monitor protected queue: some threads (''producers'') inserts elements in the queue and others (''consumers'') pick-out elements. However, you cannot pick-out elements if the queue is empty.

If we implement the queue using a monitor, the "pick-out" entry could be determ, failing if the queue is empty. But then the consumers would have to "poll" the queue until an element can be obtained. Such polling uses system resources, and normally it is desirable to avoid polling. This problem can be solved by guard predicates.

Each entry can have a guard associated in the implementation. The guard is added as a special guard-clause before the other clauses of the entry.

<vipbnf><Clause> : one of
...
<GuardClause>.</vipbnf>

<vipbnf><GuardClause> : one of
<LowerCaseIdentifier> guard <LowerCaseIdentifier> .
<LowerCaseIdentifier> guard <AnonymousPredicate> .</vipbnf>

{{Example| The guard can be the name of a predicate
<vip>
clauses
remove guard remove_guard.
remove() = ...</vip>}}

{{Example| The guard can also be an anonymous predicate
<vip>
clauses
remove guard { :- element_fact(_), ! }.
remove() = ...
</vip>}}

The guard predicates are evaluated when the monitor is created. For monitor classes this means at program start, for object predicates this is immediately after the construction of the object. The guard predicates are also evaluated whenever a tread leaves the monitor. But they are '''''not''''' evaluated at any other time.

If a certain guard succeeds the corresponding entry is ''open'', if it fails the entry is ''closed''.

It is only possible to enter open entries.

{{Example| Here is a queue class that solves the pick-out problem using a guard predicate on the '''remove''' operation:
<vip>monitor class queue
predicates
insert : (integer Element).
predicates
remove : () -> integer Element.
end class queue

implement queue
class facts
element_fact : (integer Element) nondeterm.

clauses
insert(Element) :-
assert(element_fact(Element)).

clauses
remove guard remove_guard.
remove() = Element :-
retract(element_fact(Element)),
!;
common_exception::raise_error(common_exception::classInfo, predicate_name(),
"The guard should have ensured that the queue is not empty").

predicates
remove_quard : () determ.
clauses
remove_guard() :-
element_fact(_),
!.
end implement queue</vip>
Notice that '''remove''' is a procedure, because threads that call remove will '''''wait''''' until there is an element for them. The guard predicate '''remove_guard''' succeeds if there is an element in the queue.

So '''remove_guard''' is evaluated each time a thread leaves the monitor, and the '''element_fact''' fact database can only be changed by a thread that is inside the monitor. Therefore the guard value stays sensible all the time (i.e. when there are no threads in the monitor). It is important to ensure such "stays sensible" condition for guards.
}}

Guard predicates are handled in the transformation mentioned above. The queue example is effectively the same as this "monitor-free" code:
<vip>class queue
predicates
insert : (integer Element).
predicates
remove : () -> integer Element.
end class queue

implement queue
class facts
monitorRegion : mutex := mutex::create(false).
remove_guard_event : event := event::create(true, toBoolean(remove_guard())).
element_fact : (integer Element) nondeterm.

clauses
insert(Element) :-
_W = monitorRegion:wait(),
try
assert(element_fact(Element))
finally
setGuardEvents(),
monitorRegion:release()
end try.

clauses
remove() = Element :-
_W = syncObject::waitAll([monitorRegion, remove_guard_event]),
try
retract(element_fact(Element)),
!;
common_exception::raise_error(common_exception::classInfo, predicate_name(),
"The guard should have ensured that the queue is not empty")
finally
setGuardEvents(),
monitorRegion:release()
end try.

class predicates
remove_guard : () determ.
clauses
remove_guard() :-
element_fact(_),
!.

class predicates
setGuardEvents : ().
clauses
setGuardEvents() :-
remove_guard_event:setSignaled(toBoolean(remove_guard())).
end implement queue</vip>
An '''event''' is created for each guard predicate, this event is set to ''signaled'' if the guard predicate succeeds. As mentioned it is set during the creation of the monitor and each time a predicate leaves the monitor (before it leaves the critical region).

When entering an entry the threads waits '''''both''''' for the '''monitorRegion''' and for the guard event to be in signalled state.

In the code above the initialization of the class itself and the guard events are done in an undetermined order. But actually it is ensured that the guard events are initialized after all ohter class/object initialization is performed.

=== Examples of practical usage ===

This section shows a few cases where monitors are handy.

==== Writing to a log file ====

Several threads needs to log information to a single log file.

<vip>monitor class log
properties
logStream : outputStream.
predicates
write : (...).
end class log

implement log
class facts
logStream : outputStream := erroneous.
clauses
write(...) :-
logStream:write(time::new():formatShortDate(), ": "),
logStream:write(...),
logStream:nl().
end implement log</vip>

The monitor ensures that writing of a log lines are not mixed with each other, and that stream changes only takes place between writing of log lines.

==== Shared output streams ====

This monitor can be used to thread protect the operations of an output stream:
<vip>monitor interface outputStream_sync
supports outputStream
end interface outputStream_sync

class outputStream_sync : outputStream_sync
constructors
new : (outputStream Stream).
end class outputStream_sync

implement outputStream_sync
delegate interface outputStream to stream

facts
stream : outputStream.

clauses
new(Stream) :- stream := Stream.
end implement outputStream_sync</vip>

You should realize however that with code like this:

<vip> clauses
write(...) :-
logStream:write(time::new():formatShortDate(), ": "),
logStream:write(...),
logStream:nl().</vip>

consists of '''''three separate''''' opeations, so it can still be the case (fx) that two threads first write the time and then one writes the "...", etc.

==== Queue ====

The queue above is fine, but actually it may be better to create queue objects. Using generic interfaces we can create a very general queue:

<vip>monitor interface queue{@Elem}
predicates
enqueue : (@Elem Value).
predicates
dequeue : () -> @Elem Value.
end interface queue

class queue{@Elem} : queue{@Elem}
end class queue

implement queue{@Elem}
facts
value_fact : (@Elem Value).

clauses
enqueue(V) :-
assert(value_fact(V)).

clauses
dequeue guard { value_fact(_), ! }.
dequeue() = V :-
value_fact(V),
!.
dequeue() = V :-
common_exception::raise_error(....).
end implement queue</vip>

=== References ===

*[[wikipedia:Monitor (synchronization)]]

Language Reference/Monitors

2010-03-17T17:36:58Z

Elizabeth Safro:

{{Preliminary Documentation}}

{{languageReferenceNavbar|Monitors}}

A monitor is a language construction to synchronize two or more threads that use a shared resource, usually a hardware device or a set of variables. The compiler transparently inserts locking and unlocking code to appropriately designated procedures, instead of the programmer having to access concurrency primitives explicitly.

Visual Prolog monitor entrances can be controlled by guard predicates (conditions).

=== Syntax ===

Monitor interfaces and monitor classes are scopes:
<source lang="vipbnf"><Scope> : one of
...
<MonitorInterface>
<MonitorClass>
...
</source>
A monitor interface is defined by writing the keyword '''monitor''' in front of a regular interface definition:
<source lang="vipbnf"><MonitorInterface> :
monitor <IntertfaceDefinition></source>

A monitor class is declared by writing the keyword '''monitor''' in front of a regular class declaration:
<source lang="vipbnf"><MonitorClass> :
monitor <ClassDeclaration></source>
Monitor classes and interfaces cannot declare '''multi''' and '''nondeterm''' predicate members.

=== Restrictions ===

* A regular interface cannot support a monitor interface
* A monitor class cannot construct objects.
* It is not legal to inherit from a monitor (i.e. from a class that implements a monitor interface).

=== Semantics ===

The predicates and properties declared in a monitor are the '''''entrances''''' to the monitor. A thread enters the monitor through an entrance and is in the monitor until it leaves that entrance again. Only one thread is allowed to be in the monitor at the time. So each entry is protected as a critical region.

The semantics is simplest to understand as a program transformation (which is how it is implemented). Consider this academic example:
<vip>monitor class mmmm
predicates
e1 : (a1 A1).
e2 : (a2 A2).
...
en : (an An).
end class mmmm

implement mmmm
clauses
e1(A1) :- <B1>.

clauses
e2(A2) :- <B2>.

...
clauses
en(An) :- <Bn>.
end implement mmmm</vip> Where <B1>, <B2>, ..., <Bn> are clause bodies. This code corresponds to the following "normal" code:
<vip>class mmmm
predicates
e1 : (a1 A1).
e2 : (a2 A2).
...
en : (an An).
end class mmmm

implement mmmm
class facts
monitorRegion : mutex := mutex::create(false).

clauses
e1(A1) :-
_W = monitorRegion:wait(),
try
<B1>
finally
monitorRegion:release()
end try.

clauses
e2(A2) :-
_W = monitorRegion:wait(),
try
<B2>
finally
monitorRegion:release()
end try.
...
clauses
en(An) :-
_W = monitorRegion:wait(),
try
<Bn>
finally
monitorRegion:release()
end try.
end implement mmmm</vip>
So each monitor class is extended with a mutex, which is used to create a critical region around each entry body.

The code for monitor objects are similar, except that the mutex object is owned by the object.

=== Guards ===

Consider a monitor protected queue: some threads (''producers'') inserts elements in the queue and others (''consumers'') pick-out elements. However, you cannot pick-out elements if the queue is empty.

If we implement the queue using a monitor, the "pick-out" entry could be determ, failing if the queue is empty. But then the consumers would have to "poll" the queue until an element can be obtained. Such polling uses system resources, and normally it is desirable to avoid polling. This problem can be solved by guard predicates.

Each entry can have a guard associated in the implementation. The quard is added as a special guard-clause before the other clauses of the entry.

<vipbnf><Clause> : one of
...
<GuardClause>.</vipbnf>

<vipbnf><GuardClause> : one of
<LowerCaseIdentifier> guard <LowerCaseIdentifier> .
<LowerCaseIdentifier> guard <AnonymousPredicate> .</vipbnf>

{{Example| The guard can be the name of a predicate
<vip>
clauses
remove guard remove_guard.
remove() = ...</vip>}}

{{Example| The guard can also be an anonymous predicate
<vip>
clauses
remove guard { :- element_fact(_), ! }.
remove() = ...
</vip>}}

The guard predicates are evaluated when the monitor is created. For monitor classes this means at program start, for object predicates this is immediately after the construction of the object. The guard predicates are also evaluated whenever a tread leaves the monitor. But they are '''''not''''' evaluated at any other time.

If a certain guard succeeds the corresponding entry is ''open'', if it fails the entry is ''closed''.

It is only possible to enter open entries.

{{Example| Here is a queue class that solves the pick-out problem using a guard predicate on the '''remove''' operation:
<vip>monitor class queue
predicates
insert : (integer Element).
predicates
remove : () -> integer Element.
end class queue

implement queue
class facts
element_fact : (integer Element) nondeterm.

clauses
insert(Element) :-
assert(element_fact(Element)).

clauses
remove guard remove_guard.
remove() = Element :-
retract(element_fact(Element)),
!;
common_exception::raise_error(common_exception::classInfo, predicate_name(),
"The guard should have ensured that the queue is not empty").

predicates
remove_quard : () determ.
clauses
remove_guard() :-
element_fact(_),
!.
end implement queue</vip>
Notice that '''remove''' is a procedure, because threads that call remove will '''''wait''''' until there is an element for them. The guard predicate '''remove_guard''' succeeds if there is an element in the queue.

So '''remove_guard''' is evaluated each time a thread leaves the monitor, and the '''element_fact''' fact database can only be changed by a thread that is inside the monitor. Therefore the guard value stays sensible all the time (i.e. when there are no threads in the monitor). It is important to ensure such "stays sensible" condition for guards.
}}

Guard predicates are handled in the transformation mentioned above. The queue example is effectively the same as this "monitor-free" code:
<vip>class queue
predicates
insert : (integer Element).
predicates
remove : () -> integer Element.
end class queue

implement queue
class facts
monitorRegion : mutex := mutex::create(false).
remove_guard_event : event := event::create(true, toBoolean(remove_guard())).
element_fact : (integer Element) nondeterm.

clauses
insert(Element) :-
_W = monitorRegion:wait(),
try
assert(element_fact(Element))
finally
setGuardEvents(),
monitorRegion:release()
end try.

clauses
remove() = Element :-
_W = syncObject::waitAll([monitorRegion, remove_guard_event]),
try
retract(element_fact(Element)),
!;
common_exception::raise_error(common_exception::classInfo, predicate_name(),
"The guard should have ensured that the queue is not empty")
finally
setGuardEvents(),
monitorRegion:release()
end try.

class predicates
remove_guard : () determ.
clauses
remove_guard() :-
element_fact(_),
!.

class predicates
setGuardEvents : ().
clauses
setGuardEvents() :-
remove_guard_event:setSignaled(toBoolean(remove_guard())).
end implement queue</vip>
An '''event''' is created for each guard predicate, this event is set to ''signaled'' if the guard predicate succeeds. As mentioned it is set during the creation of the monitor and each time a predicate leaves the monitor (before it leaves the critical region).

When entering an entry the threads waits '''''both''''' for the '''monitorRegion''' and for the guard event to be in signalled state.

In the code above the initialization of the class itself and the guard events are done in an undetermined order. But actually it is ensured that the guard events are initialized after all ohter class/object initialization is performed.

=== Examples of practical usage ===

This section shows a few cases where monitors are handy.

==== Writing to a log file ====

Several threads needs to log information to a single log file.

<vip>monitor class log
properties
logStream : outputStream.
predicates
write : (...).
end class log

implement log
class facts
logStream : outputStream := erroneous.
clauses
write(...) :-
logStream:write(time::new():formatShortDate(), ": "),
logStream:write(...),
logStream:nl().
end implement log</vip>

The monitor ensures that writing of a log lines are not mixed with each other, and that stream changes only takes place between writing of log lines.

==== Shared output streams ====

This monitor can be used to thread protect the operations of an output stream:
<vip>monitor interface outputStream_sync
supports outputStream
end interface outputStream_sync

class outputStream_sync : outputStream_sync
constructors
new : (outputStream Stream).
end class outputStream_sync

implement outputStream_sync
delegate interface outputStream to stream

facts
stream : outputStream.

clauses
new(Stream) :- stream := Stream.
end implement outputStream_sync</vip>

You should realize however that with code like this:

<vip> clauses
write(...) :-
logStream:write(time::new():formatShortDate(), ": "),
logStream:write(...),
logStream:nl().</vip>

consists of '''''three separate''''' opeations, so it can still be the case (fx) that two threads first write the time and then one writes the "...", etc.

==== Queue ====

The queue above is fine, but actually it may be better to create queue objects. Using generic interfaces we can create a very general queue:

<vip>monitor interface queue{@Elem}
predicates
enqueue : (@Elem Value).
predicates
dequeue : () -> @Elem Value.
end interface queue

class queue{@Elem} : queue{@Elem}
end class queue

implement queue{@Elem}
facts
value_fact : (@Elem Value).

clauses
enqueue(V) :-
assert(value_fact(V)).

clauses
dequeue guard { value_fact(_), ! }.
dequeue() = V :-
value_fact(V),
!.
dequeue() = V :-
common_exception::raise_error(....).
end implement queue</vip>

=== References ===

*[[wikipedia:Monitor (synchronization)]]

Language Reference/Attributes

2010-03-17T17:26:50Z

Elizabeth Safro:

{{Preliminary Documentation}}

{{languageReferenceNavbar|Attributes}}

Various definitions and declarations can be annotated with attributes. This section describes the general syntax of attributes and where they can be placed. It also describes the meaning of the specific attributes.

=== Syntax ===

<vipbnf><Attributes> :
[ <Attribute>-comma-sep-list ]</vipbnf>

<vipbnf><Attribute> : one of
<LowerCaseIdentifier>
<LowerCaseIdentifier> ( <Literal>-comma-sep-list )</vipbnf>

where the literals must either be numbers or string literals.

=== Insertion Points ===

The attributes of interfaces, classes and implementations are right before the scope qualifications.

<vipbnf><InterfaceDeclaration> :
interface <IinterfaceName> <Attributes>-opt <ScopeQualifications> <Sections> end interface <IinterfaceName>-opt</vipbnf>

<vipbnf><ClassDeclaration> :
class <ClassName> <ConstructionType>-opt <Attributes>-opt <ScopeQualifications> <Sections> end class <ClassName>-opt</vipbnf>

<vipbnf><ClassImplementation> :
implement <ClassName> <Attributes>-opt <ScopeQualifications> <Sections> end implement <ClassName>-opt</vipbnf>

The attributes of constants, domains, predicates, properties and facts are at the end (i.e. right before the terminating dot).

<vipbnf><ConstantDefinition>: one of
<ConstantName> = <ConstantValue> <Attributes>-opt
<ConstantName> : <TypeName> = <ConstantValue> <Attributes>-opt</vipbnf>

<vipbnf><DomainDefinition>:
<DomainName> <FormalTypeParameterList>-opt = <TypeExpression> <Attributes>-opt</vipbnf>

<vipbnf><PredicateDeclaration> :
<PredicateName> : <PredicateDomain> <LinkName>-opt <Attributes>-opt
<PredicateName> : <PredicateDomainName> <LinkName>-opt <Attributes>-opt</vipbnf>

<vipbnf><PropertyDeclaration> :
<PropertyName> : <PropertyType> <FlowPattern>-list-opt <Attributes>-opt</vipbnf>

<vipbnf><FactDeclaration> :
<FactVariableDeclaration> <Attributes>-opt
<FactFunctorDeclaration> <Attributes>-opt</vipbnf>

The attributes of formal arguments are at the end.

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

=== Specific Attributes ===

==== byVal ====

An argument is transferred directly on the stack rather than using a pointer. Valid for formal predicate arguments provided the <vp>language</vp> is <vp>stdcall</vp>, <vp>apicall</vp> or <vp>c</vp>.

{{Example|
<vip>predicates
externalP : (point Point [byVal]) language apicall.</vip>
}}

==== deprecated ====

The declared entity is deprecated. The string literal describes how to migrate from it. The entity still exist, but usage will cause a warning.
The entity will not exist in future versions of Visual Prolog. Valid for member declarations and scopes.

{{Example|
<vip>predicates
oldFasioned : (string Arg) [deprecated("Use newFasion instead")].</vip>
}}

==== formatString ====

The argument is a {{lang2|Domains|Format Strings|format string}} for a subsequent ellipsis argument (i.e. <vp>...</vp>). Valid for one string argument of a predicate with an ellipsis argument. The use of formatString will make the compiler check the validity of actual arguments with respect to actual format strings (where possible).

{{Example|
<vip>predicates
writef : (string Format [formatString], ...).</vip>
}}

==== in ====

The argument is an input argument. Valid for a formal predicate argument.

{{Example|
<vip>predicates
pred : (string InputArg [in]).</vip>
}}

==== inline ====

<vp>inline</vp> alters the memory layout of a struct (i.e. a single alternative functor domain with an align qualification). The corresponding field is inlined instead of being pointed to.

{{Example|
<vip>domains
point = align 4
p(integer X, integer Y).

domains
rectangle = align 4
r(
point UpperLeft [inline],
point LowerRight [inline]
).</vip>
}}

It is also possible to inline fixed size string and string8 fields in structs:

{{Example|
<vip>domains
device = align 4
device(
integer Id,
string DeviceName [inline(32)]
).</vip>
}}

==== noDefaultConstructor ====

Used for a class to indicate that it should not have an implicit default constructor, and can thus be used to a class that does not have any constructors at all. Valid for an object creating class declaration.

{{Example|
<vip>class classWithoutPublicConstructors : myInterface
[noDefaultConstructor]
...
end class classWithoutPublicConstructors</vip>
}}

==== out ====

The argument is an output argument. Valid for a formal predicate argument.

{{Example|
<vip>predicates
pred : (string OutputArg [out]).</vip>
}}

==== retired ====

The declared entity is retired. The string literal describes how to migrate from it. The entity does not exist anymore.

{{Example|
<vip>predicates
veryOldFasioned : (string Arg) [retired("Use newFasion instead")].</vip>
}}

==== union ====

Used for creating functor domains with several alternatives but no real functors. This should only be used to mimic C/C++ union structs in low-level interfacing. Valid for functor domain with several alternatives and alignment.

{{Example|
<vip>domains
u64var = align 4
u64(unsigned64 Value64);
u64_struct(unsigned Low32, unsigned High32)
[union].</vip>
}}

==== used ====

An unused local member can be marked <vp>used</vp> to prevent the compiler to issue a warning and remove the corresponding code. Valid for local members.

{{Example|
<vip>predicates
seeminglyUnused : () [used].</vip>
}}

Language Reference/Attributes

2010-03-17T17:24:13Z

Elizabeth Safro: /* Insertion Points */

{{Preliminary Documentation}}

{{languageReferenceNavbar|Attributes}}

Various definitions and declarations can be annotated with attributes. This section describes the general syntax of attributes and where they can be placed. It also describes the meaning of the specific attributes.

=== Syntax ===

<vipbnf><Attributes> :
[ <Attribute>-comma-sep-list ]</vipbnf>

<vipbnf><Attribute> : one of
<LowerCaseIdentifier>
<LowerCaseIdentifier> ( <Literal>-comma-sep-list )</vipbnf>

Where the literals must either be numbers or string literals.

=== Insertion Points ===

The attributes of interfaces, classes and implementations are right before the scope qualifications.

<vipbnf><InterfaceDeclaration> :
interface <IinterfaceName> <Attributes>-opt <ScopeQualifications> <Sections> end interface <IinterfaceName>-opt</vipbnf>

<vipbnf><ClassDeclaration> :
class <ClassName> <ConstructionType>-opt <Attributes>-opt <ScopeQualifications> <Sections> end class <ClassName>-opt</vipbnf>

<vipbnf><ClassImplementation> :
implement <ClassName> <Attributes>-opt <ScopeQualifications> <Sections> end implement <ClassName>-opt</vipbnf>

The attributes of constants, domains, predicates, properties and facts are at the end (i.e. right before the terminating dot).

<vipbnf><ConstantDefinition>: one of
<ConstantName> = <ConstantValue> <Attributes>-opt
<ConstantName> : <TypeName> = <ConstantValue> <Attributes>-opt</vipbnf>

<vipbnf><DomainDefinition>:
<DomainName> <FormalTypeParameterList>-opt = <TypeExpression> <Attributes>-opt</vipbnf>

<vipbnf><PredicateDeclaration> :
<PredicateName> : <PredicateDomain> <LinkName>-opt <Attributes>-opt
<PredicateName> : <PredicateDomainName> <LinkName>-opt <Attributes>-opt</vipbnf>

<vipbnf><PropertyDeclaration> :
<PropertyName> : <PropertyType> <FlowPattern>-list-opt <Attributes>-opt</vipbnf>

<vipbnf><FactDeclaration> :
<FactVariableDeclaration> <Attributes>-opt
<FactFunctorDeclaration> <Attributes>-opt</vipbnf>

The attributes of formal arguments are at the end.

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

=== Specific Attributes ===

==== byVal ====

An argument is transferred directly on the stack rather than using a pointer. Valid for formal predicate arguments provided the <vp>language</vp> is <vp>stdcall</vp>, <vp>apicall</vp> or <vp>c</vp>.

{{Example|
<vip>predicates
externalP : (point Point [byVal]) language apicall.</vip>
}}

==== deprecated ====

The declared entity is deprecated. The string literal describes how to migrate from it. The entity still exist, but usage will cause a warning.
The entity will not exist in future versions of Visual Prolog. Valid for member declarations and scopes.

{{Example|
<vip>predicates
oldFasioned : (string Arg) [deprecated("Use newFasion instead")].</vip>
}}

==== formatString ====

The argument is a {{lang2|Domains|Format Strings|format string}} for a subsequent ellipsis argument (i.e. <vp>...</vp>). Valid for one string argument of a predicate with an ellipsis argument. The use of formatString will make the compiler check the validity of actual arguments with respect to actual format strings (where possible).

{{Example|
<vip>predicates
writef : (string Format [formatString], ...).</vip>
}}

==== in ====

The argument is an input argument. Valid for a formal predicate argument.

{{Example|
<vip>predicates
pred : (string InputArg [in]).</vip>
}}

==== inline ====

<vp>inline</vp> alters the memory layout of a struct (i.e. a single alternative functor domain with an align qualification). The corresponding field is inlined instead of being pointed to.

{{Example|
<vip>domains
point = align 4
p(integer X, integer Y).

domains
rectangle = align 4
r(
point UpperLeft [inline],
point LowerRight [inline]
).</vip>
}}

It is also possible to inline fixed size string and string8 fields in structs:

{{Example|
<vip>domains
device = align 4
device(
integer Id,
string DeviceName [inline(32)]
).</vip>
}}

==== noDefaultConstructor ====

Used for a class to indicate that it should not have an implicit default constructor, and can thus be used to a class that does not have any constructors at all. Valid for an object creating class declaration.

{{Example|
<vip>class classWithoutPublicConstructors : myInterface
[noDefaultConstructor]
...
end class classWithoutPublicConstructors</vip>
}}

==== out ====

The argument is an output argument. Valid for a formal predicate argument.

{{Example|
<vip>predicates
pred : (string OutputArg [out]).</vip>
}}

==== retired ====

The declared entity is retired. The string literal describes how to migrate from it. The entity does not exist anymore.

{{Example|
<vip>predicates
veryOldFasioned : (string Arg) [retired("Use newFasion instead")].</vip>
}}

==== union ====

Used for creating functor domains with several alternatives but no real functors. This should only be used to mimic C/C++ union structs in low-level interfacing. Valid for functor domain with several alternatives and alignment.

{{Example|
<vip>domains
u64var = align 4
u64(unsigned64 Value64);
u64_struct(unsigned Low32, unsigned High32)
[union].</vip>
}}

==== used ====

An unused local member can be marked <vp>used</vp> to prevent the compiler to issue a warning and remove the corresponding code. Valid for local members.

{{Example|
<vip>predicates
seeminglyUnused : () [used].</vip>
}}

Language Reference/Attributes

2010-03-17T17:22:06Z

Elizabeth Safro: /* union */

{{Preliminary Documentation}}

{{languageReferenceNavbar|Attributes}}

Various definitions and declarations can be annotated with attributes. This section describes the general syntax of attributes and where they can be placed. It also describes the meaning of the specific attributes.

=== Syntax ===

<vipbnf><Attributes> :
[ <Attribute>-comma-sep-list ]</vipbnf>

<vipbnf><Attribute> : one of
<LowerCaseIdentifier>
<LowerCaseIdentifier> ( <Literal>-comma-sep-list )</vipbnf>

Where the literals must either be numbers or string literals.

=== Insertion Points ===

The attributes of interfaces, classes and implementations are right before the scope qualifications.

<vipbnf><InterfaceDeclaration> :
interface <IinterfaceName> <Attributes>-opt <ScopeQualifications> <Sections> end interface <IinterfaceName>-opt</vipbnf>

<vipbnf><ClassDeclaration> :
class <ClassName> <ConstructionType>-opt <Attributes>-opt <ScopeQualifications> <Sections> end class <ClassName>-opt</vipbnf>

<vipbnf><ClassImplementation> :
implement <ClassName> <Attributes>-opt <ScopeQualifications> <Sections> end implement <ClassName>-opt</vipbnf>

The attributes of constants, domains, predicates, properties and facts is at the end (i.e. right before the terminating dot).

<vipbnf><ConstantDefinition>: one of
<ConstantName> = <ConstantValue> <Attributes>-opt
<ConstantName> : <TypeName> = <ConstantValue> <Attributes>-opt</vipbnf>

<vipbnf><DomainDefinition>:
<DomainName> <FormalTypeParameterList>-opt = <TypeExpression> <Attributes>-opt</vipbnf>

<vipbnf><PredicateDeclaration> :
<PredicateName> : <PredicateDomain> <LinkName>-opt <Attributes>-opt
<PredicateName> : <PredicateDomainName> <LinkName>-opt <Attributes>-opt</vipbnf>

<vipbnf><PropertyDeclaration> :
<PropertyName> : <PropertyType> <FlowPattern>-list-opt <Attributes>-opt</vipbnf>

<vipbnf><FactDeclaration> :
<FactVariableDeclaration> <Attributes>-opt
<FactFunctorDeclaration> <Attributes>-opt</vipbnf>

The attributes of formal arguments are at the end.

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

=== Specific Attributes ===

==== byVal ====

An argument is transferred directly on the stack rather than using a pointer. Valid for formal predicate arguments provided the <vp>language</vp> is <vp>stdcall</vp>, <vp>apicall</vp> or <vp>c</vp>.

{{Example|
<vip>predicates
externalP : (point Point [byVal]) language apicall.</vip>
}}

==== deprecated ====

The declared entity is deprecated. The string literal describes how to migrate from it. The entity still exist, but usage will cause a warning.
The entity will not exist in future versions of Visual Prolog. Valid for member declarations and scopes.

{{Example|
<vip>predicates
oldFasioned : (string Arg) [deprecated("Use newFasion instead")].</vip>
}}

==== formatString ====

The argument is a {{lang2|Domains|Format Strings|format string}} for a subsequent ellipsis argument (i.e. <vp>...</vp>). Valid for one string argument of a predicate with an ellipsis argument. The use of formatString will make the compiler check the validity of actual arguments with respect to actual format strings (where possible).

{{Example|
<vip>predicates
writef : (string Format [formatString], ...).</vip>
}}

==== in ====

The argument is an input argument. Valid for a formal predicate argument.

{{Example|
<vip>predicates
pred : (string InputArg [in]).</vip>
}}

==== inline ====

<vp>inline</vp> alters the memory layout of a struct (i.e. a single alternative functor domain with an align qualification). The corresponding field is inlined instead of being pointed to.

{{Example|
<vip>domains
point = align 4
p(integer X, integer Y).

domains
rectangle = align 4
r(
point UpperLeft [inline],
point LowerRight [inline]
).</vip>
}}

It is also possible to inline fixed size string and string8 fields in structs:

{{Example|
<vip>domains
device = align 4
device(
integer Id,
string DeviceName [inline(32)]
).</vip>
}}

==== noDefaultConstructor ====

Used for a class to indicate that it should not have an implicit default constructor, and can thus be used to a class that does not have any constructors at all. Valid for an object creating class declaration.

{{Example|
<vip>class classWithoutPublicConstructors : myInterface
[noDefaultConstructor]
...
end class classWithoutPublicConstructors</vip>
}}

==== out ====

The argument is an output argument. Valid for a formal predicate argument.

{{Example|
<vip>predicates
pred : (string OutputArg [out]).</vip>
}}

==== retired ====

The declared entity is retired. The string literal describes how to migrate from it. The entity does not exist anymore.

{{Example|
<vip>predicates
veryOldFasioned : (string Arg) [retired("Use newFasion instead")].</vip>
}}

==== union ====

Used for creating functor domains with several alternatives but no real functors. This should only be used to mimic C/C++ union structs in low-level interfacing. Valid for functor domain with several alternatives and alignment.

{{Example|
<vip>domains
u64var = align 4
u64(unsigned64 Value64);
u64_struct(unsigned Low32, unsigned High32)
[union].</vip>
}}

==== used ====

An unused local member can be marked <vp>used</vp> to prevent the compiler to issue a warning and remove the corresponding code. Valid for local members.

{{Example|
<vip>predicates
seeminglyUnused : () [used].</vip>
}}

Language Reference/Attributes

2010-03-17T17:17:31Z

Elizabeth Safro: /* out */

{{Preliminary Documentation}}

{{languageReferenceNavbar|Attributes}}

Various definitions and declarations can be annotated with attributes. This section describes the general syntax of attributes and where they can be placed. It also describes the meaning of the specific attributes.

=== Syntax ===

<vipbnf><Attributes> :
[ <Attribute>-comma-sep-list ]</vipbnf>

<vipbnf><Attribute> : one of
<LowerCaseIdentifier>
<LowerCaseIdentifier> ( <Literal>-comma-sep-list )</vipbnf>

Where the literals must either be numbers or string literals.

=== Insertion Points ===

The attributes of interfaces, classes and implementations are right before the scope qualifications.

<vipbnf><InterfaceDeclaration> :
interface <IinterfaceName> <Attributes>-opt <ScopeQualifications> <Sections> end interface <IinterfaceName>-opt</vipbnf>

<vipbnf><ClassDeclaration> :
class <ClassName> <ConstructionType>-opt <Attributes>-opt <ScopeQualifications> <Sections> end class <ClassName>-opt</vipbnf>

<vipbnf><ClassImplementation> :
implement <ClassName> <Attributes>-opt <ScopeQualifications> <Sections> end implement <ClassName>-opt</vipbnf>

The attributes of constants, domains, predicates, properties and facts is at the end (i.e. right before the terminating dot).

<vipbnf><ConstantDefinition>: one of
<ConstantName> = <ConstantValue> <Attributes>-opt
<ConstantName> : <TypeName> = <ConstantValue> <Attributes>-opt</vipbnf>

<vipbnf><DomainDefinition>:
<DomainName> <FormalTypeParameterList>-opt = <TypeExpression> <Attributes>-opt</vipbnf>

<vipbnf><PredicateDeclaration> :
<PredicateName> : <PredicateDomain> <LinkName>-opt <Attributes>-opt
<PredicateName> : <PredicateDomainName> <LinkName>-opt <Attributes>-opt</vipbnf>

<vipbnf><PropertyDeclaration> :
<PropertyName> : <PropertyType> <FlowPattern>-list-opt <Attributes>-opt</vipbnf>

<vipbnf><FactDeclaration> :
<FactVariableDeclaration> <Attributes>-opt
<FactFunctorDeclaration> <Attributes>-opt</vipbnf>

The attributes of formal arguments are at the end.

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

=== Specific Attributes ===

==== byVal ====

An argument is transferred directly on the stack rather than using a pointer. Valid for formal predicate arguments provided the <vp>language</vp> is <vp>stdcall</vp>, <vp>apicall</vp> or <vp>c</vp>.

{{Example|
<vip>predicates
externalP : (point Point [byVal]) language apicall.</vip>
}}

==== deprecated ====

The declared entity is deprecated. The string literal describes how to migrate from it. The entity still exist, but usage will cause a warning.
The entity will not exist in future versions of Visual Prolog. Valid for member declarations and scopes.

{{Example|
<vip>predicates
oldFasioned : (string Arg) [deprecated("Use newFasion instead")].</vip>
}}

==== formatString ====

The argument is a {{lang2|Domains|Format Strings|format string}} for a subsequent ellipsis argument (i.e. <vp>...</vp>). Valid for one string argument of a predicate with an ellipsis argument. The use of formatString will make the compiler check the validity of actual arguments with respect to actual format strings (where possible).

{{Example|
<vip>predicates
writef : (string Format [formatString], ...).</vip>
}}

==== in ====

The argument is an input argument. Valid for a formal predicate argument.

{{Example|
<vip>predicates
pred : (string InputArg [in]).</vip>
}}

==== inline ====

<vp>inline</vp> alters the memory layout of a struct (i.e. a single alternative functor domain with an align qualification). The corresponding field is inlined instead of being pointed to.

{{Example|
<vip>domains
point = align 4
p(integer X, integer Y).

domains
rectangle = align 4
r(
point UpperLeft [inline],
point LowerRight [inline]
).</vip>
}}

It is also possible to inline fixed size string and string8 fields in structs:

{{Example|
<vip>domains
device = align 4
device(
integer Id,
string DeviceName [inline(32)]
).</vip>
}}

==== noDefaultConstructor ====

Used for a class to indicate that it should not have an implicit default constructor, and can thus be used to a class that does not have any constructors at all. Valid for an object creating class declaration.

{{Example|
<vip>class classWithoutPublicConstructors : myInterface
[noDefaultConstructor]
...
end class classWithoutPublicConstructors</vip>
}}

==== out ====

The argument is an output argument. Valid for a formal predicate argument.

{{Example|
<vip>predicates
pred : (string OutputArg [out]).</vip>
}}

==== retired ====

The declared entity is retired. The string literal describes how to migrate from it. The entity does not exist anymore.

{{Example|
<vip>predicates
veryOldFasioned : (string Arg) [retired("Use newFasion instead")].</vip>
}}

==== union ====

Used for creating functor domains with several alternatives but no real functors. This should only be used to mimic C/C++ uninon structs in low-level interfacing. Valid for functor domain with several alternatives and alignment.

{{Example|
<vip>domains
u64var = align 4
u64(unsigned64 Value64);
u64_struct(unsigned Low32, unsigned High32)
[union].</vip>
}}

==== used ====

An unused local member can be marked <vp>used</vp> to prevent the compiler to issue a warning and remove the corresponding code. Valid for local members.

{{Example|
<vip>predicates
seeminglyUnused : () [used].</vip>
}}

Language Reference/Attributes

2010-03-17T17:15:39Z

Elizabeth Safro: /* noDefaultConstructor */

{{Preliminary Documentation}}

{{languageReferenceNavbar|Attributes}}

Various definitions and declarations can be annotated with attributes. This section describes the general syntax of attributes and where they can be placed. It also describes the meaning of the specific attributes.

=== Syntax ===

<vipbnf><Attributes> :
[ <Attribute>-comma-sep-list ]</vipbnf>

<vipbnf><Attribute> : one of
<LowerCaseIdentifier>
<LowerCaseIdentifier> ( <Literal>-comma-sep-list )</vipbnf>

Where the literals must either be numbers or string literals.

=== Insertion Points ===

The attributes of interfaces, classes and implementations are right before the scope qualifications.

<vipbnf><InterfaceDeclaration> :
interface <IinterfaceName> <Attributes>-opt <ScopeQualifications> <Sections> end interface <IinterfaceName>-opt</vipbnf>

<vipbnf><ClassDeclaration> :
class <ClassName> <ConstructionType>-opt <Attributes>-opt <ScopeQualifications> <Sections> end class <ClassName>-opt</vipbnf>

<vipbnf><ClassImplementation> :
implement <ClassName> <Attributes>-opt <ScopeQualifications> <Sections> end implement <ClassName>-opt</vipbnf>

The attributes of constants, domains, predicates, properties and facts is at the end (i.e. right before the terminating dot).

<vipbnf><ConstantDefinition>: one of
<ConstantName> = <ConstantValue> <Attributes>-opt
<ConstantName> : <TypeName> = <ConstantValue> <Attributes>-opt</vipbnf>

<vipbnf><DomainDefinition>:
<DomainName> <FormalTypeParameterList>-opt = <TypeExpression> <Attributes>-opt</vipbnf>

<vipbnf><PredicateDeclaration> :
<PredicateName> : <PredicateDomain> <LinkName>-opt <Attributes>-opt
<PredicateName> : <PredicateDomainName> <LinkName>-opt <Attributes>-opt</vipbnf>

<vipbnf><PropertyDeclaration> :
<PropertyName> : <PropertyType> <FlowPattern>-list-opt <Attributes>-opt</vipbnf>

<vipbnf><FactDeclaration> :
<FactVariableDeclaration> <Attributes>-opt
<FactFunctorDeclaration> <Attributes>-opt</vipbnf>

The attributes of formal arguments are at the end.

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

=== Specific Attributes ===

==== byVal ====

An argument is transferred directly on the stack rather than using a pointer. Valid for formal predicate arguments provided the <vp>language</vp> is <vp>stdcall</vp>, <vp>apicall</vp> or <vp>c</vp>.

{{Example|
<vip>predicates
externalP : (point Point [byVal]) language apicall.</vip>
}}

==== deprecated ====

The declared entity is deprecated. The string literal describes how to migrate from it. The entity still exist, but usage will cause a warning.
The entity will not exist in future versions of Visual Prolog. Valid for member declarations and scopes.

{{Example|
<vip>predicates
oldFasioned : (string Arg) [deprecated("Use newFasion instead")].</vip>
}}

==== formatString ====

The argument is a {{lang2|Domains|Format Strings|format string}} for a subsequent ellipsis argument (i.e. <vp>...</vp>). Valid for one string argument of a predicate with an ellipsis argument. The use of formatString will make the compiler check the validity of actual arguments with respect to actual format strings (where possible).

{{Example|
<vip>predicates
writef : (string Format [formatString], ...).</vip>
}}

==== in ====

The argument is an input argument. Valid for a formal predicate argument.

{{Example|
<vip>predicates
pred : (string InputArg [in]).</vip>
}}

==== inline ====

<vp>inline</vp> alters the memory layout of a struct (i.e. a single alternative functor domain with an align qualification). The corresponding field is inlined instead of being pointed to.

{{Example|
<vip>domains
point = align 4
p(integer X, integer Y).

domains
rectangle = align 4
r(
point UpperLeft [inline],
point LowerRight [inline]
).</vip>
}}

It is also possible to inline fixed size string and string8 fields in structs:

{{Example|
<vip>domains
device = align 4
device(
integer Id,
string DeviceName [inline(32)]
).</vip>
}}

==== noDefaultConstructor ====

Used for a class to indicate that it should not have an implicit default constructor, and can thus be used to a class that does not have any constructors at all. Valid for an object creating class declaration.

{{Example|
<vip>class classWithoutPublicConstructors : myInterface
[noDefaultConstructor]
...
end class classWithoutPublicConstructors</vip>
}}

==== out ====

The argument is an output argument. Valid for a a formal predicate argument.

{{Example|
<vip>predicates
pred : (string OutputArg [out]).</vip>
}}

==== retired ====

The declared entity is retired. The string literal describes how to migrate from it. The entity does not exist anymore.

{{Example|
<vip>predicates
veryOldFasioned : (string Arg) [retired("Use newFasion instead")].</vip>
}}

==== union ====

Used for creating functor domains with several alternatives but no real functors. This should only be used to mimic C/C++ uninon structs in low-level interfacing. Valid for functor domain with several alternatives and alignment.

{{Example|
<vip>domains
u64var = align 4
u64(unsigned64 Value64);
u64_struct(unsigned Low32, unsigned High32)
[union].</vip>
}}

==== used ====

An unused local member can be marked <vp>used</vp> to prevent the compiler to issue a warning and remove the corresponding code. Valid for local members.

{{Example|
<vip>predicates
seeminglyUnused : () [used].</vip>
}}