From: arne@vajhoej.dk   
      
   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    
   #include    
      
   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   
      
   --- SoupGate-DOS v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)