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

Compound and List Domains

2020-01-08T14:12:21Z

Troels Anker Jørgensen:

In this tutorial we will introduce compound domains (sometimes called algebraic data structures). Compound domains are used to handle several pieces of data as a single entity. Lists is an example of compound domains. Lists are used so much that they have even received special syntactical sugaring.

Compound and list domains are created using built-in domains and other compound and list domains. Visual Prolog help describes built-in domains: integral, real, string, symbol, char, string8, pointer, binary, boolean, object.

==Compound Domains and Functors==

Compound domains allow you to treat several pieces of information as a single item in such a way that you can easily pick them apart again. Consider, for instance, the date "October 15, 2003". It consists of three pieces of information – the month, day, and year – but it is useful to treat the whole thing as a single data with a treelike structure:

<pre> DATE
/|\
/ | \
/ | \
/ | \
October 15 2003</pre>You can do this by declaring a domain containing the compound domain '''date''':

<vip>domains
date_cmp = date(string Month, unsigned Day, unsigned Year).</vip>

and then simply writing e.g.

<vip>D = date("October", 15, 2003),</vip>

This looks like a Prolog fact, but it isn't here – it is just a value, which you can handle in much the same way as a string or number. It begins with a name, usually called a functor(in this case date), followed by three arguments.

Note carefully that a functor in Visual Prolog has nothing to do with a function in other programming languages. '''''A functor does not stand for some computation to be performed.''''' it is just a name that identifies a kind of compound value and holds its arguments together.

The arguments of a compound value can themselves be compound. For instance, you might think of someone's birthday as an information structure like this:

<pre> birthday
/ \
/ \
/ \
/ \
/ \
person date
/ \ / | \
/ \ / | \
"Per" "Schultze" "Apr" 14 1960</pre>In Prolog you would write this as:

<vip>birthday(person("Per", "Schultze"), date("Apr",14,1960)).</vip>

In this example, there are two sub-parts in the compound birthday value: the argument person("Per", "Schultze") and the argument date("Apr", 14, 1960). The functors of these values are person and date.

==Unification of Compound Domains==

A compound value can unify either with a simple variable or with a compound value that matches it(perhaps containing variables as parts of its internal structure). This means you can use a compound value to pass the whole collection of items as a single value, and then use unification to pick them apart. For example, <vp>date("April", 14, 1960)</vp> matches <vp>X</vp> and binds <vp>X</vp> to <vp>date("April",14,1960)</vp>. Also <vp>date("April", 14, 1960)</vp> matches <vp>date(Mo, Da, Yr)</vp> and binds <vp>Mo</vp> to <vp>"April"</vp>, <vp>Da</vp> to <vp>14</vp>, and <vp>Yr</vp> to <vp>1960</vp>.

===Using the Equal Sign to Unify Compound Domains===

Visual Prolog performs unification in two places. The first is when a call or goal matches the head of a clause. The second is across the '''''equal'''''(=) sign, which is actually an infix predicate(a predicate that is located ''between'' its arguments rather than ''before'' them).

Visual Prolog will make the necessary bindings to unify the values on both sides of the '''''equal''''' sign. This is useful for finding the values of arguments within a compound value. For example, the following code excerpt tests if two people have the same last name, then gives the second person the same address as the first.

<vip>class my
domains
person = person(name, address).
name = name(string First, string Last).
address = addr(street, string City, string State).
street = street(integer Number, string Street_name).

predicates
run :().
end class

implement my
clauses
run():-
console::init(),
P1 = person(name("Jim", "Smith"),
addr(street(5, "1st st"), "igo", "CA")),
P1 = person(name(_, "Smith"), Address),
P2 = person(name("Jane", "Smith"), Address),
!,
stdio::write("P1 = ", P1, "\n"),
stdio::write("P2 = ", P2, "\n")
;
stdio::write("No solution").
end implement

goal
my::run.</vip>

==Treating Several Items as One==

Compound values can be regarded and treated as single values in your Prolog clauses, which greatly simplifies programming. Consider, for example, the fact

<vip>owns("John", book("From Here to Eternity", "James Jones")).</vip>

in which you state that John owns the book "From Here to Eternity", written by "James Jones". Likewise, you could write

<vip>owns("John", horse("Blacky")).</vip>

which can be interpreted as

John owns a horse named Blacky.

The compound values in these two examples are

<vip>book("From Here to Eternity", "James Jones")).</vip>

and

<vip>horse("Blacky").</vip>

If you had instead written two facts:

<vip>owns("John", "From Here to Eternity").
owns("John", "Blacky").</vip>

you would not have been able to decide whether Blacky was the title of a book or the name of a horse. On the other hand, you can use the first component of a compound value – the functor – to distinguish between different kinds of values. This example used the functors book and horse to indicate the difference between the values.

'''Remember''': Compound values consist of a functor and the arguments belonging to that functor, as follows:

<vip>functor(argument1, argument2, ..., argumentN)</vip>

===An Example Using Compound Domains===

An important feature of compound domains allows you to easily pass a group of values as one argument. Consider a case where you are keeping a telephone database. In your database, you want to include your friends' and family members' birthdays. Here is a section of code you might have come up with:

<vip>predicates
phone_list :(string First, string Last, string Phone, string Month, intege Day, integer Year) determ.

clauses
phone_list("Ed", "Willis", "422-0208", "aug", 3, 1955).
phone_list("Chris", "Grahm", "433-9906", "may", 12, 1962).</vip>

Examine the data, noticing the six arguments in the fact phone_list; five of these arguments can be broken down into two compound domains, like this:

