QUICK REFERENCE GUIDE

FOR mikroPascal
2

Lexical Elements Overview

The mikroPascal quick reference guide provides formal definitions of lexical elements the
mikroPascal programming language consists of. These elements are word-like units rec-
ognized by such programming language. Every program written in mikroPascal consists
of a sequence of ASCII characters such as letters, digits and special signs. Non-printing
signs such as newline characters, tab etc. are also referred to as special signs. A set of
basic elements in mikroPascal is well-organized and finite. Programs are written in the
mikroPascal Code Editor window. During the process of compiling, each file code is
parsed into tokens and whitespaces.

Whitespace
Spaces (blanks), horizontal and vertical tabs and newline characters are together called
whitespaces. Whitespaces are used as separators to indicate where tokens start and
end. For example, the two following sequences

var i : char;
j : word;

and
var
i : char;

j : word;

are lexically equivalent and parse identically giving the nine tokens each:
var
i
:
char
;
j
:
word
;

Whitespace in Strings
Whitespace may occur within string literals. In this case it is not used as a parser, but is con-
strued as a common character, i.e. represents part of the string alone. For example, the follow-
ing string

some_string := 'mikro foo';

parses into four tokens, including the string literal as a single token:
some_string
:=
'mikro foo'
;
 3

Tokens
A token is the smallest element of the Pascal programming language which is recognized
by the compiler. The parser analyzes the program code from left to right and creates the
longest possible tokens from the sequence of input characters.

Keywords
Keywords or reserved words are tokens with fixed meaning which cannot be used as
identifiers. In addition to standard mikroPascal keywords, there is a set of predefined
identifiers (of constants and variables) referred to as reserved words. They describe spe-
cific microcontroller and cannot be redefined. Here is a list of the mikroPascal keywords
in alphabetical order:

absolute except nil requires

abstract export nodefault rx
and exports not safecall
array external object sbit
as far of sealed
asm file on set
assembler final operator sfr
at finalization or shl
automated finally org shr
bdata for out small
begin forward overload stdcall
bit goto override stored
case helper package string
cdecl idata packed threadvar
class if pascal to
code ilevel pdata try
compact implementation platform type
const in private unit
constructor index procedure until
contains inherited program uses
data initialization property var
default inline protected virtual
deprecated interface public volatile
destructor io published while
dispid is raise with
dispinterface label read write
div library readonly writeonly
do message record xdata
downto mod register xor
dynamic name reintroduce
end near repeat
4

Comments
Comments are part of the program used for clarifying program operation or for providing
more information about it. They are exclusively intended for the programmer’s use and
are removed from the program before parsing. There are single-line and multi-line com-
ments in mikroPascal. Multi-line comments are enclosed in braces or (* and *) as in
example below:
{ Text within left and right brace
makes a comment which may span multiple lines. }

(* Comment can be
written in this way too. *)

Single-line comments start with ‘//’. Here is an example:

// Any text between a double-slash and the end of the
// line makes a single-line comment.

Besides, blocks of assembly instructions may introduce single-line comments by placing

‘;’ before the comment:
asm
some_asm ; This assembly instruction …
end;

Identifiers
Identifiers are arbitrary names used for designating the basic language objects (labels, types,
constants, variables, procedures and functions). Identifiers may contain all the letters of alpha-
bet (both upper case and lower case), the underscore character ‘_’ and digits (0 to 9). The first
character of an identifier must be a letter or an underscore. mikroPascal is not case sensitive,
so that Sum, sum, and suM are recognized as equivalent identifiers. Although identifier names
are arbitrary (within the rules stated), some errors may occur if the same name is used for more
than one identifier within the same scope. Here are some valid identifiers:
temperature_V1
Pressure
no_hit
dat2string
SUM3
_vtext

Here are some invalid identifiers:

7temp // NO -- cannot begin with a numeral
%higher // NO -- cannot contain special characters
xor // NO -- cannot match reserved word
j23.07.04 // NO -- cannot contain special characters (dot)

Literals
Literals are tokens representing fixed numerical or character values. The compiler deter-
mines data type of a literal on the basis of its format (the way it is represented in the
code) and its numerical value.
 5

Integer Literals
Integral literals can be written in decimal, hexadecimal or binary notation.

 In decimal notation, integer literals are represented as a sequence of digits (without

commas, spaces or dots), with optional prefix + or - (operator). Integer literals with-
out prefix are considered positive. Accordingly, the number 6258 is equivalent to the
number +6258.
 Integer literals with the dollar sign ($) or 0x prefix are considered hexadecimal
numbers. For example, $8F or 0x8F.
 Integer literals with the percent sign prefix (%) are considered binary numbers. For
example, %0101.

Here are some examples of integer literals:

11 // decimal literal
$11 // hex literal equal to decimal 17
0x11 // hex literal equal to decimal 17
%11 // binary literal equal to decimal 3

The allowed range for constant values is determined by the longint type for signed con-
stants and dword type for unsigned constants.

Floating Point Literals

A floating point literal consists of:

 Decimal integer;
 Decimal point;
 Decimal fraction; and
 e or E and a signed integer exponent (optional).

Here are some examples of floating point literals:

0. // = 0.0
-1.23 // = -1.23
23.45e6 // = 23.45 * 10^6
2e-5 // = 2.0 * 10^-5
3E+10 // = 3.0 * 10^10
.09E34 // = 0.09 * 10^34

Character Literals
Character literals are ASCII characters, enclosed in single quotation marks. Character literals
may be assigned to variables of integral and string type, array of characters and array of bytes.
A variable of integral type will be assigned the ASCII value of the corresponding character lit-
eral. Note that double quotation marks ("") have no special meaning in mikroPascal.
6

