A.7 The workspace

The workspace contains all the elements defined by the user. These are:

A.7.1 Procedures

Procedures are a kind of “program”. When a procedure is called, the instructions in the body of the procedure are executed. A procedure is defined with the keyword to.

  to name_of_procedure :v1 :v2 :v3 .... [:v4 ....] [:v5 ....]  
  Body of the procedure  
  end

Eg:

  to square :s  
  repeat 4[fd :s rt 90]  
  end

The procedure is called square  and takes a parameter called s. square 100 will therefore produce a square, the length of whose sides is 100. (See the examples of procedures at the end of this manual.)

Since version 0.7c, it is possible to insert comments in the code preceded by #.

to square :s 
#this procedure allows a square to be drawn whose side equals :s. 
repeat 4[fd :s rt 90] # handy, isn’t it? 
end 

Optional variables

It’s now possible to add optional arguments to XLogo’s procedure. Look at the example below:

to poly :n [:l 10]  
repeat :n [fd :l rt 360/:n]  
end  
 
# this command will draw a regular polygon with  
# 20 sides of 10  
poly 20

During the interpretation, the variable :l has been replaced by its default value, I mean 10. If I we want to modify this value, we have to call the procedure poly between parenthesis to notice to the interpreter that we’re going to use optional arguments.

# This command will draw a regular polygon with 20  
# sides. Every side is 5 long.  
 (poly 20 5)  
# This is a square with each side equal to 100  
(poly 4 100)

Primitive ’trace

It is possible to follow the working of a program or have it show the procedures which are working. This mode can also show if the procedures provide arguments thanks to the primitive output.

trace


Activate trace mode

stoptrace


stoptrace will disactivate the trace mode.

A small example with the factorial (see page ß).
trace pr fac 4  
fac 4  
  fac 3  
    fac 2  
      fac 1  
      fac returns 1  
    fac returns 2  
  fac returns 6  
fac returns 24  
24

A.7.2 Concept of variables

There are two kinds of variables:

In this version of LOGO, local variables are not accessible in sub-procedures. At the end of the procedure, the local variables are deleted.

make word1 arg2


If the local variable word1 exists, assigns it the value arg2. If not, creates a global variable word1 and assigns it the value arg2.
 Eg: make “a 100 assigns the value 100 to the variable a

local arg1


Creates a variable called arg1. If arg1 is a list, creates all variables contained in the list. Note, this is not initialised. To assign it a value, see make.

localmake word1 arg2


Creates a new local variable and assigns it the value arg2.

define, def word1 list1


Define a new procedure called word1.
list1 contains several lists:
def "polygon [ [nb length] [repeat :nb[fd :length rt 360/:nb] ]

—-> this command defines a procedure called polygon with two variables (:nb and :length). This procedure draws a regular polygon, we can choose the number of sides and their length.

text word1


Returns all information about the procedure called word1. It gives a list which contains several lists.

This primitive is of course associated to define.

thing word1


returns the value of the variable word1. thing "a is similar to :a

eraseprocedure, erp arg1


Deletes the procedure calling arg1 or all procedures that contains the list arg1.

erasevariable, erv arg1


Deletes the variable arg1 or all variables that contains the list arg1.

erasepropertylist, erpl arg1


Deletes the property list arg1 or all property lists that contains the list arg1.

erall, eraseall


Deletes all the variables, property lists and procedures currently running.

bye


Quit XLOGO.

procs, procedures


Returns a list which contains all the procedures currently defined.

variables vars


Returns a list which contains all the defined variables.

pls, propertylists


Returns a list which contains all the property lists currently defined.

primitives


Enumerates all primitives for the current language.

contents


Returns a list which contains 3 lists. The first list contains all procedures names, the second all variables names and the last all propert lists names.

run list1


Executes the list of instructions contained in list1

externalcommand list1


Run a system command from XLOGO. list1 must contain several lists which represent any word constituing the command. Some few examples:

externalcommand [[gedit][/home/xlogo/file.txt]]
Run the application gedit and loads the file /home/xlogo/file.txt (Linux)

externalcommand [[notepad][C: /file.txt]]
Run the application notepad and loads the file called C: /file.txt (Windows)

This syntax a bit ... particular allow to specify white spaces in file path.

A.7.3 Property Lists

Now, you can define property lists with XLogo. Each list has a specific name and contains some key-value couples.

For example, we can consider a property list named ”car“. It should contain the key ”color“ associated to the value ”red“, or the key ”type“ and the value ”4x4“.

To handle these lists, we can use the following primitives:

pprop putproperty listname key value


Adds a property to the property list named listname. value will be accessible with the key key. If no property list named listname exists, then it will be created.

gprop getproperty listname key


Returns the value associated with the key key in the property list called listname. If this property list doesn’t exist or if there isn’t any valid key, it returns an empty list.

rprop removeproperty listname key