<pre> person birthday
/ \ / | \
/ \ / | \
First Name Last Name Month Day Year</pre>It might be more useful to represent your facts so that they reflect these compound domains. Going back a step, you can see that person is a relationship, and the first and last names are the arguments. Also, birthday is a relationship with three arguments: month, day, and year. The Prolog representation of these relationships is

<vip>owns("John", "From Here to Eternity").
owns("John", "Blacky").</vip>

You can now rewrite your small database to include these compound domains as part of your database.

<vip>domains
name = person(string First, string Last).
birthday = b_date(string Month, integer Day, integer Year).

class predicates
phone_list : (name Name, string Ph_num, birthday Birthday) determ.
clauses
phone_list(person("Ed", "Willis"), "422-0208", b_date("aug", 3, 1955)).
phone_list(person("Chris", "Grahm"), "433-9906", b_date("may", 12, 1962)).</vip>

In this program, two compound '''domains''' declarations were introduced. We go into more detail about these compound data structures later in this chapter. For now, we will concentrate on the benefits of using such compound domains.

The phone_list predicate now contains three arguments, as opposed to the previous six. Sometimes breaking up your data into compound values will clarify your program and might help process the data.

Now add some rules to program. Suppose you want to create a list of people whose birthdays are in the current month. Here is the program code to accomplish this task; this program uses the standard predicate date to get the current date from the computer's internal clock. Predicate date will return the current year, month, and day from your computer's clock.

<vip>class my
domains
name = person(string First, string Last).
birthday = b_date(string Month, integer Day, integer Year).
predicates
phone_list : (name Name [out], string Ph_num [out], birthday Birthday [out]) multi.
get_months_birthdays : ().
convert_month : (string Name, integer Num [out]) determ.
check_birthday_month : (integer Month_num, birthday Birthday) determ.
write_person : (name Name).
end class

implement my
clauses
get_months_birthdays() :-
stdio::write("****** This Month's Birthday List *****\n"),
stdio::write(" First Name\t\t Last Name\n"),
stdio::write("***********************************\n"),
Now = time::now(),
Now:getDate(_, ThisMonth, _),
phone_list(Person, _, Date),
check_birthday_month(ThisMonth, Date),
write_person(Person),
fail.
get_months_birthdays() :-
stdio::write("\n Press any key to continue:\n"),
_ = console::readChar().

clauses
write_person(person(FirstName, LastName)) :-
stdio::write(" ", FirstName, "\t\t ", LastName, "\n").

clauses
check_birthday_month(Mon, b_date(Month, _, _)) :-
convert_month(Month, Month1),
Mon = Month1.

clauses
phone_list(person("Ed", "Willis"), "11-1111", b_date("Jan", 3, 1955)).
phone_list(person("Benjamin", "Thomas"), "222-2222", b_date("Feb", 5, 1965)).
phone_list(person("Ray", "William"), "333-3333", b_date("Mar", 3, 1955)).
phone_list(person("Tomas", "Alfred"), "444-4444", b_date("Apr", 29, 1975)).
phone_list(person("Chris", "Gralm"), "555-5555", b_date("May", 12, 1975)).
phone_list(person("Dastin", "Robert"), "666-6666", b_date("Jun", 17, 1975)).
phone_list(person("Anna", "Friend"), "777-7777", b_date("Jul", 2, 1975)).
phone_list(person("Naomi", "Friend"), "888-8888", b_date("Aug", 10, 1975)).
phone_list(person("Christina", "Lynn"), "999-9999", b_date("Sep", 25, 1975)).
phone_list(person("Kathy", "Ann"), "110-1010", b_date("Oct", 20, 1975)).
phone_list(person("Elizabeth", "Ann"), "110-1111", b_date("Nov", 9, 1975)).
phone_list(person("Aaron", "Friend"), "110-1212", b_date("Dec", 31, 1975)).
phone_list(person("Jenifer", "Faitlin"), "888-8888", b_date("Aug", 14, 1975)).

clauses
convert_month("Jan", 1).
convert_month("Feb", 2).
convert_month("Mar", 3).
convert_month("Apr", 4).
convert_month("May", 5).
convert_month("Jun", 6).
convert_month("Jul", 7).
convert_month("Aug", 8).
convert_month("Sep", 9).
convert_month("Oct", 10).
convert_month("Nov", 11).
convert_month("Dec", 12).
end implement

goal
console::init(),
my::get_months_birthdays().</vip>

How do compound domains help in this program? This should be easy to see when you examine the code. Most of the processing goes on in the get_months_birthdays predicate.

*First, the program makes a window to display the results.

*After this, it writes a header in the window to help interpret the results.

*Next, in get_months_birthdays, the program uses the built-in predicate date to obtain the current month.

*After this, the program is all set to search the database and list the people who were born in the current month. The first thing to do is find the first person in the database. The call phone_list(Person, _, Date) binds the person's first and last names to the variable Person by binding the entire functor person to Person. It also binds the person's birthday to the variable Date. 
Notice that you only need to use one variable to store a person's complete name, and one variable to hold the birthday. This is the power of using compound domains.

*Your program can now pass around a person's birthday simply by passing on the variable Date. This happens in the next subgoal, where the program passes the current month(represented by an integer) and the birthday(of the person it is processing) to the predicate check_birthday_month.

*Look closely at what happens. Visual Prolog calls the predicate check_birthday_month with two variables: The first variable is bound to an integer, and the second is bound to a birthday term. In the head of the rule that defines check_birthday_month, the first argument, This_month, is matched with the variable Mon. The second argument, Date, is matched against b_date(Month, _,_). 
Since all you are concerned with is the month of a person's birthday, you have used the anonymous variable for both the day and the year of birth.

