Cross Ref > Language Basics

Object Pascal is generally not case sensitive.

Syntax Example:   Variables and commands are not case sensitive. var FullName: String; begin fullname := 'Mike Prestwood'; ShowMessage(fullNAME); SHOWMESSAGE(FULLNAME); showmessage(fullname); end;

 Camel versus Pascal Casing

ObjectPAL is not case sensitive. My preference for ObjectPAL is to follow the camel casing promoted in the examples and help files originally developed by Borland.

Syntax Example:   All of the following are equivalent: msgInfo "", "Hello" MsgInfo "", "Hello" msginfo "", "Hello" MSGINFO "", "Hello" Variables are not case sensitive. Var FullName String endVar fullname="Mike Prestwood" msgInfo("", fullNAME)

 Camel Casing

Object Pascal requires the semi-colon after the "declaration" part.

function DoSomething : integer;

var

  a, b : integer

begin

  a := 1;

  b := 2;

  result := a + b;

end;

ObjectPAL code blocks are surrounded by statement ending keywords that all use End with camel caps such as endMethod, endVar, endIf, endSwitch, and endTry.

method

endMethod

var

endVar

if

endIf

switch

endSwitch

try

endTry

Commenting Code
Delphi uses // for a single line comment and both {} and (**) for multiple line comments. Although you can nest different types of multiple line comments, it is recommended that you don't.

Compiler Directives - $
A special comment. Delphi compiler directives are in the form of {$DIRECTIVE}. Of interest for comments is using the $IFDEF compiler directive to remark out code.

//This is a single line comment.

 
{

Multiple line

comment.

}

 
(*
This too is a
multiple line comment.
*)

 
{$IFDEF TEMPOUT}
  //...code here
{$ENDIF}

 Delphi Comments (// or { ... } or (* ... *))  

Commenting Code
ObjectPAL uses ; for a single line comment and { } for a multiple line comment.

Syntax Example:   ;Single line comment. { Multiple line comment. }

In Delphi, you define constants similar to how you define variables but use the Const keyword instead of the Var keyword. Declare global constants in a unit's interface section and unit constants (scope limited to unit) in the implementation section. Declare local constants above the begin..end block.

Const 

  kFeetToMeter: Double = 3.2808;

  kMeterToFeet: Double = .3048;

  kName: String = "Mike";

//Local constants:

procedure SomeProcedure;

const

  kPI: Double=3.1459;

begin

end;

 Delphi Constants (Const kPI: Double=3.1459;)  

In ObjectPAL, you declare one or more constant values within a const..endConst block. Optionally, you can specify the dataType by casting the value as part of the declaration.

If you do not specify the data type, the data type is inferred from the value as either a LongInt, a Number, a SmallInt, or a String.

As with variables, the const..endConst block can come within a method or procedure as the first bit of code, or in the Const window. Putting it above the method or procedure is allowed but has no significance so don't.

const
  kFeetToMeter = Number(3.2808)
  kMeterToFeet = Number(.3048)
  kName = String("Mike")

  kCA = "California"     ;String inferred.
endConst

 ObjectPAL Constants (const..endConst)  

Object Pascal uses a semicolon ";" as an end of statement specifier and you can put multiple statements on a single line of code and put a single statement on two or more code lines if you wish.

Syntax Example:   WriteLn('Hello1'); WriteLn('Hello2'); WriteLn('Hello3'); //Same line works too: WriteLn('Hello4'); WriteLn('Hello5'); //Two or more lines works too: WriteLn ('Hello6');

ObjectPAL is a bit unique in that it doesn't use a semicolon nor a return to mark the end of a line, it uses whitespace which can be a return, space, or tab. This is a bit unusual but does allow for some nice formatting of code.

Syntax Example:   msgInfo("", "Hello1") msgInfo("", "Hello2") msgInfo("", "Hello3") ;The following single line of code also works. msgInfo("", "Hello4") msgInfo("", "Hello5") ;Two or more works too: msgInfo ("", "Hello6")

String literals are single quoted (the apostrophe) as in 'Prestwood'. If you need to embed an apostrophe use two apostrophes in a row.

Floating point literals must start with an integer. For example, to specify a fractional floating point literal between 1 and -1, you preceed the decimal with a 0; otherwise, you will get a compiler error.

//x := .1 + .1;   //Does not work.

x := 0.1 + 0.1;   //Does work.

Syntax Example:   ShowMessage('Hello'); ShowMessage('Hello Mike''s website.');

 Ref: https://forums.codegear.com/thread.jspa?threadID=8909&tstart=60

String literals are quoted as in "Prestwood". If you need to embed a quote use a slash in front of the quote as in \".

In ObjectPAL, string literals are limited to 255 characters but there's nothing preventing you from using multiple string literals together as in:

msgInfo("", "You can " + " add literals together in ObjectPAL") 

To specify a floating point literal between 1 and -1, you can preceed the decimal with a 0 or not (both work). In other words, preceding and following decimals are allowed (both .1 and 0.1). Trailing decimals are also allowed (1, 1., and 1.0 are all equivalent and allowed).

Syntax Example:   msgInfo("", "Hello") msgInfo("", "Hello \"Mike\".") ;Does ObjectPAL evaluate this simple ;floating point math correctly? No! If (.1 + .1 + .1) = .3 Then  msgInfo("", "Correct") Else  msgInfo("", "Not correct") EndIf

The Delphi language is a strongly typed language so you have to specifically declare variables and frequently use commands such as IntToStr and StrToInt.

Declare global variables in the interface section of a unit, variables declared within the implementation section (but not within a method) have a scope limited to the unit. You declare local variables in a var block outside (above) your begin..end code block. You cannot declare variables in-line (inside begin..end).

You can initialize global and unit variables but you cannot initialize local variables.

Delphi offers many variable types. Some common variable types include String, WideString, PChar, Integer, Boolean, Single, Double, Pointer, and Variant.

Note: D2009 introduced a new UnicodeString type.

procedure SomeProcedure;

var
  Fullname: String;
  Age: Integer;

  X, Y, Z: Double;

  MyArray: array [1..100] of Char;

begin

end;

//You can initialize global variables.

var

  ClickCounter: Integer = 0;

 Delphi Variables (var x: Integer = 0;)  

Declaring variables is optional unless you click Program | Compiler Warnings while in the ObjectPAL editor for every form, script, and library you create. Using Compiler Warnings is strongly recommended to avoid incorrectly typing an existing variable and to avoid any confusion about variable scope. Also recommended is turning on Compile with Debug for every form, script, and library too for tighter, cleaner code.

Undeclared variables are AnyType variables. Common data types include Currency, Date, Datetime, Logical, LongInt, Number, SmallInt, String, and Time.

var
    FullName String
    Age SmallInt
    Weight Number

endVar

FullName = "Mike Prestwood"
Age = 32
Weight =154.4

msgInfo("", FullName + ", age=" + String(Age) 

             + ", weight=" + String(Weight))

 ObjectPAL Variables (var x SmallInt endVar)