Questing on String_(re)

Sat, 25 Oct 1997 13:06:57 +0200 (MEST)

Hello, Thomas;
hello, everybody!

According to Thomas Tan:
>
> How does writeln(astring) work,

I am not sure whether I understand your question ...

To use `writeln', just do

    writeln ( MyIntegerValue : 6, MyRealValue : 10 : 4, MyStringValue : 7 );

to get

    42    3.1415  Hallo!

or

    writeln ( 'Answer = ', MyIntegerValue );

to get

    Answer = 42

If you want to know how `writeln' works internally, please look at the
GPC source, file `rts.c', and in the subdirectory `rts' at the files
`rts-write.c' and `rts-wrtinc.c'.  If you have more questions about that,
please post them on this list.

> is the string null terminating?

No, but GPC has an additional string type `CString' (or `PChar' for BP
compatibility) which *is* null-terminated.  If you have, for example,
a null-terminated string you want to pass to an external function that
wants to have such a string as a parameter (this holds for many external
functions written in C), you can use `CString' as follows:


    Program Environment;

    (*$X+*)  (* Enable "extended syntax" if you want to use `CString' *)

    Function SetEnv ( Name, Value: CString; overwrite: Integer ): Integer; C;
    Function GetEnv ( Name: CString ): CString; C;

    Var
      S: CString;

    begin
      SetEnv ( 'TEST_ENV', 'OK', 1 );
      S:= GetEnv ( 'TEST_ENV' );
      writeln ( S );
    end.


> If so, what is the character of null?

Not too surprisingly, it is `chr ( 0 )' or `#0'.  :-)  For `CString'.
GPC's native `String' is *not* null-terminated.

And to answer your implicit question about GPC string internals:
GPC's native `String' is a special case of a "schema type".  It looks
like a record internally:

    Type
      String ( n: Integer ) = record
        Capacity, length: Integer;             (* 8 bytes *)
        data: packed array [ 1..n ] of Char;   (* n bytes *)
      end (* String *);

(* Remark:  The above is a perfectly valid type declaration in GNU Pascal
or any other compiler that supports Extended Pascal's schema types.  It is,
however, not identically the same as GPC's `String' since the built-in
string functions only work on the built-in string type, but it has the same
structure in memory. *)

When you declare a string variable with "Var Foo: String ( 42 )" (* Now you
see where the round parentheses come from. ;*), the "record field" `Capacity'
gets the value 42 assigned, while `length' and `data' remain undefined until
you assign a value to the string.  You can access a string's capacity with
`Foo.capacity' just like a record field.

For dynamical allocation of strings, you can define "Type StringPtr = ^String"
*without* a specified capacity and then give it when `New'ing the variable.


    Program Test;

    Type
      StringPtr = ^String;

    Var
      Foo: StringPtr;

    begin
      New ( Foo, 1042 );  (* allocate a String of maximum length 1042 *)
      Foo^:= 'Hello, world!';
      writeln ( Foo^.Capacity );  (* yields "1024" *)
      writeln ( Foo^ );  (* yields "Hello, world!" *)
      Dispose ( Foo );
    end.


In addition to these features of Extended Pascal, GPC supports the following
extensions:


    Type
      StringPtr = ^String;

    Var
      Foo: StringPtr;

    Foo:= @'Hello, world!';  (* let `Foo' point to a string constant *)

    Foo:= New ( StringPtr, 42 );  (* let `New' act as a function *)


If you want to contribute to the GNU Pascal project, feel free to improve
the existing documentation by adding the things I wrote above (and more;-).
If you do so, please do not forget to post to this list what you are doing
so you can coordinate with others who are currently working on the same
field.

Hope this helps,

    Peter

 Dipl.-Phys. Peter Gerwinski, Essen, Germany, free physicist and programmer
peter.gerwinski@uni-essen.de - http://home.pages.de/~peter.gerwinski/ [971005]
 maintainer GNU Pascal [971001] - http://home.pages.de/~gnu-pascal/ [971005]

Peter Gerwinski (peter@agnes.dida.physik.uni-essen.de)