*The predicate check_birthday_month first converts the string for the month into an integer value. Once this is done, Visual Prolog can compare the value of the current month with the value of the person's birthday month. If this comparison succeeds, then the subgoal check_birthday_month succeeds, and processing can continue. If the comparison fails(the person currently being processed was not born in the current month), Visual Prolog begins to backtrack to look for another solution to the problem.

*The next subgoal to process is write_person. The person currently being processed has a birthday this month, so it is OK to print that person's name in the report. After printing the information, the clause fails, which forces backtracking.

*'''''Backtracking always goes up to the most recent non-deterministic call and tries to re-satisfy that call.''''' In this program, the last non-deterministic call processed is the call to phone_list. It is here that the program looks up another person to be processed. If there are no more people in the database to process, the current clause fails; Visual Prolog then attempts to satisfy this call by looking further down in the database. Since there is another clause that defines get_months_birthdays, Visual Prolog tries to satisfy the call to get_months_birthdays by satisfying the subgoals to this other clause.

==Declaring Compound Domains==

In this section, we show you how instances of compound domains are defined. After compiling a program that contains the following relationships:

<vip>owns("John", book("From Here to Eternity", "James Jones")).</vip>

and

<vip>owns("John", horse("Blacky")).</vip>

you could query the system with this goal:

<vip>owns("John", X))</vip>

The variable X can be bound to a different type: a book, a horse, or perhaps other types you define. Because of your definition of the owns predicate, you can no longer employ the old predicate declaration of owns:

<vip>owns :(string, string).</vip>

The second argument no longer refers to the string domain. Instead, you must formulate a new declaration to the predicate, such as

<vip>owns :(name, articles).</vip>

You can describe the articles domain in the domains section as shown here:

<vip>domains
articles = book(string Title, string Author);
horse(string Name).
/* Articles are books or horses */</vip>

The semicolon is read as ''or''. In this case, two alternatives are possible: A book can be identified by its title and author, or a horse can be identified by its name. The domains title, author, and name are all of the standard domain string.

More alternatives can easily be added to the domains declaration. For example, articles could also include a boat, a house, or a bankbook. For a boat, you can make do with a functor that has no arguments attached to it. On the other hand, you might want to give a bank balance as a figure within the bankbook. The domains declaration of articles is therefore extended to:

<vip>domains
articles = book(string Title, string Author);
horse(string Name); boat; bankbook(real Balance).</vip>

Here is a full program that shows how compound domains from the domain articles can be used in facts that define the predicate owns.

<vip>class my
domains
articles =
book(string Title, string Author) ;
horse(string Name) ; boat ; bankbook(real Balance).
predicates
owns :(string Name, articles) nondeterm(i,o) determ(i,i).
end class

implement my
clauses
owns("John", book("A friend of the family", "Irwin Shaw")).
owns("John", horse("Blacky")).
owns("John", boat).
owns("John", bankbook(1000)).
end implement

goal
console::init(),
my::owns("John", Thing),
stdio::write("Thing: ", Thing, "\n"),
fail
;
stdio::write("The end.").</vip>

Now load the program into Visual Development Environment and run it in window. Visual Prolog responds with:

<vip>Thing: book("A friend of the family","Irwin Shaw")
Thing: horse("Blacky")
Thing: boat()
Thing: bankbook(1000)
The end.</vip>

===Writing Domain Declarations: a Summary===

This is a generic representation of how to write compound domain declarations:

<vip>domain = alternative1(D, D, ...);
alternative2(D, D, ...);
...</vip>

Here, alternative1 and alternative2 are arbitrary(but different) functors. The notation(D, D, ...) represents a list of domain names that are either declared elsewhere or are one of the standard domain types(such as string, integer, real, etc).

'''Note''':

*The alternatives are separated by semicolons.

*Every alternative consists of a functor and, possibly, a list of domains for the corresponding arguments.

*If the functor has no arguments, you can write it as alternativeN or alternativeN( ) in your programs.

===Multi-Level Compound Domains===

Visual Prolog allows you to construct compound domains on several levels. For example, in

<vip>book("The Ugly Duckling", "Andersen").</vip>

instead of using the author's last name, you could use a new structure that describes the author in more detail, including both the author's first and last names. By calling the functor for the resulting new compound domain author, you can change the description of the book to

<vip>book("The Ugly Duckling", author("Hans Christian", "Andersen")).</vip>

In the old domain declaration

<vip>book(string Title, string Author).</vip>

the second argument of the book functor is Author that can only include a single name, so it is no longer sufficient. You must now specify that an author is also a compound domain made up of the author's first and last name. You do this with the domain definition:

<vip>author = author(string First_name, string Last_name).</vip>

which leads to the following declarations:

<vip>domains
articles = book(string Title, author Author); ...
/* First level */
author = author(string First_name, string Last_name).
/* Second level */</vip>

When using compound domains on different levels in this way, it is often helpful to draw a "tree":

<pre> book
/ \
/ \
title author
/ \
/ \
First_name Last_name</pre>A domain declaration describes only one level of the tree at a time, and not the whole tree. For instance, a book can't be defined with the following domain declaration:

<vip>/* Not allowed */
book = book(string Title, author(string First_name, string Last_name)).</vip>

==Compound Mixed-Domain Declarations==

In this section, we discuss three different types of domain declarations you can add to your programs. These declarations allow you to use predicates that

*take an argument, more than one type of more than one possible type

*take a variable number of arguments, each of a specified type

*take a variable number of arguments, some of which might be of more than one possible type