String Literals
String literal represents a sequence of ASCII characters written in one line and enclosed
in single quotation marks. As mentioned before, string literals may contain whitespaces.
The parser does not “go into” string literals, but treats them as single tokens. The length
of a string literal depends on the number of characters it consists of. There is a final null
character (ASCII zero) at the end of each string literal. It is not included in the string’s total
length. A string literal with nothing in between the quotation single marks (null string) is
stored as one single null character. String literals can be assigned to string variables, array
of char or array of byte. Here are several string literals:
'Hello world!' // message, 12 chars long
'Temperature is stable' // message, 21 chars long
' ' // two spaces, 2 chars long
'C' // letter, 1 char long
'' // null string, 0 chars long

Punctuators
mikroPascal uses the following punctuators (also known as separators):

 [ ] - square brackets;
 ( ) - parentheses;
 , - comma;
 ; - semicolon;
 : - colon
 . - dot

Square brackets
Brackets [ ] are used for indicating single and multidimensional array’s indices:

var alphabet : array[1..30] of byte;

alphabet[3] := 'c';

Parentheses
Parentheses ( ) are used for grouping expressions, isolating conditional expressions and
for indicating function calls and function declarations:
d := c * (a + b); // Group expressions
if (d = z) then ... // Conditional expressions
func(); // Function call, no parameters
function func2(n : word); // Function declaration with parameters

Comma
Commas ‘,’ are used for the purpose of separating parameters in function calls, identi-
fiers in declarations and elements of initializer:
Lcd_Out(1, 1, txt);
var i, j, k : byte;
const MONTHS : array[1..12] of byte = (31,28,31,30,31,30,31,31,30,31,30,31);
 7

Semicolon
Every statement in mikroPascal must be terminated by a semicolon ‘;’. The only excep-
tion is the last (outermost) end statement in the program which is terminated by a dot,
as well as the statement preceding the else keyword. The semicolon is also used for
denoting the place in assembly blocks where comments start.

Colon
A colon (:) is used in declarations for separating variable and constant identifiers from
type identifiers. For example:
var
i, j : byte;
k : word;

In the program, the colon is used for indicating a label:

start: nop;
...
goto start;

Dot
A dot (.) is used to indicate access to a record field. It can also be used for accessing
individual bits of registers in mikroPascal. For example:
person.surname := 'Smith';

Program Organization
Similar to other programming languages, mikroPascal provides a set of strictly defined
rules to be observed when writing programs. In other words, all the programs written in
mikroPascal have a clear and well-organized structure. Some of the program examples
are given in text below. Every project written in mikroPascal consists of a project file and
one or more units (files with the .mpas extension). The project file provides information
on the project itself, whereas units contains program code.

Main Unit
Every project in mikroPascal requires a single main unit. It is identified by the program
keyword placed at the beginning of the unit, thus instructing the compiler from where to
start the process of compiling. After an empty project is successfully created in Project
Wizard, the main unit will be automatically displayed in the Code Editor window. It con-
tains the basic structure of the program written in mikroPascal. Nothing may precede the
program keyword, except comments. The uses clause may optionally be placed after
the program name. All global identifiers of constants, variables, labels and routines are
declared before the begin keyword.
8

Structure of the Main Unit

Basically, the main unit can be divided in two sections: declarations and program body.
Declarations must be properly organized and placed in the code. Otherwise, the compil-
er may not be able to interpret the program correctly. When writing a code, it is advisable
to follow the model presented below.

The main unit is to look as follows:

program {program name}
uses {include other units}

//********************************************************
//* Global declarations:
//********************************************************

{constant declarations}
const ...

{variable declarations}
var ...

{label declarations}
label ...
{procedure declarations}
procedure procedure_name
{local declarations}
begin
...
end;

{function declarations}
function function_name
{local declarations}
begin
...
end;

//********************************************************
//* Program body:
//********************************************************

begin
{write your code here}
end.

Other units
Other units allow you to:

 break large programs into encapsulated parts that can be edited separately;
 create libraries that can be used in different projects; and
 distribute libraries to other developers without disclosing the source code.
 9

Every unit is stored in its own file and compiled separately. Compiled units are linked
together for the purpose of creating an executable code. To build a project, the compiler
needs all the units either as program code files or object files (files created by compiling
units). All units start with the unit keyword. Apart from the comments, nothing may pre-
cede the unit keyword. The uses clause may follow the unit name.

Structure of Other Units

Every unit consists of three sections. These are uses, interface and implementation sec-
tion. Only the implementation section is obligatory. Follow the model presented below:

unit { unit name }

uses { include other units }
//********************************************************
//* Interface (globals):
//********************************************************
{ constant declarations }
const ...
{ variable declarations }
var ...

{ procedure prototypes }
procedure procedure_name(...);

{ function prototypes }
function function_name(...);

//********************************************************
//* Implementation:
//********************************************************

implementation
{ constant declarations }
const ...

{ variable declarations }
var ...
{ label declarations }
label ...

{ procedure declarations }
procedure procedure_name
{ local declarations }
begin
...
end;

{ function declarations }
function function_name
{ local declarations }
begin
...
end;

end.
10

Uses Clause
mikroPascal includes units by means of the uses clause. It consists of the uses reserved
word and one or more comma-delimited unit names, followed by a semicolon. Unit name
does not include extension. Every unit may include at most one uses clause which must
be placed immediately after the unit name. Here is an example:

unit MyUnit;
uses utils, strings, Unit2;
...

After reaching the unit name, the compiler checks if the project contains files with the
given name and .mcl and .mpas extensions in the order and places specified in the
Search Paths option.

 If both .mpas and .mcl files are found, the compiler will check their dates and include
a file of later date in the project. If the .mpas file is of later date, the compiler will
recompile it and generate new .mcl file by copying the old one;

 If only .mpas file is found, the compiler will recompile it and generate the .mcl file;

 If only .mcl file is found, the compiler will include it as found;

 If no file is found, the compiler will report an error.

