Lazarus is being used in the 2008-2009 introductory programming course for first-year computer science students at Eindhoven University of Technology. The following information is mainly focused on use under Windows. There may be some small differences for use on other platforms.
Lazarus together with FreePascal is a set of open-source software development tools running on various platforms, including (but not restricted to) Linux, Mac OS X, and Windows. The supported programming language is Object Pascal, which is a Pasal extension that includes object-oriented (OO) features. Both Lazarus and FreePascal are themselves written in Object Pascal.
Lazarus is an Integrated Development Environment (IDE) with a graphical user interface for Rapid Application Development (RAD). The IDE controls the project inspector, source editor, object inspector, code explorer and code browser, compiler, linker, debugger, etc. For development of applications with a Graphical User Interface (GUI), Lazarus offers the Lazarus Component Library (LCL).
FreePascal (FPC) is a compiler for various Pascal dialects targeting multiple platforms. FPC can also be used separately on the command line (Windows: in a command window). FreePascal includes extensive libraries with extra functionality, such as the Run-Time Library (RTL) and Free Component Library (FCL).
Lazarus resembles CodeGear's Delphi, which is a commercial RAD IDE for Object Pascal. FreePascal has a Delphi compatibility mode. However, Delphi and Lazarus projects are not interchangeable. Lazarus does have a tool to help convert a Delphi project into a Lazarus project.
On-line documentation for Lazarus is available in the following places:
On-line documentation for FreePascal:
FreePascal can also be invoked on the command-line (Windows: in a command window) to compile a Pascal program (typically a console application) into an executable:
fpc <file.pas>
NOTE: This assumes that your execution path
includes the path to fpc.
Assuming a standard installation of Lazarus on Windows,
your execution path must include
\lazarus\fpc\<version>\bin\<target>\.
In this way, most Pascal programs can be compiled into executables.
Advantages of using the command-line compiler are:
However, development of applications with a graphical user interface (GUI) is easier with Lazarus.
On Windows:
NOTE: By default, Lazarus starts up with a blank project for developing a GUI application (typically a Form with a grid of dots is shown). For `simple' programming tasks, this is NOT what you want. Choose Project->Close Project to get rid of this blank project (do NOT save anything).
All files needed to build a program are gathered in, what is called,
a project.
A Lazarus Project Information file with extension .lpi
defines which files belong to a project.
It is recommended that you put each project in a separate folder.
To open an existing Lazarus project
NOTE: Even though the project is now open, it is possible that you do not see any windows for this project. Also see Viewing the program in a project.
Projects can also be opened from within the Lazarus IDE:
You can try the project GetalKlutser (in Dutch). The zip archive contains one folder named `GetalKlutser' with a Lazarus Project Information file `GetalKlutser.lpi' and all related files for a console application. (Here is a GUI version for Windows: NumberMunger.)
Make sure that the project is open.
.lpr,
the others are units (typically with extension .pas).
Make sure that the project is open and the program source is visible in the Source Editor.
Make sure the project is open in the IDE.
.exe).
A Console Application (also see Changing the options of a project) automatically opens its own console window (some, or even all, Lazarus windows may be hidden, also see Changing the IDE preferences). When the program finishes, its window automatically closes and the hidden Lazarus windows are shown again. It is often convenient to include the lines
; Write('Type return to dismiss this window: ')
; ReadLn
at the end of a console application.
(The write statement can be omitted, but keep in mind you need to type
return to terminate the program.)
Before typing return,
you can use the Edit->Mark and Copy buttons of the window
(under the icon in the top left corner)
to save program output produced in the window
(e.g. to paste it into some other
editor window where you are making a report).
When a program is running `on its own', you can only observe and control it through the communication actions that it contains. By using the debugger, you can run a program in a more controlled way: in `small' steps, with the possibility to observe the values of variables.
NOTE: It is necessary to provide input in the program's console window when a read or readln statement is executed; otherwise, stepping will NOT continue.
Program variables can be inspected by pointing at the variable name in the Source Editor window, or by adding them to the Watch List (see Watches and Add Watch below). They can be modified through the Evaluate/Modify window (see below).
Step Into executes one line of the program. When that line contains a function or procedure call, execution stops at the first line of the body of the first call. However, this it also `steps into' system calls. Usually, it is best to use Step Over, and only use Step Into when you really want to delve into details.
Step Over executes one line of the program. When that line contains a function or procedure call, these are executed completely without intermediate stopping.
In larger programs (more than a few screens of code), it may be helpful to set breakpoints when tracing the program's execution.
Make sure the project is open in the IDE and visible in the Source Editor. The Lazarus Source Editor is a fairly standard text editor with syntax highlighting and some other features (also see Changing the IDE preferences), such as an extensive Search/Replace commands (see Search menu). You can change the program text in this window.
When the FreePascal Object Pascal Compiler or Linker detects errors or reasons for warnings, these are listed the Messages window. Clicking a message in the bottom part, highlights the corresponding line in the Editor window. The message briefly explains what is the matter. Additional help can be obtained by selecting the message and typing F1.
NOTE: The `real' cause of an error may be located in a different place from where the tools mark it (typically, earlier in the file).
When a runtime error (e.g. division by zero) occurs while a program executes from within the IDE, an error message is shown in a separate window, and the offending line is highlighted in the Source Editor. See Tracing the program's execution for ways of obtaining more information about the error state.
However, when a console-application program is run from the command line, an error message appears on the console. The error message includes a stack trace (with line numbers, if the project was derived from the `TUE Console Application', as explained next).
This is slightly complicated (but making it easier is even harder :-)
TUeConsoleApp.lpi
in the folder TUE Console Application,
or an existing Lazarus project that was derived earlier from the
`TUeConsoleApp' project.
Also see Opening an existing project.
TUeConsoleApp part of the file name
before clicking Save.
Lazarus automagically changes the program name in the file as well
(next to the keyword program).
NOTE:
program)
as the file it is stored in.
Consequently, the file name (minus its extension)
must be a legal Pascal identifier.
If this condition is not met,
Lazarus may not compile and run the program.
The project options for console-application projects started from `TUE Console Application' (see Creating a new project) have been set appropriately for `beginners'. The project options for application projects started in other ways (e.g. the default blank project when Lazarus is started from the Start menu) are usually less appropriate and need adjustment.
The project's options are divided into project options proper and compiler options
The behavior of the IDE can be modified through a large set of Options.