===Multiple-Type Arguments===

To allow a Visual Prolog predicate to accept an argument that gives information of different types, you must add a functor declaration. In the following example, the your_age clause will accept an argument of type age, which can be a string, a real, or an integer.

<vip>domains
age = i(integer); r(real); s(string).

class predicates
your_age :(age).
clauses
your_age(i(Age)) :- stdio::write(Age).
your_age(r(Age)) :- stdio::write(Age).
your_age(s(Age)) :- stdio::write(Age).</vip>

Visual Prolog does not allow the following domain declaration:

<vip>/* Not permitted. */
domains
age = integer; real; string.</vip>

===Lists===

Suppose you are keeping track of the different classes a professor might teach. You might produce the following code:

<vip>class predicates
teacher :(string First_name, string Last_name, string Class) determ.

clauses
teacher("Ed", "Willis", "english1").
teacher("Ed", "Willis", "math1").
teacher("Ed", "Willis", "history1").
teacher("Mary", "Maker", "history2").
teacher("Mary", "Maker", "math2").
teacher("Chris", "Grahm", "geometry").</vip>

Here, you need to repeat the teacher's name for each class he or she teaches. For each class, you need to add another fact to the database. Although this is perfectly OK in this situation, you might find a school where there are hundreds of classes; this type of data structure would get a little tedious. Here, it would be helpful if you could create an argument to a predicate that could take on one ''or more'' values.

A list in Prolog does just that. In the following code, the argument class is declared to be of a list type. We show here how a list is represented in Prolog.

<vip>domains
classes = string*. /* declare a list domain */

class predicates
teacher :(string First_name, string Last_name, classes Classes) determ.
clauses
teacher("Ed", "Willis", ["english1", "math1", "history1"]).
teacher("Mary", "Maker", ["history2", "math2"]).
teacher("Chris", "Grahm", ["geometry"]).</vip>

In this example, the code is more concise and easier to read than in the preceding one. Notice the domains declaration. The asterisk(*) means that classes is a list of strings. You can just as easily declare a list of integers:

<vip>domains
integer_list = integer*.</vip>

Once you declare a domain, it is easy to use it; just place it as an argument to a predicate declared in the predicates section. Here is an example of using an integer list:

<vip>domains
integer_list = integer*.

class predicates
test_scores :
(string First_name,
string Last_name,
integer_list Test_Scores)
determ.
clauses
test_scores("Lisa", "Lavender", [86, 91, 75]).
test_scores("Libby", "Dazzner", [79, 75]).
test_scores("Jeff", "Zheutlin", []).</vip>

In the case of ''Jeff Zheutlin'', notice that a list doesn't need to contain any elements at all.

One more example shows how one can use lists to describe the family-tree.

<vip>domains
tree_list = tree*.
tree = tree(string Text, tree_list TreeList).

class predicates
family :(tree) determ.
clauses
family(tree("Grandmother",
[tree("John",
[tree("Eric", []),
tree("Mark", []),
tree("Leonard", []) ] ),
tree("Ellen", [])
]
)).</vip>

==Summary==

These are the important points covered in this tutorial:

*A Visual Prolog program can contain many types of values: simple and compound, standard and user-defined.

*Simple values are numbers, strings, etc.

*''Compound domains'' allow you to treat several pieces of information as a single item. A compound domain consists of a name(known as a functor) and one or more arguments. You can define a domain with several alternative functors.

*A functor in Visual Prolog is not the same thing as a function in other programming languages. '''''A functor does not stand for some computation to be performed.''''' It is just a name that identifies a kind of a compound domain and holds its arguments together.

*Compound values can be regarded and treated as single values; you use the functor to distinguish between different kinds of compound values. Visual Prolog allows you to construct compound values on several levels; the arguments of a compound value can also be compound values. With compound mixed domain declarations, you can use predicates that:

*take an argument of more than one possible type(functor declaration).

*take a variable number of arguments, each of a specified type(list declaration).

*take a variable number of arguments, some of which might be of more than one possible type.

[[ru:Cоставные Домены и Списки]]
[[Category:Data types and handling]]

Ide/Environment Overview

2020-01-06T13:11:28Z

Troels Anker Jørgensen: /* Building */

{{ideNavbar|Environment Overview}}

In this tutorial I will give an overview of the Integrated Development Environment (IDE).The IDE is used to create, develop and maintain your Visual Prolog projects.

Briefly speaking you will use the IDE for the following tasks in a project life cycle:

*'''Creation''': The project is created in the IDE, at creation time you choose important properties of your project, such as whether the project is an executable or a DLL, whether it uses GUI or is text based, etc.

*'''Building''': The project is built, i.e. compiled and linked, from the IDE.

*'''Browsing''': The IDE and the compiler collect information about the project, which is utilized in various ways for quick localization of entities, etc.

*'''Development''': During the development and maintenance of the project, the IDE is used to add and remove source files and GUI entities to the project and to edit these.

*'''Debugging''': The IDE is also used for debugging the project. The debugger is used to follow program execution and exploit the program state when the program runs.In the sequel we will look more detailed at each of these things.

'''Notice''' that the tutorial will start from scratch and create a project that is used for the whole tutorial. The reader is encouraged to do the same. Also notice that clicking on reduced pictures will show them in full scale in a separate window.

==Creation==

First we will create a project by selecting '''Project -> New...''' in the menu. In response to this you are presented to a dialog containing various properties of the project.

[[Image:tut01_projectSettingsS.png]]

I have chosen that my project should have the name ''tut01''.

The project name is also used as the name of the target that is produced. In this case the target is an ''exe'' file so the target name will be ''tut01.exe''.

