The Const keyword

Smart pascal source code


// ######## CASE I ########################
const ONE = 1;
const TWO = ONE + ONE;
const MINUS_ONE = -ONE;

procedure WriteLnOut(Value: Integer = MINUS_ONE);
begin
  Writeln(IntToStr(Value));
end;

WriteLnOut();
WriteLnOut(TWO + MINUS_ONE - ONE);
WriteLnOut(ONE);
WriteLnOut(TWO);
WriteLnOut($100);
{ <<<<<<<<<<<< CONSOLE OUTPUTS >>>>>>>>>>>>>>>>>>>
  -1
  0
  1
  2
  256
}

// ######## CASE II ########################
const X = 1024;
const Y = Round(X / 5);
const Z = Trunc(X / 5);

  Writeln(IntToStr(Y));
  Writeln(IntToStr(Z));
{ <<<<<<<<<<<< CONSOLE OUTPUTS >>>>>>>>>>>>>>>>>>>
  205
  204
}

// ######## CASE III ########################
// EMPTY ARRAY ----> VAR X CONST <-----

//var ARR := [];
Const ARR = [];
var i := 0;
try
   WriteLn(ARR[i]);
except
   on E: Exception do
      WriteLn(E.Message);
end;

// ######## CASE IV ########################
// -----> CONST BLOCK <-------
procedure Stuff1;
const
   a = 1;
   b = 2;
var
   c : Integer;
   d : Integer;
begin
   c:=d;
end;

procedure Stuff2;
var
   c : Integer;
   d : Integer;
const
   a = 1;
   b = 2;
begin
   c:=d;
end;

procedure Stuff3;
var
   c : Integer;
   d : Integer;
begin
   c:=d;
end;

procedure Stuff4;
const
   a = 1;
   b = 2;
begin
end;


// ######## CASE V ########################
// -----> CONST IN PARAMETERS <-------
procedure Test(const i : Integer);
begin
   WriteLn(i);
end;

Test(1);
Test(1+2);

var j = 10;
Test(j+1);
Test(2*j);
Test(Round(j*PI));

{ <<<<<<<<<<<< CONSOLE OUTPUTS >>>>>>>>>>>>>>>>>>>
  1
  3
  11
  20
  31
}

// ######## CASE VI ########################
// -----> CONST IN PARAMETERS II <-------

type
TRec = record
  Field: Integer;
end;

function Func1(const r: TRec): Integer;
begin
  Result := r.Field;
end;

function Func2(const r: TRec): TRec;
begin
  Result.Field := r.Field + 1;
end;

var
  r: TRec;
  Writeln(Func1(r));
  Writeln(Func1(Func2(r)));
  r := Func2(r);
  Writeln(Func1(r));
  Writeln(Func1(Func2(r)));

{ <<<<<<<<<<<< CONSOLE OUTPUTS >>>>>>>>>>>>>>>>>>>
  0
  1
  1
  2
}

// ######## CASE VII ########################
// --- CONST with RECORD TYPE --
type
TRec1 = record
  w, x, y: Integer;
  z: Float;
  Name: string;
end;

const
  c: TRec1 = (x: 1; y: 2; z: 3.1; Name: 'hello');

  Writeln(c.w);
  Writeln(c.x);
  Writeln(c.y);
  Writeln(c.z);
  Writeln(c.Name);

{ <<<<<<<<<<<< CONSOLE OUTPUTS >>>>>>>>>>>>>>>>>>>
  0
  1
  2
  3.1
  hello
}

var i = 0,
j = 0,
r = {
	Field : 0
};
function WriteLnOut(Value) {
	WriteLn(Value.toString());
};
/// TRec1 = record
///  [line: 227, column: 1, file: uMain]
function Copy$TRec1(s, d) {
	d.w = s.w;
	d.x$1 = s.x$1;
	d.y = s.y;
	d.z = s.z;
	d.Name$3 = s.Name$3;
	return d;
}
function Clone$TRec1($) {
	return {
		w : $.w,
		x$1 : $.x$1,
		y : $.y,
		z : $.z,
		Name$3 : $.Name$3
	}
}
/// TRec = record
///  [line: 195, column: 1, file: uMain]
function Copy$TRec(s, d) {
	d.Field = s.Field;
	return d;
}
function Clone$TRec($) {
	return {
		Field : $.Field
	}
}
function Test(i$1) {
	WriteLn(i$1);
};
function Func2(r$1) {
	var Result = {
		Field : 0
	};
	Result.Field = r$1.Field + 1;
	return Result
};
function Func1(r$2) {
	return r$2.Field;
};
var ARR = [];
WriteLnOut(-1);
WriteLnOut(0);
WriteLnOut(1);
WriteLnOut(2);
WriteLnOut(256);
WriteLn("205");
WriteLn("204");
i = 0;
try {
	WriteLn(ARR[i]);
} catch ($e) {
	var E = $W($e);
	WriteLn(E.FMessage)
}
Test(1);
Test(3);
j = 10;
Test((j + 1));
Test((j * 2));
Test(Math.round(j * 3.14159265358979));
WriteLn(Func1(r));
WriteLn(Func1(Func2(r)));
r = Func2(r);
WriteLn(Func1(r));
WriteLn(Func1(Func2(r)));
WriteLn({
	w : 0,
	x$1 : 1,
	y : 2,
	z : 3.1,
	Name$3 : "hello"
}
	.w);
WriteLn({
	w : 0,
	x$1 : 1,
	y : 2,
	z : 3.1,
	Name$3 : "hello"
}
	.x$1);
WriteLn({
	w : 0,
	x$1 : 1,
	y : 2,
	z : 3.1,
	Name$3 : "hello"
}
	.y);
WriteLn({
	w : 0,
	x$1 : 1,
	y : 2,
	z : 3.1,
	Name$3 : "hello"
}
	.z);
WriteLn({
	w : 0,
	x$1 : 1,
	y : 2,
	z : 3.1,
	Name$3 : "hello"
}
	.Name$3);