Re: [Spark] Arrays of Strings

[Lutz Donnerhacke <lutz@iks-jena.de>]

* Martin Krischik wrote:
> On Tue, 08 Apr 2003 12:02:09 +0000, Lutz Donnerhacke wrote:
>> In order to implement thin an execve binding, I wonder how to emulate the
>> C-Type "char const * const x []". Any bright ideas?
>
> Depends if you need a 1 to 1 emulation or you want a more high level OO
> aproach.

The emulation should be native Spark and to be used in an inlined syscall.
The syscall interface is so thin, that the inlined code prepare the
registers and switch directly to the kernel.

Example:
pragma No_Run_Time;

with Kernel.Processes, Kernel.IO, Kernel.Linux_i86, Addon;
use type Kernel.IO.long;
--# inherit Kernel, Kernel.Processes, Kernel.IO;

--# main_program;
procedure test_kernel
  --# global in out Kernel.State;
  --# derives Kernel.State from Kernel.State;
  is
   pragma Suppress(All_Checks);

   subtype Buffer_Index is Positive range 1 .. 10;
   subtype Buffer is String(Buffer_Index);
   outbuf : Buffer;
   outlast : Natural;
   outwritten : Natural;
   exitcode : Kernel.Processes.exit_code_t;
   
   child : Kernel.Processes.child_data_t;
   res : Kernel.Linux_i86.syscall_result;
begin
   Kernel.Processes.fork(child, res);
   if res.ok then
      if child.child then
	 outbuf := Buffer'(
	   1 => 'C', 2 => 'h', 3 => 'i', 4 => 'l', 5 => 'd',
	   others => ' ');
	 outlast := 5;
      else
	 outbuf := Buffer'(
	   1 => 'M', 2 => 'a', 3 => 's', 4 => 't', 5 => 'e', 6 => 'r',
	   others => ' ');
	 outlast := 6;
      end if;
   else
      outbuf := Buffer'(
	1 => 'E', 2 => 'r', 3 => 'r', 4 => 'o', 5 => 'r',
	others => ' ');
      outlast := 5;
   end if;
   
   outlast := outlast + 1;
   outbuf(outlast) := ASCII.LF;

   Kernel.IO.write(Kernel.IO.stdout, outbuf, outlast, outwritten, res);
   if not res.ok or else outwritten /= outlast then
      exitcode := 1;
   else
      exitcode := 0;
   end if;
   
   Kernel.Processes.sysexit(exitcode);
end test_kernel;

00000000 <_ada_test_kernel>:
   0:	55                   	push   %ebp
   1:	b8 02 00 00 00       	mov    $0x2,%eax    <= the fork call.
   6:	57                   	push   %edi
   7:	56                   	push   %esi
   8:	53                   	push   %ebx
   9:	83 ec 54             	sub    $0x54,%esp
   c:	cd 80                	int    $0x80        <= the fork call.
   e:	31 db                	xor    %ebx,%ebx
  10:	89 c1                	mov    %eax,%ecx    <= return code for fork
  12:	83 c0 7c             	add    $0x7c,%eax
  15:	89 4c 24 28          	mov    %ecx,0x28(%esp,1)
  19:	83 f8 7b             	cmp    $0x7b,%eax
  1c:	89 d0                	mov    %edx,%eax
  1e:	0f 96 c3             	setbe  %bl          <= set the error bit
  21:	31 f6                	xor    %esi,%esi    <= the if construct
  23:	30 c0                	xor    %al,%al
  25:	89 c2                	mov    %eax,%edx
  27:	09 da                	or     %ebx,%edx
  29:	31 db                	xor    %ebx,%ebx
  2b:	89 54 24 24          	mov    %edx,0x24(%esp,1)
  2f:	84 d2                	test   %dl,%dl
  31:	74 10                	je     43 <_ada_test_kernel+0x43>
 ...