I have also chosen that the target should be a GUI program, i.e. a program with a graphical user interface.

The '''Base Directory''' is the "base" of all your projects; you should choose a place that is convenient for you.

The new project will be created in a '''Sub-Directory''' of the base directory. By default this directory have the same name as the project itself.

The '''Package Prefix''' is used when creating new "packages" in the system (a later tutorial will explain about the package notion). In case your source files will ever be shared with somebody else it is a good idea if the prefix does not conflict with other prefixes. Therefore it is a good idea to use a prefix that start with a reverse Internet domain name, like ''com/visual-prolog ''(which is the reverse of ''visual-prolog.com'').

For the moment you do not need to consider the remaining tabs and options.

Now create the project by pressing '''Finish'''.

The IDE will now look something like this:

[[Image:tut01_totalS.png]]

You have the '''Project Window''', which contains information about the entities in your project.
You have the '''Messages Window''', which will contain various status and progress messages.

==Building==

When you create the project, it auto builds the first time.

However, before we make any modifications, we will try to build (i.e. compile and link) the project manually. In the '''Build''' menu you find commands for building, compiling and executing the project.

If you choose '''Execute''' the project is first build, so that it is an up to date version you execute. Therefore I will choose '''Execute'''.

If you have not registered Visual Prolog you will be presented to a special screen telling you so. I will suggest that you register, but you can also choose "Continue Evaluation".

In the '''Messages Window''' the IDE writes which files are compiled, etc.

If the build process succeeds, which it does in this case, the created program is executed. As a result you will see a little ''doing-nothing ''GUI program. You might notice that the program looks a bit like the IDE itself. This is no coincidence since the IDE is actually a Visual Prolog program.

Later in this tutorial we will also see what happens, if the compiler or the linker detects errors in the build process.

==Browsing==

Right now we will turn our eyes to the '''Project Tree''' in the '''Project Window''', and explore that a bit. The tree itself is presented in a standard Windows tree control so you should already be familiar with its usage. Here we shall concentrate on the contents of the tree.

Right now the project tree will look like this:

[[Image:tut01_projectWindow1.png|Project Tree]]

The top node represents the project, and the project directory.

Right below that is the logical node '''$(ProDir)''' which represents the directory in which Visual Prolog is installed. This directory contains (as we shall shortly see) libraries and library code from the Visual Prolog system.

Then comes another directory '''TaskWindow,''' which is a subdirectory of the project directory. This directory contains all the code needed to produce the Task Window, its menu and toolbar and the about dialog.

Finally, you see a number of files. Visual Prolog uses the following conventions:

*.'''ph''' files are '''package headers'''. A package is a collection of classes and interfaces that are intended to be used as a chunk.
*.'''pack''' files are '''packages'''. They contain the implementation/definition of the corresponding .ph files.
*.'''i''' file contains an '''interface'''.
*.'''cl''' file contains a '''class declaration'''
*.'''pro''' file contains a '''class implementation'''

If you expand the main.cl node completely you will see the following:

[[Image:tut01_projectWindow2.png|Project Tree]]

This sub-tree shows that the file '''main.cl''' contains a class called '''main''', which contains the declaration of the predicate <vp>run</vp>. Predicates are subroutines, but they will not be considered further in this tutorial.

If we collapse this node again and instead expand the '''TaskWindow''' node, you will see this tree:

You will notice several new kinds of nodes:

*.'''dlg''' file contains a '''dialog'''

*.'''frm''' file contains a '''form'''

*.'''win''' file contains a '''window''' (task window or conventional PFC GUI window)

*.'''mnu''' file contains a '''menu'''

*.'''ico''' file contains an '''icon'''

If you continue to explore you might also meet:

[[Image:tut01_projectWindow3.png|Project Tree: TaskWindow]]

*.'''ctl''' files containing '''controls'''

*.'''tb''' files containing '''toolbars'''

*.'''cur''' files containing '''cursors'''

*.'''bmp''' files containing '''bitmaps'''

*.'''lib''' that are '''libraries'''

If you right click on a node a context menu will appear, with commands that have relevance for that particular node.

If you double click on a node the corresponding entity will be brought up in a suitable editor. All code is edited in a text editor, but windows resources like dialogs and menus are edited in graphical editors. We will look closer to graphical editors below, here we shall try to bring up a text editor.

Some entities are represented twice in the tree, because they have both a declaration and a definition/implementation. For example, the predicate run in the class '''tut01''':

[[Image:tut01_projectWindow2.png|Project Tree]] [[Image:tut01_projectWindow4.png|Project Tree]]

Try double clicking on each of the run nodes, and notice that two editors open showing the declaration and the definition of the run predicate, respectively.

The IDE has other facilities for browsing to specific entities, but these will not be considered here.

==Development==

Now lets try to modify the project a bit. Since we have not yet concerned ourselves with how to program in Visual Prolog, we will keep the changes simple.

We will start by deliberately introducing an error, that way you will not be completely surprised if you make some thing wrong, at the same time you can see the error window.

First you should locate the clauses for the run predicate in the file '''main.pro'''. If you double click the last of the two run nodes in the project tree, an editor opens with the caret placed like this:

[[Image:tut01_editRun1S.png]]

Try inserting a fail like this (notice the comma after show):

<vip>clauses
run():-
TaskWindow = taskWindow::new(),
TaskWindow:show(),
fail.</vip>

After that we try to build the project again: simply press the '''Ctrl+Shift+B''' key combination. The system will now save and compile the file, but since we have made an error, the '''Error Window''' will open:

