[fpc-pascal] Declaring an array as var or not in function calls?

[Bo Berglund]

I am wondering how to deal with this var or not in function calls:

In a processing program where I am building the command arguments for a write
operation by analyzing incoming commands and splitting the data such that the
write can be fully done by executing a series of smaller write commands for
chunks of data.

The container for this is a dynamic array of write commands and this array is
part of the arguments for the build function.

Like this (simplified): 

type
  TWriteBytesArgs = record 
    DeviceAddr: byte;
    StartAddr: uint16;
    SourceAddr: uint16;
    NumWriteBytes: uint16;
    NextSourceAddr: uint16;
  end;

  TWriteCommands = array of TWriteBytesArgs;


function BuildArgumentsArray(Arg: TWriteBytesArgs; var WArgs: TWriteCommands):
boolean;
var
  variables...
begin
  stuff...
  (Build arguments into WArgs)
end;

procedure main();
var
  WCmd: TWriteBytesArgs;
  WCmds: TWriteCommands;
  Data: TBytes; //Container for actual data
  i: integer;
begin
  ...
  - Fill Data array with values to write
  - Set values to WCmd record members
  if BuildArgumentsArray(WCmd, WCmds) then
  begin
    for i := 0 to Length(WCmds) -1 do
      WriteItem(WCmd[i].DeviceAddr, WCmds[i].StartAddr, 
                WCmd[i].SourceAddr, WCmds[i]NumWriteBytes, Data);
    etc...

In main() the Arg record is analyzed by a call to BuildArgumentsArray and based
on that one or several actual smaller write commands will be generated. These
are written to the WArgs array.

So the WArgs dyn array is originally length zero, but inside the
BuildArgumentsArray function its length will be set to contain the needed write
commands to do the complete write.
And the caller can iterate over the array items and generate a write command for
each.

Now my question:
----------------
Since I am modifying the WArgs variable inside the BuildArgumentsArray function
and using its new content afterwards in the WriteItem function I assumed that I
had to use var as shown above, but I am not certain this is the case...

It seems like it works also if I do not use the vars specification...

What is the deal here, is this kind of variable written to inside a called
function not needing to be set as var and it will work anyway?

And if so, what is the rule for *when* to use var in function call argument
lists for items that will be changed inside the called function and used
afterwards?


-- 
Bo Berglund
Developer in Sweden