Removes the corresponding couple key-value in the property list listname.

plist propertylist listname


Displays all key-value couples contained in the property list called listname.

Let’s return to the property list called ”car“.
# Filling property list  
pprop "car "color "red  
pprop "car "type "4x4  
pprop "car "vendor "CitroŽn  
 
# Display one value  
print gprop "car "color  
red  
 
# Display all elements  
print plist "car  
color red type 4x4 vendor CitroŽn


files


By default, lists the contents of the directory. (Equivalent to the ls command for Linux users and the dir command for DOS users)

loadimage, li list


Load the image file contained in the list. Its upper left corner will be placed at the turtle’s location. The only supported formats are .png and .jpg. The path specified must be relative to the current folder. Eg: setdir "C:\\my_images_dir loadimage "turtle.jpg

saveimage word list


Saves the drawing area image in file specified with word in the current directory.
The supported format are png and jpg. If you don’t specify any extension, the default format is png.
The list contains four numbers [XminY minXmaxY max] which allow to specify the two corners if you want a zone selection. An empty list is equivalent to the whole image. An example:
## In the editor  
to test  
repeat 20 [  
  forward 30 right 18  
  # Save all images as 1.png, 2.png ... 20.png  
  saveimage word repcount ".png  [-50 150 200 -150]  
]  
end  
 
## In the command line:  
test  
clearscreen hideturtle repeat 20 [loadimage word repcount ".png]

And you create a little animation!

setdirectory, setdir word1


Specifies the current directory. The path must be absolute. The directory must be specified with a word.

changedirectory, cd word1


Allows to choose the current directory. The path is related to the current directory. You can use the ’..’ notation to refer to the parent directory.

directory, dir


Gives the current directory. The default is the user’s home directory, ie /home/your_login for Linux users, C:\WINDOWS for Windows users.

save word1 list2


A good example to explain this: save "test.lgo [proc1 proc2 proc3] saves in the file test.lgo in the current directory the procedues proc1, proc2 et proc3. If the extension .lgo is omitted, it is added by default. word1 gives a relative path starting from the current directory. This command will not work with an absolute path.

saved word1


saved "test.lgo saves in the file test.lgo in the current directory the collection of procedures currently defined. If the extension .lgo is omitted, it is added by default. word1 gives a relative path starting from the current directory. This command will not work with an absolute path.

ed, edit arg1


Open the editor with all the procedures specified in the list arg1 or in the word arg1.

edall, editall


Open the editor with all the currently defined procedures.

load word1


Opens and reads the file word1. For example, to delete all the defined procedures and load the file test.lgo, you would use: efns load "test.lgo. word1 gives a relative path starting from the current directory. This command will not work with an absolute path.

openflow id file


When you want to read or write in a file, you must first open a flow toward this file. The argument file must be the name of the file you want. You must use a phrase to show the name of the file in the current directory. The id argument is the number given to this flux so as to identify it.

listflow


Shows the list of the various open fluxes with their identifiers.

readlineflow id


Opens the flow which identifier corresponds to the number used as argument and then reads a line in this file.

readcharflow id


Opens the flux which identifier corresponds to the number used as argument and then reads a character in this file. This primitive sends back a number representing the value of the character (similar to readchar).

writelineflow id list


Writes the text line included in list at the beginning of the file identified thanks to the identifier id. Be careful, the writing is effective only after the flow has been closed by the primitive closeflow.

appendlineflow id list


Writes the text line included in list at the end of the file identified thanks to the identifier id. Be careful, the writing is effective only after the flux has been closed by the primitive closeflow.

closeflow id


Closes the flux when its identifier number is written as argument.

endflow? id


Sends back "true if it is the end of the file. Otherwise sends back "false.

Here is an example of the use of primitives allowing to read and write in a file. I will give this example in a Windows-type framework. Other users should be able to adapt the following example.

The aim of this file is to create the file c:\example containing the following three lines:

ABCDEFGHIJKLMNOPQRSTUVWXYZ
Abcdefghijklmnopqrstuvwxyz
0123456789
# You open a flow towards the desired file. This flow is given the number 2  
setdirectory "c:\\  
openflow 2 "example  
# You type the desired lines  
writelineflow 2 [abcdefghijklmnopqrstuvwxyz]  
writelineflow 2 [abcdefghijklmnopqrstuvwxyz]  
writelineflow 2 [0123456789]  
# You close the flux to end the writing  
closeflow 2

Now, you can see the writing procedure went alright:

# You open a flow towards the file you want to read. This flow is given the number 0  
openflow 0 "c:\\example  
# You read the one after the other the different lines from the file  
pr readlineflow 0  
pr readlineflow 0  
pr readlineflow 0  
# You close the flow  
closeflow 0

if you wish to add the line ’Great !’:

setdirectory "c:\\  
openflow 1 "example]  
appendlineflow 1 [Great!]  
closeflow 1