[[Image:tut01_errorS.png|Error Wondow]]

We will not consider what the error message actually means. Instead you should try to double-click on the error message. You will notice that the editor gets focus again and that the caret points exactly to the fail we inserted.

Reestablish the code without the fail and build the project again.

Next we will try to make a modification in the about dialog. It is not a very sensible change, but it will illustrate a number of things.

First we will open the '''About''' dialog in the '''Dialog Editor''', to do this you double click the dialog in the project tree. The node you have to double click is shown here:

[[Image:tut01_projectWindowAbout.png|Project Window: About Dialog]]

Once you have clicked it you will see the dialog in the '''Dialog Editor''', two toolbars and properties window.

We will add a button to the dialog. You click on the "button" on the controls toolbar, and then you click in the dialog next to the project icon in the '''AboutDialog''' window. As a result you can see the properties of the new control and you can edit them. I have changed the '''Text''' to "Press Me", this is the text that will appear on the button. I can also see the '''Name''' field, the IDE will identify this particular control in various contexts by this Name.

Now it should look something like this:

[[Image:tut01_dialogEditorAbout2.png|Dialog Editor: About Dialog with new button]]

Now we want to do something whenever the button is pressed:

[[Image:Tut01_dialogEditorAboutClick.png]]

The IDE has suggested the name onPushButton for the handling predicate. If you double-click the line corresponding to the event, an editor will open positioned at the newly inserted code.

We will change the button text when the button is pressed. To do this we modify the code as follows:

<vip>predicates
onPushButtonClick : button::clickResponder.
clauses
onPushButtonClick(_Source) = button::defaultAction() :-
pushButton_ctl:setText("Pressed").</vip>

Now try to build and execute the program again (i.e. press the '''Ctrl+Shift+B''' key combination). If you have followed the steps carefully this should be a success. In the program you should of course open the '''About''' dialog, by selecting the menu entry '''Help -> About'''; and then press the new button.

This is how it looked in my application:

[[Image:tut01_AboutPressMe.png|About: Press Me]][[Image:tut01_AboutPressed.png|About Pressed]]

==Debugging==

The development environment contains a debugger. With the debugger you can trace the execution of your program and examine the program state.

It does not make much sense to go into details with debugging before you have learned the Visual Prolog language. But I will briefly explain the debugger anyway, because it can be very useful for understanding and experimenting with the language.

To start the debugger, select '''Debug -> Run''' in the menu. If the project is not up-to-date it will first be build, after that the debugging session will start.

'''Notice''' you can stop the debugging at any time by selecting '''Debug -> Stop Debugging''' in the menu.

When debugging starts the IDE will first load the debug information and then it will enter the program. The program execution is stopped just before the goal is executed. To indicate this, the goal is opened in an editor window, and the blue arrow points to the goal:

[[Image:tut01_debug1.png|Editor: Current Position]]

You can single step in the program using the '''Step Into '''and '''Step Over''' commands in the '''Debug '''menu.

Try '''Step Into''': this will open another editor with the code of mainExe::run, and the arrow will point to the entry of this code.

In the view menu you can open various debugger windows, which I will briefly explain.

The '''Run Stack''' window:

[[Image:tut01_runStack.png|Run Stack]]

contains a "picture" of the run stack. In principle, the run stack contains a number of lines corresponding to calls that has been made. However, optimization (so called last call optimization) might have removed some entries.

The run stack not only shows the calls, it also shows trap points and backtrack points, these is described in a later tutorial and there I also describe the run stack window in more details.

The '''Local Variables''' window:

[[Image:tut01_localVariables.png|Local Variables]]

contains the local variables corresponding to the selection in the run stack window. Some variables might not yet have received a value, these are show as an underscore (i.e. like originalraiser in the above picture).

The '''Facts''' window:

[[Image:tut01_factsWindow.png|Facts]]

Contains the global state of the program, this state is stored in fact databases. ''Fact databases ''are a unique Visual Prolog feature, which will be described in a later tutorial. You can also add objects from the '''Local Variables '''window to the '''Facts''' window, that way you can track the state changes in interesting objects.

The '''Breakpoints '''window:

[[Image:tut01_breakPointsWindow.png]]

shows the current breakpoints in the program (I have set open breakpoint so that the window would not be empty). You can set/remove breakpoints by selecting '''Debug -> Toggle Breakpoint'''.

The remaining debug windows are for low level debugging and will not be considered here.

==Summary==

The Integrated Development Environment (IDE) makes it possible for you to:

*create

*build

*maintain, and

*debug

your projects. It contains a number of tools, editor and wizards that will help you in your tasks.

[[ru:Среда_разработки]]
[[Category:Tutorials]]

Ide/Environment Overview

2020-01-06T13:06:31Z

Troels Anker Jørgensen: /* Creation */

{{ideNavbar|Environment Overview}}

In this tutorial I will give an overview of the Integrated Development Environment (IDE).The IDE is used to create, develop and maintain your Visual Prolog projects.

Briefly speaking you will use the IDE for the following tasks in a project life cycle:

*'''Creation''': The project is created in the IDE, at creation time you choose important properties of your project, such as whether the project is an executable or a DLL, whether it uses GUI or is text based, etc.

*'''Building''': The project is built, i.e. compiled and linked, from the IDE.

*'''Browsing''': The IDE and the compiler collect information about the project, which is utilized in various ways for quick localization of entities, etc.

*'''Development''': During the development and maintenance of the project, the IDE is used to add and remove source files and GUI entities to the project and to edit these.

*'''Debugging''': The IDE is also used for debugging the project. The debugger is used to follow program execution and exploit the program state when the program runs.In the sequel we will look more detailed at each of these things.

