I am just starting to learn pascal and I was wondering if someone could
explain how parameter passing works, in plain english terms.

Your help would be much appreciated.

procedure Ref_Param (var X : integer);
procedure Val_Param (X : integer);

In article <MPG.f51efa7e2b90dd0989...@news.primenet.com>,

To illustrate the difference in simple parameters, lets have some code:

procedure Value(x:word);
begin
  x:=1;
End;

procedure Variable(x:word);
begin
  x:=1;
End;

var z:word;

begin
  value(z);
  variable(z);
End.

Now lets see the code that is produced:

Lets first view the calls:

PROGRAM.14:  value(z);
  cs:0023 FF365000       push   word ptr [PROGRAM.Z]
  cs:0027 E8D6FF         call   PROGRAM.VALUE
PROGRAM.15:  variable(z);
  cs:002A BF5000         mov    di,0050
  cs:002D 1E             push   ds
  cs:002E 57             push   di
  cs:002F E8DAFF         call   PROGRAM.VARIABLE

See, how in case of value parameter the actual value of the variable is
pushed on the stack. In case of variable parameter the address (DS:50h)
of the variable is pushed.

Now lets see the actual code:

First for the value version:

PROGRAM.VALUE: begin
  cs:000C 55             push   bp
  cs:0001 89E5           mov    bp,sp
PROGRAM.3:  x:=1;
  cs:0003 C746040100     mov    word ptr [bp+04],0001
PROGRAM.4: End;
  cs:0008 C9             leave
  cs:0009 C20200         ret    0002

See, how this only modifies the parameter on the stack. The ret removes
that parameter so there is no permanent effect.

Then the variable parameter version:

PROGRAM.VARIABLE: begin
  cs:000C 55             push   bp
  cs:000D 89E5           mov    bp,sp
PROGRAM.8:  x:=1;
  cs:000F C47E04         les    di,[bp+04]
  cs:0012 26C7050100     mov    es:word ptr [di],0001
PROGRAM.9: End;
  cs:0017 C9             leave
  cs:0018 C20400         ret    0004

Notice how this uses les to load the address to the actual parameter in
es:di and then uses that to modify the actual variable.

Variable parameters are called that as the actual parameter has to be a
variable. One cannot pass a constant (excluding typed constant) to it.
For example variable(2) would be illegal but value(2) would be perfectly
legal. This causes some problems as with string constants one would like
the efficient pass by reference method. Also in case of arrays (which
have to be variables) one might want protection against accidental
change and yet the pass by reference. For this reason newer versions of
TP have also constant parameters (const). They are constants (within the
procedure) and thus protected against change. So you can pass either a
constant or a variable. Also the compiler is free to choose optimal
method of passing (value for simple parameters and reference for complex
ones)

JRS:  In article <MPG.f51efa7e2b90dd0989...@news.primenet.com> of Mon,
16 Feb 1998 06:41:01 in comp.lang.pascal.borland, Mike Copeland

var j, k : byte ;
procedure x(var x : byte ; y : byte) ;
begin end ;
BEGIN
x(j, k) ;
end.

PROGRAM.5: x(j, k) ;
  cs:001D BF5000         mov    di,0050
  cs:0020 1E             push   ds
  cs:0021 57             push   di
  cs:0022 A05100         mov    al,[0051]
  cs:0025 50             push   ax
  cs:0026 E8D7FF         call   PROGRAM.X

The address of x, and the value of y, are pushed.

In article <MPG.f52dcdbe7038dd4989...@news.primenet.com>,

No. Trying to make value parameters look like reference parameters or
pointers only confuses the issue. They are different concepts.

Conceptually, when you have a value parameter, only the value is
passed. It becomes in effect a local variable of the subprogram,
initialised with the value being passed. The subprogram may modify
this local copy of the value without affecting the calling program,
exactly as is the case with other local variables. The calling program
may have an expression for a value parameter precisely because the
address is _not_ required.

For example,

function total(x:integer):integer;
  { x is a value parameter.
    Returns x + (x-1) + (x-2) + ... + 1
  }
Var
  Result : Integer;
