Langage

Overview

The line 1000 language is a managed language which inherits from object Pascal.

Main differences between Line 1000 and Object Pascal are list below :

• They is no supports to define types, classes and structures because this part must be managed in the Model.
• The memory is managed so there is no need to explicitly allocate or free memory.

Language features

Constants

There is no support at this time to declare constant inside a code block.

integer	10
hexadecimal	$0A
float	1.00
char	'A'
char	#10
string	'This is a string with a quote'

Block of code

A block of code has the fallowing structure :

declarations ;
begin
  instructions ;
end;

declarations may be variable, procedure or function declaration.

Variables MUST be explicitly declared using the fallowing syntax :

var 
  identifier : type;
  identifier, identifier : type;
  identifier : Array[0..X] of type;
  identifier : Array of type;

Like in Pascal language procedures and functions may be embedded inside a code block :

var
  p1,p2,p3 : type; 

  function name(p4:type):type;
  var p2:type;
  begin
    Result := p1+p4+p2;
  end;

begin
  ...
  p3 := name(p1,p2);
end;

Operators

Arithmetic

+	Addition
-	Subtraction
unary (-)	Negation
/	Division
*	Multiplication
div	Integer division
mod	Integer modulo

Logical

and	logical AND
or	logical OR
xor	logical XOR
not	Negation

Comparison

=	equal
<>	not equal
>	upper
>=	upper equal
<	lower
<=	lower equal

Expression

Expression are evaluate left to right, each term must be parenthesized :

  (a=b) and (c=d) ....

Expression evaluation are optimized :

  // term is not evaluate.
  false and term

  // term is not evaluate.
  true or term

Instructions

Statement

Statements are delimited by semi column ";"

  x := 1;
  y := 2;
  x := x+y;

Several statements may be combined in a single statement using begin / end :

  begin
    x := 1;
    y := 2;
    x := x+y;
  end;

Assignment

Assignment used the := operator :

  x := 1;

for

The for instruction allow implementation on index based loop :

  for index:=lower to upper do 
   statement ;

  for index:=upper downto lower do 
   statement ;

The index variable MUST BE an integer variable.

while

The while instruction allow implementation on expression based loop :

 while (expression) do
   statement ;

repeat

The repeat instruction allow implementation on expression based loop :

 repeat
   statement ;
 until (expression)

Unlike while construction the repeat statement will be executed at least one time.

foreach

The foreach instruction allow iterations inside a collection :

  foreach V in C do 
   statement ;

C MUST be a collection V MUST be a variable of the collection type

break

The break instruction allow exiting a loop, it can be used in any loop construction.

  for index:=lower to upper do 
   begin
     ....
     if expression then break;
   end;

The effect of the break instruction is to exit the loop.

Break instruction could be used inside for, while, repeat, foreach loop instructions.

continue

The continue instruction allow resuming a loop, it can be used in any loop construction.

  for index:=lower to upper do 
   begin
     if expression then continue;
     ....
   end;

The effect of the continue instruction is to branch at start of the loop.

Continue instruction could be used inside for, while, repeat, foreach loop instructions.

if

The if instruction allow implementation of test and branch :

  if expression then statement ; 

  if expression then statement else statement ; 

case

The case instruction is not supported at this time.

Exception support

Exception may be rise easer by managed code or by runtime and framework code. In both case the exception may be trap and managed using the try / finally / except construction.

Rising an exception

The rise instruction allow rising an exception :

  rise ERule.Create('some message here');

The exception type MUST be of the fallowing class :

• ERule

Try / finally block

The Try/finally block construction may trap an exception to ensure execution of an exit code :

 try
   statement 1;
 finally
   statement 2;
 end;
 statement 3 ;

if an exception occurs in statement 1 the execution flow will branch in statement 2 and then exit from main block; the statement 3 is not executed.

Try / except block

The Try/finally block construction may trap an exception to manage the exception :

 try
   statement 1;
 except
   statement 2;
 end;
 statement 3;

if an exception occurs in statement 1 the execution flow will branch in statement 2 and then continue in statement 3.

The exception message may be catch and used in the exception block :

 try
   statement 1;
 except
   on E:Exception do 
    begin
      ... do something with E.Message ....
      statement 2;
    end;
 end;
 statement 3;

Inside an exception block the exception may be re-trigger :

 try
   statement 1;
 except
   statement 2;
   raise ;
 end;
 statement 3;

if an exception occurs in statement 1 the execution flow will branch in statement 2 and the exception will be re-rise; the statement 3 is not executed.