'''Notice''' that the tutorial will start from scratch and create a project that is used for the whole tutorial. The reader is encouraged to do the same. Also notice that clicking on reduced pictures will show them in full scale in a separate window.

==Creation==

First we will create a project by selecting '''Project -> New...''' in the menu. In response to this you are presented to a dialog containing various properties of the project.

[[Image:tut01_projectSettingsS.png]]

I have chosen that my project should have the name ''tut01''.

The project name is also used as the name of the target that is produced. In this case the target is an ''exe'' file so the target name will be ''tut01.exe''.

I have also chosen that the target should be a GUI program, i.e. a program with a graphical user interface.

The '''Base Directory''' is the "base" of all your projects; you should choose a place that is convenient for you.

The new project will be created in a '''Sub-Directory''' of the base directory. By default this directory have the same name as the project itself.

The '''Package Prefix''' is used when creating new "packages" in the system (a later tutorial will explain about the package notion). In case your source files will ever be shared with somebody else it is a good idea if the prefix does not conflict with other prefixes. Therefore it is a good idea to use a prefix that start with a reverse Internet domain name, like ''com/visual-prolog ''(which is the reverse of ''visual-prolog.com'').

For the moment you do not need to consider the remaining tabs and options.

Now create the project by pressing '''Finish'''.

The IDE will now look something like this:

[[Image:tut01_totalS.png]]

You have the '''Project Window''', which contains information about the entities in your project.
You have the '''Messages Window''', which will contain various status and progress messages.

==Building==

Before we make any modifications, we will build (i.e. compile and link) the project. In the '''Build''' menu you find commands for building, compiling and executing the project.

If you choose '''Execute''' the project is first build, so that it is an up to date version you execute. Therefore I will choose '''Execute'''.

If you have not registered Visual Prolog you will be presented to a special screen telling you so. I will suggest that you register, but you can also choose "Continue Evaluation".

In the '''Messages Window''' the IDE writes which files are compiled, etc.

If the build process succeeds, which it does in this case, the created program is executed. As a result you will see a little ''doing-nothing ''GUI program. You might notice that the program looks a bit like the IDE itself. This is no coincidence since the IDE is actually a Visual Prolog program.

Later in this tutorial we will also see what happens, if the compiler or the linker detects errors in the build process.

==Browsing==

Right now we will turn our eyes to the '''Project Tree''' in the '''Project Window''', and explore that a bit. The tree itself is presented in a standard Windows tree control so you should already be familiar with its usage. Here we shall concentrate on the contents of the tree.

Right now the project tree will look like this:

[[Image:tut01_projectWindow1.png|Project Tree]]

The top node represents the project, and the project directory.

Right below that is the logical node '''$(ProDir)''' which represents the directory in which Visual Prolog is installed. This directory contains (as we shall shortly see) libraries and library code from the Visual Prolog system.

Then comes another directory '''TaskWindow,''' which is a subdirectory of the project directory. This directory contains all the code needed to produce the Task Window, its menu and toolbar and the about dialog.

Finally, you see a number of files. Visual Prolog uses the following conventions:

*.'''ph''' files are '''package headers'''. A package is a collection of classes and interfaces that are intended to be used as a chunk.
*.'''pack''' files are '''packages'''. They contain the implementation/definition of the corresponding .ph files.
*.'''i''' file contains an '''interface'''.
*.'''cl''' file contains a '''class declaration'''
*.'''pro''' file contains a '''class implementation'''

If you expand the main.cl node completely you will see the following:

[[Image:tut01_projectWindow2.png|Project Tree]]

This sub-tree shows that the file '''main.cl''' contains a class called '''main''', which contains the declaration of the predicate <vp>run</vp>. Predicates are subroutines, but they will not be considered further in this tutorial.

If we collapse this node again and instead expand the '''TaskWindow''' node, you will see this tree:

You will notice several new kinds of nodes:

*.'''dlg''' file contains a '''dialog'''

*.'''frm''' file contains a '''form'''

*.'''win''' file contains a '''window''' (task window or conventional PFC GUI window)

*.'''mnu''' file contains a '''menu'''

*.'''ico''' file contains an '''icon'''

If you continue to explore you might also meet:

[[Image:tut01_projectWindow3.png|Project Tree: TaskWindow]]

*.'''ctl''' files containing '''controls'''

*.'''tb''' files containing '''toolbars'''

*.'''cur''' files containing '''cursors'''

*.'''bmp''' files containing '''bitmaps'''

*.'''lib''' that are '''libraries'''

If you right click on a node a context menu will appear, with commands that have relevance for that particular node.

If you double click on a node the corresponding entity will be brought up in a suitable editor. All code is edited in a text editor, but windows resources like dialogs and menus are edited in graphical editors. We will look closer to graphical editors below, here we shall try to bring up a text editor.

Some entities are represented twice in the tree, because they have both a declaration and a definition/implementation. For example, the predicate run in the class '''tut01''':

[[Image:tut01_projectWindow2.png|Project Tree]] [[Image:tut01_projectWindow4.png|Project Tree]]

Try double clicking on each of the run nodes, and notice that two editors open showing the declaration and the definition of the run predicate, respectively.

The IDE has other facilities for browsing to specific entities, but these will not be considered here.

==Development==

Now lets try to modify the project a bit. Since we have not yet concerned ourselves with how to program in Visual Prolog, we will keep the changes simple.

We will start by deliberately introducing an error, that way you will not be completely surprised if you make some thing wrong, at the same time you can see the error window.