Interface Section
A part of the unit above the implementation keyword is referred to as interface section.
It contains global declarations of constants, variables and labels for the project. Routines
cannot be defined in this section. Instead, the section contains declarations of routines,
defined in the implementation section, which are to be visible beyond the unit. Routine
declarations must completely match definitions thereof.

Implementation Section
The Implementation section contains private routine declarations and definitions and
allows code encapsulation. Everything declared below the implementation keyword is
for private use only, i.e. has the scope limited to that unit and thus can be used in any
block or routine defined within that unit. Any identifier declared within this section of the
unit cannot be used beyond that unit, only in routines defined after declaration of the
given identifier.
 11

Scope and Visibility

Scope
The scope of an identifier represents the part of the program in which the identifier can
be used. There are different categories of scope depending on how and where identifiers
are declared:

Place of declaration Scope

Identifier is declared in
Scope extends from the point where identifier is declared
sections for program,
to the end of the current block, including all the blocks
function or procedure
within that scope.
declaration.
Scope extends from the point where identifier is declared
Identifier is declared in the
to the end of the current unit, as well as to all other project
interface section of the unit.
units using that unit.
Identifier is declared in the
Scope extends from the point where identifier is declared
implementation section of
to the end of the current unit. The identifier is available to
the unit, but not within
any function or procedure defined below its declaration.
function or procedure block.

Visibility
Similar to scope, the visibility of an identifier represents the part of the program in which
the identifier can be used. Scope and visibility usually coincide, though there are some
situations in which an object referred to by an identifier becomes temporarily hidden by
its duplicate (an identifier with the same name, but different scope). In this case, the
object still exists, but cannot be accessed by its original identifier until the scope of the
duplicate identifier ends. The visibility cannot exceed the scope, but the scope can
exceed the visibility.

Types
mikroPascal is strictly typed language, which means that each variable and constant
must have its type defined before the process of compiling starts. Type checking may
prevent objects from being illegally assigned or accessed.

mikroPascal supports standard (predefined) data types such as signed and unsigned
integers of various sizes, arrays, strings, pointers etc. Besides, the user can define new
data types using the type directive. For example:

Type MyType1 = array[10] of byte;

MyType2 = integer;
MyType3 = ^word;
MyType4 = ^MyType1;

var mynumber:MyType2;
12

Simple Types
Simple types represent types that cannot be broken down into more basic elements.
Here is an overview of simple types in mikroPascal:

Type Size Range

byte 8–bit 0 – 255
char 8–bit 0 – 255
word 16–bit 0 – 65535
dword 32–bit 0 – 4294967295
short 8–bit -128 – 127
integer 16–bit -32768 – 32767
longint 32–bit -2147483648 – 2147483647
-38 38
real 32–bit ±1.17549435082 * 10 .. ±6.80564774407 * 10
bit 1-bit 0-1
sbit 1-bit 0-1
* char type can be treated as byte type in every aspect

Arrays
An array represents a finite and arranged set of variables of the same type called ele-
ments. Type of elements is called the base type. The value of an element can be
accessed by its index which is unique for each element so that different elements may
contain the same value.

Array Declaration
Arrays are declared in the following way:
array[index_start .. index_end] of element_type

Each element of an array is numbered from the first index (index_start) to the last one
(index_end). The index_start specifier can be omitted along with dots, and thus, it
defaults to zero. The element_type specifier represents the type of array elements (the
base type). Each element of an array can be accessed by specifying array name followed
by the element index enclosed in square brackets. Here are a few examples:

var
weekdays : array[1..7] of byte;
samples : array[50] of word;

begin
// Now we can access elements of array variables, for example:
samples[0] := 1;
if samples[37] = 0 then ...
 13

Constant Arrays
Constant array is initialized by assigning it a comma-delimited sequence of values
enclosed in parentheses. For example:

// Declare a constant array which holds number of days in each month:

const MONTHS: array[1..12] of byte =
(31,28,31,30,31,30,31,31,30,31,30,31);
// Declare a constant numbers:
const NUMBERS: array[4] of array[4] of byte = ((0, 1, 2, 3),
(5, 6, 7, 8), (9, 10, 11,12), (13,14, 15, 16));

The number of assigned values must not exceed the specified array length, but can be
less. In this case, the trailing “excess” elements will be assigned zeroes.

Multi-dimensional Arrays
An array is one-dimensional if it is of scalar type. One-dimensional arrays are sometimes
referred to as vectors. Multidimensional arrays are created by declaring arrays of array
type. Here is an example of a 2-dimensional array:

m: array[50] of array[20] of byte; //2-dimensional array of size 50x20

The m variable represents an array of 50 elements which in turn represent arrays of 20

elements of byte type each. This is how a matrix of 50x20 elements is created. The first
element is m[0][0], whereas the last one is m[49][19]. If an array is a function parameter
then it has to be passed by reference as in the following example:

procedure example(var m: array[50] of array[20] of byte); // we can

// omit the first dimension
begin
...
inc(m[1][1]);
end;

var
m: array[50] of array[20] of byte;// 2-dimensional array of size 50x20
n: array[4] of array[2] of array[7] of byte; // 3-dimensional array of size 4x2x7
begin
...
func(m);
end.

Strings
A string represents a sequence of characters, and is equivalent to an array of char. It is
declared in the following way:
string_name string[length]
14

The string_name specifier represents a string name and must be valid identifier. The
string_length specifier represents the number of characters the string consists of. At the
end of each string, there is a final null character (ASCII code 0) which is not included in
string’s total length. A null string ('') represents an array containing a single null character.
Strings can be assigned to variables of string type, array of char and array of byte. For
example:

var
msg1 : string[20];
msg2 : string[19];
begin
msg1 := 'This is the first message';
msg2 := 'This is the second message';
msg1 := msg2;