Begin
  Result := 0;
  While (x>0) do
  Begin
    Result := Result+x;
    x := x-1;
      { the value parameter may be changed like any other local
        variable
      }
  End;
  total := Result;
End;

Begin
  Writeln(total(3+4));
    { An expression may be used for a value parameter
    }
End.

As an _implementation_ issue, BP7 has const parameters, which are
value parameters which the subprogram does not change the value of.
Conceptually they are the same as value parameters, assuming that we
do not wish to change the value of the parameter:

function total(const x:integer):integer;
  { x is still a value parameter, but one the programmer doesn't
    want to change.
    Returns x + (x-1) + (x-2) + ... + 1
  }
Var
  Result : Integer;
  i : Integer;
Begin
  Result := 0;
  For i := 1 to x do
    Result := Result+i;
  total := Result;
End;

Begin
  Writeln(total(3+4));
    { An expression may be used for a const parameter
    }
End.

However, since the programmer promises to the compiler that the value
of x will not change, the compiler may use a pointer if the type of
the parameter takes more than a few bytes of memory, for example if
the parameter is a string. Normally a value parameter is implemented
by putting it where local variables are put: on the stack (because for
the subprogram, it IS a local variable). If it would take a lot of
stack, putting the address of the data may be more efficient in some
cases. The differences are important, but not when learning what
parameters are. The compiler handles these differences. Conceptually
the value is passed, NOT a pointer.

On the other hand, reference parameters (also called Var parameters)
COULD be regarded as similar to pointers, if that helps you understand
them. (If not, forget the word "pointer" for now.)

A reference is a variable that occupies the same memory as another
variable of the same type. So the subprogram is told what the address
of the variable in the calling program is; within the subprogram you
can use the reference parameter as a normal variable but the important
thing is that you are dealing with a variable owned by the caller. The
compiler handles this for you: you just use the parameter as a
variable. But it's the caller's variable. So if you change the value,
the caller's variable is changed. This is useful if you want to pass
data back to the caller:

Procedure total(var x:integer);
  { Sets x to the total x + (x-1) + (x-2) + ... + 1
  }
Var
  Result : Integer;
  i : Integer;
Begin
  Result := 0;
  For i := 1 to x do
    Result := Result+i;
  x := Result;
    { This doesn't just change a local variable. x is a reference to
      whatever variable the caller said to use.
    }
End;

Var
  n : Integer;
Begin
  { An expression may NOT be used for a var parameter. So it has
    to be evaluated and put in a variable.
  }
  n := 3+4;
  total(n); { need a variable! Result gets put in n }
  Writeln(n);
End.

In this simple example, x is just an integer and total could be a
function. But sometimes you want to pass two separate values back, or
your compiler may not let you return values of the type that you want
(if it's a record, say). Then a var parameter is the way to go. If you
don't want to pass data back to the caller, use value parameters.

In article <6ccj80$b5...@news.indigo.ie>,

type Tarr=array[1..4] of byte;

var arr:Tarr;

Procedure xx(const a:tarr);
begin
  arr[1]:=1;
  writeln(a[1]);
End;

begin
  arr[1]:=2;
  xx(arr);
End.

The above code outputs 2 but it one changes the array size to 5 it
outputs 1. This is because array of 4 bytes is passed as value but array
of 5 bytes as reference. Directly modifying a variable used as actual
parameter is very ugly even in Pascal. In ADA or in TP with CONST it is
asking trouble plain and simple.

The const parameters are simply of completely different philosophy than
value or var.

Guess I should have learned ADA.

One introduction to ISO standard Pascal said "A parameter may be
declared to be protected; the code within the procedure or function
must then not contain statements which might change the parameter."
and goes on to mention protected var and protected value parameters. I
assumed const was the same as that except that the compiler makes the
decision about whether the parameter should be protected var or
protected value. So I was inclined to consider them one or the other,
I chose to consider them protected value parameters because you can
pass an expression. So, to the caller at least, they are the same as
value parameters (assuming you are considering the source code and not
using ugly tricks).

I wonder what the original poster wanted - an explanation of what
parameters are and how they should be used or a low-level explanation
of what bytes go where? I was assuming the former.

In article <6ch5db$4e...@news.indigo.ie>,

...