First you should locate the clauses for the run predicate in the file '''main.pro'''. If you double click the last of the two run nodes in the project tree, an editor opens with the caret placed like this:

[[Image:tut01_editRun1S.png]]

Try inserting a fail like this (notice the comma after show):

<vip>clauses
run():-
TaskWindow = taskWindow::new(),
TaskWindow:show(),
fail.</vip>

After that we try to build the project again: simply press the '''Ctrl+Shift+B''' key combination. The system will now save and compile the file, but since we have made an error, the '''Error Window''' will open:

[[Image:tut01_errorS.png|Error Wondow]]

We will not consider what the error message actually means. Instead you should try to double-click on the error message. You will notice that the editor gets focus again and that the caret points exactly to the fail we inserted.

Reestablish the code without the fail and build the project again.

Next we will try to make a modification in the about dialog. It is not a very sensible change, but it will illustrate a number of things.

First we will open the '''About''' dialog in the '''Dialog Editor''', to do this you double click the dialog in the project tree. The node you have to double click is shown here:

[[Image:tut01_projectWindowAbout.png|Project Window: About Dialog]]

Once you have clicked it you will see the dialog in the '''Dialog Editor''', two toolbars and properties window.

We will add a button to the dialog. You click on the "button" on the controls toolbar, and then you click in the dialog next to the project icon in the '''AboutDialog''' window. As a result you can see the properties of the new control and you can edit them. I have changed the '''Text''' to "Press Me", this is the text that will appear on the button. I can also see the '''Name''' field, the IDE will identify this particular control in various contexts by this Name.

Now it should look something like this:

[[Image:tut01_dialogEditorAbout2.png|Dialog Editor: About Dialog with new button]]

Now we want to do something whenever the button is pressed:

[[Image:Tut01_dialogEditorAboutClick.png]]

The IDE has suggested the name onPushButton for the handling predicate. If you double-click the line corresponding to the event, an editor will open positioned at the newly inserted code.

We will change the button text when the button is pressed. To do this we modify the code as follows:

<vip>predicates
onPushButtonClick : button::clickResponder.
clauses
onPushButtonClick(_Source) = button::defaultAction() :-
pushButton_ctl:setText("Pressed").</vip>

Now try to build and execute the program again (i.e. press the '''Ctrl+Shift+B''' key combination). If you have followed the steps carefully this should be a success. In the program you should of course open the '''About''' dialog, by selecting the menu entry '''Help -> About'''; and then press the new button.

This is how it looked in my application:

[[Image:tut01_AboutPressMe.png|About: Press Me]][[Image:tut01_AboutPressed.png|About Pressed]]

==Debugging==

The development environment contains a debugger. With the debugger you can trace the execution of your program and examine the program state.

It does not make much sense to go into details with debugging before you have learned the Visual Prolog language. But I will briefly explain the debugger anyway, because it can be very useful for understanding and experimenting with the language.

To start the debugger, select '''Debug -> Run''' in the menu. If the project is not up-to-date it will first be build, after that the debugging session will start.

'''Notice''' you can stop the debugging at any time by selecting '''Debug -> Stop Debugging''' in the menu.

When debugging starts the IDE will first load the debug information and then it will enter the program. The program execution is stopped just before the goal is executed. To indicate this, the goal is opened in an editor window, and the blue arrow points to the goal:

[[Image:tut01_debug1.png|Editor: Current Position]]

You can single step in the program using the '''Step Into '''and '''Step Over''' commands in the '''Debug '''menu.

Try '''Step Into''': this will open another editor with the code of mainExe::run, and the arrow will point to the entry of this code.

In the view menu you can open various debugger windows, which I will briefly explain.

The '''Run Stack''' window:

[[Image:tut01_runStack.png|Run Stack]]

contains a "picture" of the run stack. In principle, the run stack contains a number of lines corresponding to calls that has been made. However, optimization (so called last call optimization) might have removed some entries.

The run stack not only shows the calls, it also shows trap points and backtrack points, these is described in a later tutorial and there I also describe the run stack window in more details.

The '''Local Variables''' window:

[[Image:tut01_localVariables.png|Local Variables]]

contains the local variables corresponding to the selection in the run stack window. Some variables might not yet have received a value, these are show as an underscore (i.e. like originalraiser in the above picture).

The '''Facts''' window:

[[Image:tut01_factsWindow.png|Facts]]

Contains the global state of the program, this state is stored in fact databases. ''Fact databases ''are a unique Visual Prolog feature, which will be described in a later tutorial. You can also add objects from the '''Local Variables '''window to the '''Facts''' window, that way you can track the state changes in interesting objects.

The '''Breakpoints '''window:

[[Image:tut01_breakPointsWindow.png]]

shows the current breakpoints in the program (I have set open breakpoint so that the window would not be empty). You can set/remove breakpoints by selecting '''Debug -> Toggle Breakpoint'''.

The remaining debug windows are for low level debugging and will not be considered here.

==Summary==

The Integrated Development Environment (IDE) makes it possible for you to:

*create

*build

*maintain, and

*debug

your projects. It contains a number of tools, editor and wizards that will help you in your tasks.

[[ru:Среда_разработки]]
[[Category:Tutorials]]

File:Tut01 projectSettingsS.png

2020-01-06T13:02:46Z

Troels Anker Jørgensen: Troels Anker Jørgensen uploaded a new version of File:Tut01 projectSettingsS.png

File:Tut01 projectSettingsS.png

2020-01-06T12:48:10Z

Troels Anker Jørgensen: Troels Anker Jørgensen uploaded a new version of File:Tut01 projectSettingsS.png