A string can also be accessed element–by–element. For example:

String Splicing

var s : string[5];
//...
s := 'mik';
{
s[0] is char literal 'm'
s[1] is char literal 'i'
s[2] is char literal 'k'
s[3] is zero
s[4] is undefined
s[5] is undefined
}

mikroPascal allows you to splice strings by means of the plus operator ‘+’. This kind of con-
catenation may apply to string variables, string literals, character variables and character liter-
als. Non-printing characters can be represented by means of a non-quoted hash sign and a
number representing the ASCII code thereof (e.g. #13 for CR). For example:

var msg : string[100];

res_txt : string[5];
res, channel : word;
begin
//...
// Get result of ADC
res := Adc_Read(channel);

// Create string out of numeric result

WordToStr(res, res_txt);
// Prepare message for output
msg := 'Result is' + // Text "Result is"
#13 + #10 + // Append CR/LF sequence
res_txt + // Result of ADC
'.'; // Append a dot

mikroPascal includes the String Library which facilitates string related operations.
 15

Pointers
A pointer is a variable which holds memory address of an object. While variable directly
accesses some memory address, the pointer can be thought of as a reference to that
address. To declare a pointer, it is necessary to add a carat prefix (^) before its type. For
example, to declare a pointer to an object of integer type, it is necessary to write:

^integer;

To access data stored at the memory location pointed to by a pointer, it is necessary to

add a carat suffix after the pointer name. For example, let’s declare the p variable which
points to an object of word type, and then assign value 5 the object:
var p : ^word;
...
p^ := 5;

A pointer can be assigned to another pointer. It makes both pointers point to the same
memory location. Modifying the object pointed to by one pointer causes another object
pointed to by another pointer to be automatically changed since they share the same
memory location.

@ Operator
The @ operator returns the address of a variable or routine, i.e. directs a pointer to its
operand. The following rules apply to this operator:

 If X is a variable, @X returns the address of X.

If variable X is of array type, the @ operator will return the pointer to its first basic ele-
ment, except when the left side of the statement in which X is used is array pointer. In
this case, the @ operator will return the pointer to the array, not to its first basic element:

program example;
var w_ : word;
ptr_b : ^byte;
ptr_arr : ^array[10] of byte;
arr : array[10] of byte;
begin
ptr_b := @arr; // @ operator will return ^byte
w_ := @arr; // @ operator will return ^byte
ptr_arr := @arr; // @ operator will return ^array[10] of byte
end.

 If F is a routine (function or procedure), @F returns the pointer to F.

16

Function Pointers
mikroPascal allows the use of function pointers. This example illustrates how to define and
use function pointers. We will first define procedural type and function pointer, then call the
function by means of the pointer.

// Procedural type definition

type TMyFunctionType = function (param1, param2: byte; param3: word) : word;

// Pointer to previously defined procedural type

var MyPtr: ^TMyFunctionType;
Sample: word;

// Function definition
// Function prototype should match type definition.
function Func1(p1, p2: byte; p3: word): word;
begin
result := p1 and p2 or p3; // return value
end;

function Func2(abc: byte; def: byte; ghi: word): word;

begin
result := abc * def + ghi; // return value
end;

function Func3(first, yellow: byte; monday: word): word;

begin
result := monday - yellow - first; // return value
end;

// main program:
begin
// MyPtr now points to Func1
MyPtr := @Func1;
// Call function Func1 via pointer
Sample := MyPtr^(1, 2, 3);
// MyPtr now points to Func2
MyPtr := @Func2;
// Call function Func2 via pointer
Sample := MyPtr^(1, 2, 3);
// MyPtr now points to Func3
MyPtr := @Func3;
// Call function Func3 via pointer
Sample := MyPtr^(1, 2, 3);
end.
 17

Records
A record represents a heterogeneous set of elements. Each element is called a field.
Record declaration specifies the name and type of each field. For example:

type recordTypeName = record

fieldList1 : type1;
...
fieldListn : typen;
end;

The recordTypeName specifier represents a record name which must be valid identifi-
er, specifiers fieldList1..fieldListn represent lists of comma-delimited record field iden-
tifiers, whereas specifiers type1.. typen represent types of appropriate record fields. The
scope of a field identifier is limited to the record in which it occurs, so that it is not nec-
essary to take care of naming conflicts between field identifiers and other variables. Note
that in mikroPascal the record can be declared as a new type only.
For example, the following declaration creates a record called TDot:
type TDot = record
x, y : real;
end;

Each TDot contains two fields: x and y coordinates. Memory is not allocated until an
object of record type is defined as in the following example:

var m, n: TDot;

Such declaration creates two instances of TDot, called m and n.

A record field can be previously defined record. For example:

// Structure defining a circle:
type
TCircle = record
radius : real;
center : TDot;
end;

Accessing Fields
Record fields may be accessed by means of the dot (.) operator. If we declare variables
circle1 and circle2 of the previously defined type TCircle,

var circle1, circle2 : TCircle;

their individual fields can be accessed in the following way:

circle1.radius := 3.7;
circle1.center.x := 0;
circle1.center.y := 0;
18

Type Conversions
Conversion of an object of one type is the process of changing its type into another type.
mikroPascal supports both implicit and explicit conversions of basic types.

Implicit Conversion
The compiler automatically performs implicit conversion in the following situations:

 if a statement requires an expression of particular type, but expression of different

type is used;
 if an operator requires an operand of particular type, but operand of different type is
used;
 if a function requires a formal parameter of particular type, but is assigned an object
of different type; and
 if a function result does not match the declared function return type.

Promotion
When operands are of different types, implicit conversion promotes a less complex to a
more complex type as follows:

bit  byte/char
byte/char word
short  integer
short  longint
integer  longint
integral  real

Higher bytes of an extended unsigned operand are filled with zeroes. Higher bytes of an
extended signed operand are filled with a bit sign. If the number is negative, higher bytes
are filled with ones, otherwise with zeroes. For example:
var a : byte; b : word;
...
a := $FF;
b := a; // a is promoted to word, b to $00FF

Clipping
In assignment statements and statements requiring an expression of particular type, the
correct value will be stored in destination only if the result of expression doesn’t exceed
the destination range. Otherwise, excess data, i.e. higher bytes will simply be clipped
(lost).
var i : byte; j : word;
...
j := $FF0F;
i := j; // i becomes $0F, higher byte $FF is lost
 19

Explicit Conversion
Explicit conversion can be executed upon any expression by specifying desired type
(byte, word, short, integer, longint, dword or real) before the expression to be con-
verted. The expression must be enclosed in parentheses. A special case represents con-
version between signed and unsigned types. Such explicit conversion does not affect
binary representation of data. For example:
var a : byte; b : short;
...
b := -1;
a := byte(b); // a is 255, not 1
// This is because binary representation remains
// 11111111; it's just interpreted differently now

Explicit conversion cannot be performed upon the operand to the left of the assignment
operator:

word(b) := a; // Compiler will report an error

Here is an example of conversion:

var a, b, c : byte; cc : word;

...
a := 241;
b := 128;

c := a + b; // equals 113
c := word(a + b); // equals 369
cc := a + b; // equals 369

Note: Conversion of floating point data into integral data (in assignment statements or via
explicit typecast) produces correct results only if the float value does not exceed the scope
of destination integral type.
20

Variables
A variable is an object the value of which can be changed during the runtime. Every vari-
able is declared under unique name which must be a valid identifier. Variables can be
declared in the file and routine declaration sections. Each variable needs to be declared
before it is used in the program. Global variables (visible in all files) are declared in the
the main unit declaration sections. It is necessary to specify data type for each variable.
The basic syntax of the variable declaration is:

var identifier_list : type;

The identifier_list specifier represents a list of comma-delimited variable identifiers,

whereas the var_type specifier represents their type. mikroPascal allows a shortened
version of the syntax comprising of the var keyword followed by multiple variable decla-
rations. For example:

var i, j, k : byte;
counter, temp : word;
samples : array[100] of word;

Constants
A constant is an object the value of which cannot be changed during the runtime. RAM
memory is not used for their storage. Constants are declared in the file and routine dec-
laration sections as follows:

const constant_name [: type] = value;

Every constant is declared under unique name (specifier constant_name) which must
be a valid identifier. Constant names are usually written in uppercase. When declaring a
constant, it is necessary to specify its value matching the given type. Specifying the type
is optional. In the absence of type, the compiler assumes a simple type with the smallest
scope that can accommodate the constant value. mikroPascal allows shortened version
of the syntax comprising of the const keyword followed by multiple constant declara-
tions. For example:

const
MAX : longint = 10000;
MIN = 1000; // compiler will assume word type
SWITCH = 'n'; // compiler will assume char type
MSG = 'Hello'; // compiler will assume string type
MONTHS : array[1..12] of byte =
(31,28,31,30,31,30,31,31,30,31,30,31);
 21

Labels
Labels serve as targets for jump statements. Mark a desired statement with a label like this:

label_identifier : statement

Every label must be declared before it is used. Similar to variables and constants, labels
are declared in the file and routine declaration sections. For the purpose of declaring a
label, the label keyword is used:

label label1, ..., labeln;

A signed label and jump statements referring to that label must belong to the same block,
i.e. no jump to or from the procedure or function can be executed. A label can be declared
only once within the block.

Functions and Procedures

Functions and procedures, together called routines, are subprograms which perform
certain tasks on the basis of a number of input parameters. Function returns a value after
execution, whereas procedure does not. mikroPascal does not support inline routines.

Functions
Functions are declared as follows:

function function_name(parameter_list) : return_type;

{ local declarations }
begin
{ function body }
end;

The function_name specifier represents a function name and can be any valid identifi-
er. The parameter_list specifier within parenthesis represents a list of formal parameters
declared similar to variable declaration. In order to pass a parameter by address to a
function, it is necessary to add the var keyword at the beginning of parameter declara-
tion. Local declarations are optional declarations of variables, constants and labels and
refer to the given function only. A function body represents a sequence of statements to
be executed upon calling the function.

The return_type specifier represents the type of a function return value which can be of
complex type. The example on the following page illustrates how to define and use a
function returning a complex type.
22

type TCircle = record // Record

CenterX, CenterY: word;
Radius: byte;
end;

var MyCircle: TCircle; // Global variable

// DefineCircle function returns a Record

function DefineCircle(x, y: word; r: byte): TCircle;

begin
result.CenterX := x;
result.CenterY := y;
result.Radius := r;
end;

begin
// Get a Record via function call
MyCircle := DefineCircle(100, 200, 30);

// Access a Record field via function call

MyCircle.CenterX := DefineCircle(100, 200, 30).CenterX + 20;
// |------------------------| |------|
// | |
// Function returns TCircle Access to one field of
TCircle

Calling function
A function is called by specifying its name followed by actual parameters placed in the
same order as their matching formal parameters. The compiler is able to make mis-
matching parameters to get appropriate type according to implicit conversion rules. If
there is a function call in an expression, the function return value will be used as an
operand in that expression. Here’s a simple function which calculates xn on the basis of
input parameters x and n (n > 0):
function power(x, n : byte) : longint;
var i : byte;
begin
i := 0; result := 1;
if n > 0 then
for i := 1 to n do result := result*x;
end;

By calling this function, it is possible to calculate, for example, 312:

tmp := power(3, 12);
 23

Procedures
Procedures are declared as follows:

procedure procedure_name(parameter_list);
{local declarations}
begin
{procedure body}
end;

The procedure_name specifier represents a procedure name and can be any valid iden-
tifier. The parameter_list specifier within parentheses represents a list of formal param-
eters which are declared similar to variables.

In order to pass a parameter by address to a procedure, it is necessary to add the var

keyword at the beginning of the parameter declaration. Local declarations are optional
declarations of variables, constants and labels and refer to the given procedure only. A
procedure body represents a sequence of statements to be executed upon calling the
procedure.

Calling procedure
A procedure is called by specifying its name followed by actual parameters placed in the
same order as their matching formal parameters.
24

Operators
Operators are tokens denoting operations to be performed upon operands in an expres-
sion. If the order of execution is not explicitly determined using parentheses, it will be
determined by the operator precedence. There are 4 precedence categories in
mikroPascal. Operators in the same category have equal precedence. Each category
has associativity rules, either left-to-right () or right-to-left (). In the absence of paren-
theses, these rules resolve grouping of expressions with operators of equal precedence.

Precedence Operands Operators Associativity

4 1 @ not + - ĸ
3 2 * / div mod and shl shr ĺ
2 2 + - or xor ĺ
1 2 = <> < > <= >= ĺ

Arithmetic Operators
Arithmetic operators are used for performing computing operations. Operands of char
type are bytes and can be used as unsigned operands in arithmetic operations therefore.
All arithmetic operators associate from left to right.

Operator Operation Operands Result

byte, short,
byte, short,
integer, word,
+ addition integer, word,
longint, dword,
longint, dword, real
real
byte, short,
byte, short,
integer, word,
- subtraction integer, word,
longint, dword,
longint, dword, real
real
byte, short, integer, word,
* multiplication integer, word, longint, dword,
dword, real real
byte, short, byte, short,
Division of floating-point
/ integer, word, integer, word,
objects
dword, real dword, real
Division and rounding byte, short, byte, short,
div down to the nearest integer, word, integer, word,
integer longint, dword, real longint, dword,
Modulus operator returns
byte, short, byte, short,
the remainder of integer
mod integer, longint, integer, longint,
division (cannot be used
word, dword word, dword
with floating-point objects)
 25

Division by Zero
If a zero (0) is used explicitly as the second operand in the division operation (x div 0),
the compiler will report an error and will not generate a code. In case of implicit division
where the second operand is an object the value of which is 0 (x div y, where y=0), the
result will be undefined.

Unary Arithmetic Operators

The ‘-’ operator can be used as a prefix unary operator to change the sign of an object.
The ‘+’ operator can also be used as unary arithmetic operator, but it doesn’t affect the
object. For example:
b := -a;

Relational Operators
Relational operators are used in logic operations. All relational operators return TRUE or
FALSE and associate from left to right.

Operator Operation
= equal
<> not equal
> greater than
< less than
>= greater than or equal
<= less than or equal

Relational Operators in Expressions

The precedence of arithmetic and relational operators enables complex expressions
without parentheses to generate expected results. For example:

a + 5 >= c - 1.0 / e // (a + 5) >= (c - (1.0 / e))

Bitwise Operators
Bitwise operators are used for modifying individual bits of an operand. Bitwise operators
associate from left to right. The only exception is the bitwise complement operator not
which associates from right to left.
26

Bitwise Operators Overview

Operator Operation
AND operator compares pairs of bits and generates 1 if both bits are
and
1, otherwise it generates 0.
OR operator compares pairs of bits and generates 1 if either or both
or
bits are 1, otherwise it generates 0.
XOR operator compares pairs of bits and generates 1 if the bits are
xor
complementary, otherwise it generates 0.
not Bitwise complement (unary) inverts each bit.
Shift left operator moves bits to the left, discards the leftmost bit and
shl
assigns 0 to the rightmost bit.
Shift right operator moves bits to the right and discards the
shr rightmost bit. If the object is unsigned, the leftmost bit is assigned 0.
Otherwise, it is assigned a bit sign.

Logical Bitwise Operations

Bitwise operators and, or and xor perform logical operations upon appropriate bit pairs
of their operands. The not operator complements each bit of an operand. For example:

$1234 and $5678 // equals $1230

{ because ..

$1234 : 0001 0010 0011 0100

$5678 : 0101 0110 0111 1000
----------------------------
and : 0001 0010 0011 0000 .. that is, $1230 }

Bitwise Shift Operators

There are two shift operators in mikroPascal. These are the shl operator which moves
bits to the left and the shr operator which moves bits to the right. Both operators have
two operands each. The left operand is an object to move, whereas the right operand is
a number of positions to move the object by. Both operands must be of integral type.
The right operand must be a positive value. By shifting an operand left (shl), the leftmost
bits are discarded, whereas ‘new’ bits on the right are assigned zeroes. Accordingly, shift-
n
ing unsigned operand to the left by n positions is equivalent to multiplying it with 2 if all
discarded bits are zeros. The same applies to signed operands if all discarded bits are
equal to the sign bit. By shifting operand right (shr), the rightmost bits are discarded,
whereas ‘new’ bits on the left are assigned zeroes (in case of unsigned operand) or the
sign bit (in case of signed operand). Shifting operand to the right by n positions is equiv-
alent to dividing it by 2n.
 27

Expressions
An expression is a sequence of operators, operands and punctuators that returns a
value. Primary expressions include literals, constants, variables and function calls. These
can be used for creating more complex expressions by means of operators. The way
operands and subexpressions are grouped does not necessarily represent the order in
which they are evaluated in mikroPascal.

Statements
Statements define operations within a program. Every statement needs to be terminated
by a semicolon ‘;’. In the absence of jump and selection statements, statements are exe-
cuted sequentially in the order of appearance in the program code.

Assignment Statements
Assignment statements look as follows:

var_name := some_expression;

The statement evaluates the expression and assigns its value to a variable. All implicit
conversion rules apply. The var_name specifier can be any declared variable, whereas
some_expression represents an expression the value of which matches the given vari-
able. Do not confuse the assignment operator ‘:=’ with relational operator ‘=’ used for
testing equality.

Compound Statements
A compound statement or a block is a set of statements enclosed within the begin and
end keywords:
begin
statements
end;

A block is considered to be a single statement, which enables it to be used when it is neces-

sary to write several statements where Pascal syntax requires a single statement. One block
can be defined within another block (block nesting). For example, in the place where while loop
expects one statement, we can write a compound statement:
while i < n do
begin
temp := a[i];
a[i] := b[i];
b[i] := temp;
n := n + 1;
end;

end.
In mikroPascal, the end. statement (the closing statement of every program) acts as an endless loop.
28

Conditional Statements
Conditional or selection statements make selection from alternative courses of program
execution by testing certain values.

If Statement
If statement is a conditional statement. The syntax of the if statement looks as follows:

if some_expression then statement1 [else statement2]

If some_expression is true, statement1 executes. Otherwise, statement2 executes.

The else keyword with an alternate statement (statement2) is optional. A semicolon ‘;’
shall never appear before the else reserved word.

Nested if statements
Nested if statements require additional attention. A general rule is that they are parsed
starting from the innermost if statement (the most nested) and each else statement is
bound to the nearest available if on its left:

if expression1 then
if expression2 then statement1
else statement2

The compiler interprets the block of statements given above as follows:

if expression1 then
begin
if expression2 then statement1
else statement2
end

To make the compiler to interpret the same block in another way, it is necessary to explic-
itly group the statements by means of begin-end blocks:

if expression1 then
begin
if expression2 then statement1
end
else statement2
 29

Case Statement
The case statement is a conditional statement of multiple branching. It consists of a con-
trol statement (selector) and a list of possible values of that expression. The syntax of the
case statement is:

case selector of
value_1 : statement_1
...
value_n : statement_n
[else default_statement]
end;

The selector specifier is a control statement evaluated as integral value. Specifiers

value1..value_n represent selector’s possible values and can be literals, constants or
expressions. Specifiers statement1..statement_n represent statements. The else
clause is optional. If the else branch is used, a semicolon ‘;’ shall never be placed before
the else keyword. First, the selector value is evaluated. It is then compared to all avail-
able values. If the value match is found, the appropriate statement will be executed, and
the case statement terminates. In the event that there are multiple matches, the first
matching statement will be executed. If none of the values matches the selector, then the
default_statement statement in the else clause (if there is one) is executed.
Here’s a simple example of the case statement:

case operator of
'*' : result := n1 * n2;
'/' : result := n1 / n2;
'+' : result := n1 + n2;
'-' : result := n1 - n2
else result := 0;
end;

Possible values of the control statement can also be grouped so that a few values refer
to a single statement. It is just necessary to name all the values and separate them by
commas:

case reg of
0: opmode := 0;
1,2,3,4: opmode := 1;
5,6,7: opmode := 2;
end;

Nested Case Statements

Case statements can also be defined within another case statements. As mentioned
before, the process is referred to as nesting.
30

Iteration Statements
Iteration statements enable a set of statements to be looped. Statements break and con-
tinue can be used for controlling the flow of loop execution. The break statement terminates
the loop in which it exists, while continue starts new iteration of the loop.

For Statement
The for statement implements an iterative loop when the number of iterations is speci-
fied. The syntax of the for statement is as follows:
for counter := initial_value to final_value do some_statement
// or
for counter := initial_value downto final_value do some_statement

The counter specifier is a variable which increments (or decrements if the downto option is used)
with each iteration of the loop. Before the first iteration, the counter is set to initial value
(initial_value) and will increment (or decrement) until it reaches the final value (final_value). The
given statement (some_statement) will be executed with each iteration. It can be any state-
ment which doesn’t change the value of the counter variable. The initial_value and final_value
should be expressions compatible with the counter variable, whereas the some_statement can
be any statement that does not change the counter value. Here is an example of calculating
scalar product of two vectors, a and b, of length n, using the for statement:
s := 0;
for i := 0 to (n-1) do s := s + a[i] * b[i];

Endless Loop
The for statement results in an endless loop if the final_value equals or exceeds the
range of the counter variable. Here is an example of an endless loop, as the counter
variable can never reach the value 300:
var counter : byte;
...
for counter := 0 to 300 do ...

Another way of creating an endless loop in mikroPascal is by means of the while statement.

While Statement
The while statement implements an iterative loop when the number of iterations is not
specified. It is necessary to check the iteration condition before loop execution. The syn-
tax of the while statement is as follows:
while some_expression do some_statement

The some_statement statement is executed repeatedly as long as the value of the

some_expression expression is true. The expression value is checked before the next
iteration is executed. Thus, if the expression value is false before entering the loop, no
iteration executes. Probably the easiest way of creating an endless loop is by using the
statement:
while TRUE do ...;
 31

Repeat Statement
The repeat statement implements an iterative loop when the number of iterations is not
specified. The statement is executed repeatedly until the expression evaluates true. The
syntax of the repeat statement is as follows:

repeat some_statement until some_expression

The some_statement statement is iterated until the some_expression expression

becomes true. The expression is evaluated after each iteration, so the loop will execute
the statement at least once. Here is an example of calculating scalar product of two vec-
tors, using the repeat statement:

s := 0; i := 0;
...
repeat
s := s + a[i] * b[i];
i := i + 1;
until i = n;

Jump Statements
mikroPascal supports the following jump statements: break, continue, exit and goto.

Break Statement
Sometimes it is necessary to stop the loop from within its body. The break statement
within loop is used to pass control to the first statement following the respective loop. For
example:

Lcd_Out(1, 1, "No card inserted");

// Wait for CF card to be plugged;
while TRUE do
begin
if Cf_Detect() = 1 then break;
Delay_ms(1000);
end;
// CF card cen be used now ...
Lcd_Out(1, 1, "Card detected ");

Continue Statement
The continue statement within the loop is used for starting new iteration of the loop.
Statements following the continue statement will not be executed.

// continue jumps here // continue jumps here

for i := ... do repeat
while condition do ...
begin begin
... continue;
... ...
continue; continue;
... //continue jumps here
... until condition;
end; end;
32

Exit Statement
The exit statement allows you to break out of a routine (function or procedure). It pass-
es the control to the first statement following the routine call.
Here is a simple example:

procedure Proc1();
var error: byte;
begin
...
if error = TRUE then exit;
... // some code which won't be executed if error is true
end;

Goto Statement
The goto statement is used for executing an unconditional jump to appropriate part of
the program. The syntax of the goto statement is:

goto label_name;

This statement executes a jump to the label_name label. The goto statement may occur
before or after the label declaration. The label declaration and goto statement must
belong to the same routine. Accordingly, it is not possible to jump into or out of a proce-
dure or function. The goto statement can be used for breaking out of any level of nest-
ed structures. It is not advisable to jump into a loop or other structured statement, as it
may give unexpected results. The use of the goto statement is generally discouraged as
practically every algorithm can be realized without it, resulting in legible structured pro-
grams. However, the goto statement is useful for breaking out of deeply nested control
structures:

for (...) do
begin
for (...) do
begin
...
if (disaster) then goto Error;
...
end;
end;
.
.
.
Error: // error handling code
 33

asm Statement
mikroPascal allows embedding assembly instruction in the program code by means of
the asm statement. Assembly instructions may be grouped together using the asm key-
word:
asm
block of assembly instructions
end;

mikroPascal comments are allowed in embedded assembly code. Besides, single-line

assembly comments may be written using a semicolon ‘;’ before the comment.
program test
var myvar : word;
begin
myvar := 0;
asm
MOVLW 10
MOVWF test_main_global_myvar_1
end;
end.

Directives
Directives are words of special significance which provide additional possibilities when
compiling and showing results.

Compiler Directives
mikroPascal treats comments starting with a ‘$’ sign immediately following an opening
brace as compiler directives. Such directives, among other things, enable the program
code to be conditionally compiled, i.e. it selects particular sections of the code to be com-
piled. All compiler directives must be completed within the file in which they have begun.

Directives $DEFINE and $UNDEFINE

The $DEFINE directive is used for defining a conditional compiler constant (flag). The
flag can be any valid identifier. Flags have separate name space so that no confusions
over program identifiers are possible. Only one flag per directive can be defined. For
example:

{$DEFINE Extended_format}

The $UNDEFINE directive is used for undefining (“clearing”) previously defined flag.
34

Directives $IFDEF..$ELSE
Conditional compilation is carried out using the $IFDEF directive. It tests whether a flag
is currently defined or not (using the $DEFINE directive). The $IFDEF directive is termi-
nated by the $ENDIF directive and may have an optional $ELSE clause:

{$IFDEF flag}
<block of code>
{$ELSE}
<alternate block of code>
{$ENDIF}

First, $IFDEF checks if the flag is defined or not. If so, only <block of code> will be com-
piled. Otherwise, <alternate block of code> will be compiled. $ENDIF ends the condi-
tional compilation sequence. The result of the preceding scenario is that only one sec-
tion of the code (possibly empty) will be compiled. This section may contain additional
(nested) conditional clauses. Each $IFDEF directive must be terminated with $ENDIF.
Here is an example:

// Uncomment the appropriate flag:

// {$DEFINE resolution10}
// {$DEFINE resolution12}

{$IFDEF resolution10}
// <code specific to 10-bit resolution>
{$ELSE}
{$IFDEF resolution12}
// <code specific to 12-bit resolution>
{$ELSE}
// <default code>
{$ENDIF}
{$ENDIF}

Directive $I
The $I directive is a compiler directive used for inserting given file into the program at the
place from where the directive was called. Here is an example:

{$I filename.txt}

Predefined Flags
mikroPascal has predefined flags which can be used for compiling program code for dif-
ferent hardware platforms.
 35

Linker Directives
mikroPascal uses internal algorithm for the purpose of distributing objects within memo-
ry. If it is necessary to have a variable or a routine at some specific predefined address,
linker directives absolute, org and orgall must be used.

Directive absolute
The absolute directive specifies the starting variable address in RAM. For multi-byte
variables, the higher bytes will be stored at adjacent, consecutive locations starting from
the given location. This directive is appended to variable declaration:

var x : byte; absolute $22;

// Variable x will occupy 1 byte at address $22

y : word; absolute $23;

// Variable y will occupy 2 bytes at addresses $23 and $24

Directive org
The org directive specifies the starting address of a routine in ROM. It is appended to
the routine declaration. For example:

procedure proc(par : byte); org $200;

begin
// Procedure will start at address $200
...
end;

Constant aggregates (records, arrays) can also be allocated at the specified address in
ROM by means of the org directive.

const ar : array[10] of char = {0,1,2,3,4,5,6,7,8,9}; org 0x400;

// const array will occupy 10 bytes at address 0x400

Directive orgall
The orgall directive is used for specifying the starting address of a routine in ROM from
where placing of all routines and constants starts. For example:

begin
orgall(0x200) // All routines and constants in the program will be
// stored above the 0x200 address, including origin routine as well.

...

end.
If you want to learn more about our products, please visit our website: www.mikroe.com

If you are experiencing some problems with any of our products or just need additional information, please place
your ticket at www.mikroe.com/en/support

If you have any question, comment or business proposal, do not hesitate to contact us: office@mikroe.com