[Info-vax] basic BASIC question

[Arne Vajhøj]

On 1/31/2025 8:39 PM, Arne Vajhøj wrote:
> Regarding the test:

> Basic   : TRUE  TRUE  FALSE TRUE  TRUE
> Fortran : F     T     F     T     F
> C       : TRUE  TRUE  FALSE TRUE  TRUE
> Pascal  : F     T     F     T     F

Improved version:
* more values
* also pass individual values instead of array
* dump addresses for verification
* also try C bool for individual values (we are
   past 1999)

$ type m.pas
program m(input,output);

type
    ia9 = array [1..9] of integer;

[external]
procedure b1(%ref v : ia9); external;

[external]
procedure b2(%ref v1, v2, v3, v4, v5, v6, v7, v8, v9 : integer); external;

var
    v : ia9;
    i : integer;

begin
    v[1] := -257;
    v[2] := -256;
    v[3] := -2;
    v[4] := -1;
    v[5] := 0;
    v[6] := 1;
    v[7] := 2;
    v[8] := 256;
    v[9] := 257;
    write('                      ');
    for i := 1 to 9 do begin
       write(v[i]:4, '  ');
    end;
    writeln;
    b1(v);
    b2(v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8], v[9]);
end.
$ type b.bas
sub b1(integer v() by ref)
     external string function s(integer)
     external sub f1(integer dim() by ref)
     print using "Basic (array arg)   : 'E 'E 'E 'E 'E 'E 'E 'E 'E 
