[comp.lang.pascal] returning records

eli@smectos.gang.umass.edu (Eli Brandt) (07/27/90)

In article <15365@thorin.cs.unc.edu> hardarso@arras.cs.unc.edu (Kari Hardarson) writes:
>I have two questions about TP. Is there a good reason why a function
>in TP cannot return a record? Also: is there any way to implement
    (deleted; I can't answer that one)

Well, you don't want to pass records on the stack, but there should be a way to
return pointers to them with having to explicitly reference and dereference them.
One way around this is to return a string of the proper size and then typecast it:

type
  complex = record a, b: real  end;
  cstr = string[11];  { you get element 0, too }

function cAdd(x, y: complex): cstr;
var sum: complex;
begin
  with sum do
  begin
    a := x.a+y.a;
    b := x.b+y.b;
  end;
  cAdd := cstr(sum);
end;

const
  c1: complex = (a:1; b:1);   { sorry, don't remember the format }
  c2: complex = (a:-3; b:2);

var
  c3: complex;

begin
  c3 := complex(cAdd(c1, c2));
end.


Consider this more pseudocode than actual TP code.  I'm just entering this from
memory, but I have used this trick.  I ran it through cpp first to convert cAdd to complex(cAdd) to simplify the syntax.

nmouawad@water.waterloo.edu (Naji Mouawad) (07/30/90)

>>In article <15365@thorin.cs.unc.edu> hardarso@arras.cs.unc.edu (Kari
Hardarson) writes:

>>I have two questions about TP. Is there a good reason why a function
>>in TP cannot return a record? Also: is there any way to implement

>In article <17556@dime.cs.umass.edu> eli@smectos.CS.UMASS.EDU (Eli Brandt)
>writes:

>Well, you don't want to pass records on the stack, but there should be a way to
>return pointers to them with having to explicitly reference and dereference them.
>One way around this is to return a string of the proper size and then typecast it:
>
>type
>  complex = record a, b: real  end;
>  cstr = string[11];  { you get element 0, too }
>
>function cAdd(x, y: complex): cstr;
>var sum: complex;
>begin
>  with sum do
>  begin
>    a := x.a+y.a;
>    b := x.b+y.b;
>  end;
>  cAdd := cstr(sum);
>end;
>
>const
>  c1: complex = (a:1; b:1);   { sorry, don't remember the format }
>  c2: complex = (a:-3; b:2);
>
>var
>  c3: complex;
>
>begin
>  c3 := complex(cAdd(c1, c2));
>end.
>
>
>Consider this more pseudocode than actual TP code.  I'm just entering this from
>memory, but I have used this trick.  I ran it through cpp first to convert cAdd to complex(cAdd) to simplify the syntax.

Note: This trick will work fine if the size of the record (retured by the
SizeOf function) does not exceed the size of a string (255 bytes).

In Tp 5.0, 5.5 (maybe 4.0, I duno) there is a way of doing this with
not much hassel, using the @ function.
Recall that the @ function returns the adress of a variable. It is a
pointer in disguise.
So Let us assume that you have a record variable recA of type Rec_type.
Declare the function 

function f(possible parameters) : pointer;
Var recA : Rec_type;
begin
            .
            .
            .
         f := @recA;
end;
On the receiving end, assume another variable recB : Rec_type;
simply say : @RecB := f;

This method has one more advantage and a drawback: You can assign
to a varaible a variable of another type (RecB could have been an array)
as long as you know what you are doing. The drawback is that it does not
allow you to pass records by value, but then, this is not very recommended.

-- 
         ---------------+-------------------------------------------
        | Naji Mouawad  |       nmouawad@water.uwaterloo.edu        |
        |  University   |-------------------------------------------|
        | Of Waterloo   | "Thanks God, we cannot prove He Exists."  |