Cross Ref > Language Basics

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

JavaScript is case sensitive. Change the case, and it no longer works! Notice the "W" in "Write" is capitalized.

<script language=JavaScript> 
<!--
document.Write("Hello"); //Does not work! 
//--> 
</script>

Variable names are case sensitive.

<script language=JavaScript> 
<!--
document.write("Hello"); 
//--> 
</script>

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

In html pages, you embed JavaScript code between <script> and </script> (see example). Also it's tradtional to put an HTML comment around your code too so that really old browsers don't crash (probably not all that important these days).

For JavaScript, Java, PHP, and C++, I prefer to put the first { at the end of the first line of the code block as in the example above because I see moreJavaScript codeformatted that way.

<script language="JavaScript" type="text/javascript">

<!--

function DisplayDialogLg(StrURL) {
}

if (x == -1) {

}

-->

</script>

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

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

Commenting Code
JavaScript uses "//" for a single line comment and /* */ for a multiple line comment.

//This is a single line comment.
 
/*
Multiple line
comment.

*/

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)  

Although JavaScript has variables, it does not have constants.

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")

In JavaScript, using a semicolon at the end of statements is optional. You might think a semicolon then is just another comment specifier but it is not. The semicolon is an optional end of statement specifier. To put two statements on a single code line, you must use a semicolon. However, the semicolon is optional, but probably confusing, when you break a single statement into multiple code lines.

document.write("Hello1");
document.write("Hello2");
 
//Semicolons are optional:
document.write("Hello3")
document.write("Hello4")
 
//This works too but only if you use a semicolon:
document.write("Hello5");  document.write("Hello6");
 
//Two lines also works:
document.write
  ("Hello7")

 JavaScript End of Statement (; is optional)

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

String literals use either an apostrophe (also known as a single quote) as in 'Prestwood' or quoted as in "Prestwood". If you need to embed an apostrophe in an apostrophe-literal or a quote in a quoted-literal, precede it with a slash as in \' and \".

Alert("Hello");

Alert("Hello \"Mike\".")

Alert('Hello');

Alert('Hello Mike\'s website.')

//Does JavaScript evaluate this simple

//floating point math correctly? No! 

if ((.1 + .1 + .1) == .3) {
 document.write("Correct")
} else {
 document.write("Not correct")
}

 JavaScript Literals (quote or apostrophe)

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)  

JavaScript is a loosely typed language. Each variable is cast in usage as string, number, boolean, function, or object.

Variable names are case sensitive.

Alternatively, you can specify the value when you declare a variable:

var FirstName = "Mike";

var LastName = "Prestwood";

var Age = 42;

var FirstName;

var LastName;

var Age;