(##########-##########)", &
                 s(v(0)), s(v(1)), s(v(2)), &
                 s(v(3)), s(v(4)), s(v(5)), &
                 s(v(6)), s(v(7)), s(v(8)), &
                 loc(v(0)), loc(v(8))
     call f1(v())
end sub
!
sub b2(integer v1 by ref, integer v2 by ref, integer v3 by ref, &
        integer v4 by ref, integer v5 by ref, integer v6 by ref, &
        integer v7 by ref, integer v8 by ref, integer v9 by ref)
     external string function s(integer)
     external sub f2(integer by ref, integer by ref, integer by ref, &
                     integer by ref, integer by ref, integer by ref, &
                     integer by ref, integer by ref, integer by ref)
     print using "Basic (multi arg)   : 'E 'E 'E 'E 'E 'E 'E 'E 'E 
(##########-##########)", &
                 s(v1), s(v2), s(v3), &
                 s(v4), s(v5), s(v6), &
                 s(v7), s(v8), s(v9), &
                 loc(v1), loc(v9)
     call f2(v1, v2, v3, v4, v5, v6, v7, v8, v9)
end sub
!
function string s(integer v1)
     if v1 then
         s = "TRUE "
     else
         s = "FALSE"
     end if
end function
$ type f.for
       subroutine f1(v)
       logical*4 v(9)
       integer*4 i
       write(*,'(1x,a,9(l,4x),1x,1h(,i10,1h-,i10,1h))')
      +        'Fortran (array arg) :',
      +        (v(i),i=1,9),
      +        loc(v(1)),loc(v(9))
       call c1(v)
       end
c
       subroutine f2(v1,v2,v3,v4,v5,v6,v7,v8,v9)
       logical*4 v1,v2,v3,v4,v5,v6,v7,v8,v9
       write(*,'(1x,a,9(l,4x),1x,1h(,i10,1h-,i10,1h))')
      +        'Fortran (multi arg) :',
      +        v1,v2,v3,v4,v5,v6,v7,v8,v9,
      +        loc(v1),loc(v9)
       call c2a(v1,v2,v3,v4,v5,v6,v7,v8,v9)
       call c2b(v1,v2,v3,v4,v5,v6,v7,v8,v9)
       end
$ type c.c
#include <stdio.h>
#include <stdbool.h>

void p1(int *v);
void p2(int *v1, int *v2, int *v3, int *v4, int *v5, int *v6, int *v7, 
int *v8, int *v9);

#define PTF(v) if(v) printf(" TRUE "); else printf(" FALSE");

void c1(int *v)
{
     printf("C (array arg, int)  :");
     for(int i = 0; i < 9; i++)
     {
         PTF(v[i])
     }
     printf(" (%d-%d)\n", (int)&v[0], (int)&v[8]);
     p1(v);
}

void c2a(int *v1, int *v2, int *v3, int *v4, int *v5, int *v6, int *v7, 
int *v8, int *v9)
{
     printf("C (multi arg, int)  :");
     PTF(*v1)
     PTF(*v2)
     PTF(*v3)
     PTF(*v4)
     PTF(*v5)
     PTF(*v6)
     PTF(*v7)
     PTF(*v8)
     PTF(*v9)
     printf(" (%d-%d)\n", (int)v1, (int)v9);
     p2(v1, v2, v3, v4, v5, v6, v7, v8, v9);
}

void c2b(bool *v1, bool *v2, bool *v3, bool *v4, bool *v5, bool *v6, 
bool *v7, bool *v8, bool *v9)
{
     printf("C (multi arg, bool) :");
     PTF(*v1)
     PTF(*v2)
     PTF(*v3)
     PTF(*v4)
     PTF(*v5)
     PTF(*v6)
     PTF(*v7)
     PTF(*v8)
     PTF(*v9)
     printf(" (%d-%d)\n", (int)v1, (int)v9);
}

$ type p.pas
module p(input, output);

type
    ba9 = array [1..9] of boolean;

[global]
procedure p1(var v : ba9);

begin
    writeln('Pascal (array arg)  : ', v[1]:1, '     ', v[2]:1, '     ', 
v[3]:1, '     ',
                                      v[4]:1, '     ', v[5]:1, '     ', 
v[6]:1, '     ',
                                      v[7]:1, '     ', v[8]:1, '     ', 
v[9]:1,
                                      '     (', iaddress(v[1]):1, '-', 
iaddress(v[9]):1, ')');
end;

[global]
procedure p2(var v1, v2, v3, v4, v5, v6, v7, v8, v9 : boolean);

begin
    writeln('Pascal (multi arg)  : ', v1:1, '     ', v2:1, '     ', 
v3:1, '     ',
                                      v4:1, '     ', v5:1, '     ', 
v6:1, '     ',
                                      v7:1, '     ', v8:1, '     ', v9:1,
                                      '     (', iaddress(v1):1, '-', 
iaddress(v9):1, ')');
end;

end.
$ pas m
$ bas b
$ for f
$ cc c
$ pas p
$ link m + b + f + c + p
$ run m
                       -257  -256    -2    -1     0     1     2   256   257
Basic (array arg)   : TRUE  TRUE  TRUE  TRUE  FALSE TRUE  TRUE  TRUE 
TRUE  (2060040448 2060040480)
Fortran (array arg) : T     F     F     T     F     T     F     F     T 
    (2060040448-2060040480)
C (array arg, int)  : TRUE  TRUE  TRUE  TRUE  FALSE TRUE  TRUE  TRUE 
TRUE  (2060040448-2060040480)
Pascal (array arg)  : T     F     F     T     F     T     F     F     T 
    (2060040448-2060040480)
Basic (multi arg)   : TRUE  TRUE  TRUE  TRUE  FALSE TRUE  TRUE  TRUE 
TRUE  (2060040448 2060040480)
Fortran (multi arg) : T     F     F     T     F     T     F     F     T 
    (2060040448-2060040480)
C (multi arg, int)  : TRUE  TRUE  TRUE  TRUE  FALSE TRUE  TRUE  TRUE 
TRUE  (2060040448-2060040480)
Pascal (multi arg)  : T     F     F     T     F     T     F     F     T 
    (2060040448-2060040480)
C (multi arg, bool) : TRUE  FALSE TRUE  TRUE  FALSE TRUE  TRUE  FALSE 
TRUE  (2060040448-2060040480)

(in case someone wonder about C bool, then it is 8 bit!)

Arne