Gpc June 1998

gpc@gnu.de

38 participants
59 discussions

Re: GPC MANUAL: Schemata, Pointer arithmetics
by Frank Heckenbach 03 Jun '98

03 Jun '98

Peter Gerwinski wrote: > here are three new sections for the "programmer's guide to GPC" (see > `info -f gpc -n programming'). Comments/improvements/etc. welcome. OK, here they are. :-) > @node Schemata > [...] > Schemata are types that depend on a variable, called ``discriminant''. <nitpick> There can be more than one discriminant. </nitpick> > @node Pointer arithmetics > [...] > @smallexample > Var > A: array [ 1..7 ] of Char; > p, q: ^Char; > i: Integer; > > [...] > > for p:= @@A [ 1 ] to @@A [ 7 ] do > p^:= 'x'; > > q:= @@A [ 3 ]; > while p > q do This is a bad example, IMHO, since p is defined as being undefined after a for loop, AFAIK -- even if it might actually have the correct value here. > begin > p^:= 'y'; > dec ( p ); > end (* while *); > > i:= q - p; This would, after the above while loop, always be 0, and is therefore not very instructive, I think. > @node Type casts This section does not clearly draw the distinction between value type casting and variable type casting. So I'll try to write an improvement of this section (it got a little bit longer ;-): @c ============================================================================ @node Type casts @section Type Casts @cindex type casts In some cases, especially when interfacing with other languages, Pascal's strong typing can be an obstacle. To temporarily circumvent this, GPC (and other Pascal compilers) defines explicit ``type casts''. There are two kinds of type casts, value type casts and variable type casts. Value type casts To convert a value of one data type into another type, you can use the target type like the name of a function that is called. The value to be converted can be a variable or an expression. An example: @smallexample Var Ch: Char; i: Integer; [...] i := Integer (Ch); @end smallexample Another, more complicated, example: @smallexample Type CharPtr = ^Char; CharArray = array [ 0..99 ] of Char; CharArrayPtr = ^CharArray; Var Foo1, Foo2: CharPtr; Bar: CharArrayPtr; [...] @{$X+@} @{ We need extended syntax in order to use ``Succ'' on a pointer @} Foo1 := CharPtr ( Bar ); Foo2 := CharPtr ( Succ ( Bar ) ); @end smallexample However, because of risks involved with type casts, explained below, you should try to avoid type casts whenever possible -- and it should be possible in most cases. For instance, the first example above could use the built-in function ``Ord'' instead of the type cast: @smallexample i := Ord (Ch); @end smallexample The assignments in the second example could be written in the following way without any type casts: @smallexample Foo1 := @@Bar^ [ 0 ]; Foo2 := @@Bar^ [ 1 ]; @end smallexample Value type casting only works between certain types: either between different ordinal types (including integer types), or between different real types, or between different pointer types. In each case, the actual value, i.e. the ordinal or numeric value or the address pointed to, respectively, is preserved in the cast. Note: It is also possible to cast from an integer into a real type. This is a consequence of the fact that integer values are generally automatically converted to real values when needed. Note: In the case of pointers, a warning is issued if the dereferenced target type requires a bigger alignment than the dereferenced source type (see @ref{alignment}). Variable type casts It is also possible to temporarily change the type of a variable, without converting its contents in any way. This is called variable type casting. The syntax is the same as for value type casting. This can be confusing, as the example below shows. The type-casted variable is still the same variable (memory location) as the original one, just with a different type. Outside of the type cast, the variable keeps its original type. There are some important differences between value and variable type casting: - Variable type casting only works on variables, not on expressions. - The result of a variable type casting is still a variable. Especially, it can be used on the left side of an assignment (as a so-called ``lvalue''), or passed by reference to a procedure. - No values are converted. The contents of the variable, seen as a raw bit pattern, are just interpreted according to the new type. In many cases, this does not make a big difference, e.g. the same ordinal values of different ordinal types have the same bit pattern (provided, the types have the same size), and similarly for different pointer types. However, there are cases where it does make a difference, most notably the completely different internal representation of integer and real types. This is demonstrated in the following example, admittedly a very constructed example, by using an integer and a real type of the same size and trying to cast between them. - Because bit patterns are just interpreted differently, the source and target type must have the same size. If this is not the case, GPC will give a warning. (@@error? see below) - Beware: Variable type casts might have unexpected effects on different platforms since you cannot rely on a specific way the data is stored (e.g. see @ref{endianness}). @smallexample program TypeCastingTraps; { Declare a real type and an integer type of the same size, and some variables of these types we will need. } Type RealType = ShortReal; IntegerType = Integer ( BitSizeOf ( RealType ) ); Var i, i1, i2, i3, i4, i5: IntegerType; r, r1, r2, r3, r4: RealType; begin @{ First part: Casting integer into real types. @} @{ Start with some integer value @} i := 42; @{ First attempt to cast. Here, an lvalue is casted, so this must be a variable type cast. Therefore, the bit pattern of the value of i is transferred unchanged into r1 which results in a silly value of r1. @} IntegerType (r1) := i; @{ Second try. Here we cast an expression -- though a trivial one --, rather than a variable. So this can only be a value type cast. Therefore, the numeric value is preserved, i.e. r2 = 42.0 . @} r2 := RealType (i+0); @{ Third way. In this last example, a variable is casted, and the result is used as an expression, not as an lvalue. So this could be either a value or variable type cast. However, there is a rule that value type casting is preferred if possible. So r3 will contain the correct numeric value, too. @} r3 := RealType (i); @{ Of course, you do not need any casts at all here. A simple assignment will work because of the automatic conversion from integer to real types. So r4 will also get the correct result. @} r4 := i; @{ Now the more difficult part: Casting real into integer types. @} @{ Start with some real value. @} r := 41.9; @{ Like the first attempt above, this one does a variable type cast, preserving bit patterns, and leaving a silly value in i1. @} RealType (i1) := r; @{ The second try from above does not work, because an expression of type real is to be casted into an integer which is not allowed. @} @{ i2 := IntegerType (r+0); @} @{ Third way. This looks just like the third way in the first part which was a value type cast. But -- surprise! Since value type casting is not possible from real into integer, this really does a variable type casting, and the value of i3 is silly again! This difference in behaviour shows some of the hidden traps in type casting. @} i3 := IntegerType (r); @{ As often, it is possible to avoid type casts altogether and convert real types into integers easily by other means, i.e. by using the built-in functions ``Round'' or ``Trunc'', depending on the mode of rounding one wants. @} i4 := Round (r); @{ 42 @} i5 := Trunc (r); @{ 41 @} end. @end smallexample When dealing with objects (see @ref{OOP}), it is often necessary---and safe---to cast a pointer to an object into a pointer to a more specialized (derived) object. In future releases, GPC will provide an operator @samp{as} for a safer approach to this problem. See also: @ref{absolute}, @ref{alignment}, @ref{endianness}, @ref{OOP}, @ref{Ord}, @ref{Chr}, @ref{Round}, @ref{Trunc}. @c ============================================================================ Some notes: - My texi skills are quite limited. In particular I think I should - highlight the headings "value"- and "variable type casting" - mark the "Note:"'s specially and - format the enumeration better than with "-"'s, but I wanted to get this out tonight, so I didn't look up how to do it. - When writing this, I strongly thought there should be a way to mark certain sections as "advanced" and "very advanced"... :-) - I'm not completely sure about the kind of types between which value type casting works, with "works" in the sense of (either or all): supported by BP, supported by GPC currently, should be supported by GPC. This is left to be checked and corrected if necessary. - Unfortunately, GPC does not behave completely like I described it :-(, but I think wrongly so. In particular, for the line "RealType (i1) := r;", it does a value type cast which is IMHO wrong since it is an lvalue. So I consider it a bug in GPC, tested by the following program, very similar to the one above, without comments: program frank170; Type RealType = ShortReal; IntegerType = Integer ( BitSizeOf ( RealType ) ); Var r, r1, r2, r3, r4: RealType; i, i1, i2, i3, i4, i5: IntegerType; begin i := 42; IntegerType (r1) := i; r2 := RealType (i+0); r3 := RealType (i); r4 := i; r := 41.9; RealType (i1) := r; i3 := IntegerType (r); i4 := Round (r); { 42 } i5 := Trunc (r); { 41 } if (r1<>42) and (r2=42) and (r3=42) and (r4=42) and (i1<>41) and (i1<>42) and (i3<>41) and (i3<>42) and (i4=42) and (i5=41) then writeln('OK') else writeln('Failed') end. - I think, GPC should give an error, not just a warning, when casting between types of different size -- at least in {$x-} mode. With extended syntax active (or some other switch), a warning still seems appropriate. Of course: Comments/improvements/etc. welcome! Frank -- Frank Heckenbach, frank(a)pascal.gnu.de http://fjf.gnu.de/ PGP keys: http://pgp5.ai.mit.edu/pks/lookup?op=index&search=Frank+Heckenbach

1 0

Re: GPC test suite (was: egcs-19980517 and gpc-980511)
by mrs＠wrs.com 02 Jun '98

02 Jun '98

> From: Peter Gerwinski <peter(a)gerwinski.de> > Date: Tue, 2 Jun 1998 10:44:24 +0200 (MEST) > Yes: The program contains a comment of the form > (* FLAG --extended-pascal --pedantic -Werror *) > which carries the flags that must be passed to the call to `gpc' > for that the test makes sense. Gee, this exactly mirrors the g++ testsuite. We spell it: // Special g++ Options: -pedantic -Werror

1 0

gpc-bug
by Matthias Klose 02 Jun '98

02 Jun '98

A user reported this bug with gpc-980511, built with the egcs-19980525 snapshot on a Debian/Linux 2.0 system: % cat typrat.pas Unit typrat ; INTERFACE Type TRATIONNEL = Record num : integer ; den : integer ; end ; IMPLEMENTATION END. % cat meo_rat.pas unit meo_rat ; INTERFACE uses typrat in 'typrat.pas'; procedure AffichRat(a : Trationnel) ; IMPLEMENTATION procedure AffichRat(a : Trationnel) ; begin end ; END. % gpc -c typrat.pas % gpc -c meo_rat.pas gpc: Internal compiler error: program gpc1 got fatal signal 11 I hope that this is enough information to reproduce the bug. If not, please ask.

2 1

GPC REFERENCE: ParamCount...
by Orlando Llanes 02 Jun '98

02 Jun '98

Is there a way to retrieve the number of parameters using GPC? See ya! Orlando Llanes "Meine Damen und Herren, Elvis hat soeben das Gebaeude verlassen!" "Look out fo' flyeeng feet" O__/ a010111t(a)bc.seflin.org \/|____. O <__. \/\> / \ ____________|___\______ http://ourworld.compuserve.com/homepages/Monkey414

3 6

GPC REFERENCE: abs
by Peter Gerwinski 02 Jun '98

02 Jun '98

Hi! This is an example entry for how I think our joined effort to complete the GPC reference could work. The section I am posting is already in existence (`abs'): @c ---------------------------------------------------------------------------- @node abs @unnumberedsec abs @cindex abs @unnumberedsubsec Syntax @smallexample Function abs ( i: @var{integer type} ): @var{integer type}; @end smallexample or @smallexample Function abs ( x: @var{real type} ): @var{real type}; @end smallexample or @smallexample Function abs ( z: @var{complex type} ): @var{real type}; @end smallexample @unnumberedsubsec Description Returns the absolute value of the argument: @smallexample Function abs ( x: @var{some type} ): @var{some type}; begin (* abs *) if x < 0 then abs:= -x else abs:= x; end (* abs *); @end smallexample @unnumberedsubsec Standards The function @samp{abs} is defined in ISO-7185 Standard Pascal; its application to complex values is defined in ISO-10206 Extended Pascal. @unnumberedsubsec Example @smallexample Program TestAbs; Var i1: Complex; begin writeln ( abs ( 42 ) ); (* 42 *); writeln ( abs ( -42 ) ); (* 42 *); writeln ( abs ( -12.1 : 0 : 1 ) ); (* 12.1 *); i1:= cmplx ( 1, 1 ); (* 1 + i *) writeln ( abs ( i1 ) : 0 : 10 ); (* yields 1.4142135624, i.e. sqrt ( 2 ) *) end. @end smallexample @unnumberedsubsec See also @ref{sqr}. @c ---------------------------------------------------------------------------- If you follow-up to this mail and modify the section, please include a complete copy without leading "> " or such in order to make it easier for me to integrate the modified copy into `reference.texi'. Peter PS: I just was pointed to some errors in the above, so you can expect my own follow-up to this in a few minutes. :-) -- Peter Gerwinski, Essen, Germany, http://home.pages.de/~Peter.Gerwinski/ Maintainer GNU Pascal - http://home.pages.de/~GNU-Pascal/ - gpc-980511 PGP key on request - 6C 94 45 BE 28 A4 96 - 0E CC E9 12 47 25 82 75 Fight the SPAM and UBE! - http://spam.abuse.net/ - http://maps.vix.com/

3 4

Re: egcs-19980517 and gpc-980511
by mrs＠wrs.com 02 Jun '98

02 Jun '98

> From: Matthias Klose <Matthias.Klose(a)cs.tu-berlin.de> > Date: Fri, 22 May 1998 04:43:56 +0200 (MET DST) > To: egcs(a)cygnus.com, gpc(a)hut.fi > After patching the gpc-980511 drop in for egcs, I got a working > egcs-gpc compiler. Some problems remain: > - the gpc testsuite fails with dejagnu-971222, it runs ok with dejagnu-1.3 1.3 is horribly old, and I don't recommend you use it. dejagnu needs a new FSF release to incorporate all the latest good bits that people have put into it. All the people that use dejagnu, use newer snapshots. Please consider upgrading to dejagnu-971222.

3 7

None
by hantschr＠hantsch.co.at 02 Jun '98

02 Jun '98

--note----------------------------------------------------------------- Username: [rainer] Use the above line in your e-Mail body to reach me in our company. You may use [rainer] at the beginning of the SUBJECT line (with higher priority) instead. -- This will allow us "Automatic Mail Forwarding". Our human "postmaster" may be reached with [rainer]. DO NOT USE OTHER FILE-ENCODING THAN UUENCODE, IT CANNOT BE PROCESSED!!! --note----------------------------------------------------------------- Received: from Hantsch-Message_Server by hantsch.co.at with WordPerfect_Office; Tue, 02 Jun 1998 08:43:34 +0100 Message-Id: <s573bb36.001(a)hantsch.co.at> X-Mailer: WordPerfect Office 4.0 Date: Tue, 02 Jun 1998 08:42:31 +0100 From: hantschr(a)hantsch.co.at To: gpc(a)hut.fi Subject: FPK-Area: Where? Item Type: Note ** PRIVATE ** Hello to everybody! Please, be so kind and let me know if there exists a special area (like this GPC area) for FPK users. I would like to subcribe to it but I couldn't locate one! Thanks in advance, Rainer Hantsch ---------------------------------------------------------------------- | Office address: | You may reach us by: | |--------------------------|-------------------------------------------| | ING. RAINER HANTSCH | Phone : +43 1 7988538 0 | | Khunngasse 21/1 | Fax : +43 1 7988538 18 | | A-1030 Wien/Vienna | BBS : +43 1 7988538 17 | | | e-Mail: hantschr(a)hantsch.co.at | | *** A U S T R I A *** | www : http://members.eunet.at/hantschr/ | ----------------------------------------------------------------------

2 1

GPC MANUAL: Schemata, Pointer arithmetics
by Peter Gerwinski 01 Jun '98

01 Jun '98

Hello, folks! here are three new sections for the "programmer's guide to GPC" (see `info -f gpc -n programming'). Comments/improvements/etc. welcome. Greetings, Peter -- Peter Gerwinski, Essen, Germany, http://home.pages.de/~Peter.Gerwinski/ Maintainer GNU Pascal - http://home.pages.de/~GNU-Pascal/ - gpc-980511 PGP key on request - 6C 94 45 BE 28 A4 96 - 0E CC E9 12 47 25 82 75 Fight the SPAM and UBE! - http://spam.abuse.net/ - http://maps.vix.com/ @c ============================================================================ @node Schemata @section Schema Types @cindex schemata @cindex types, schema Schemata are types that depend on a variable, called ``discriminant''. They are an ISO-10206 Extended Pascal extension. @smallexample Type RealArray ( n: Integer ) = array [ 1..n ] of Real; @end smallexample The type @samp{RealArray} in this example is called a Schema with the discriminant @samp{n}. To declare a variable of such a type, write @cindex Foo @smallexample Var Foo: RealArray ( 42 ); @end smallexample Schema-typed variables ``know'' about their discriminants. They can be accessed just like record fields: @smallexample writeln ( Foo.n ); (* yields 42 *) @end smallexample While types of variables must always have specified discriminants (which may be other variables), @emph{pointers} to schema variables may be without a discriminant: @cindex Bar @smallexample Type RealArrayPtr = ^RealArray; Var Bar: RealArrayPtr; @end smallexample When applying @samp{New} to such a pointer, you must specify the intended value of the discriminant as a parameter: @smallexample New ( Bar, 137 ); @end smallexample As a GNU extension, the above can also be written as @smallexample Bar:= New ( RealArrayPtr, 137 ); @end smallexample Schemata are not limited to arrays. They can be of any type that normally requires constant values in its definition, for instance subrange types, or records containing arrays etc. (Sets do not yet work.) To finish this section, here is a somewhat exotic example: @smallexample Type ColorType = ( red, green, blue ); ColoredInteger ( Color: ColorType ) = Integer; @end smallexample A @samp{ColoredInteger} behaves just like an ordinary integer, but it has an additional property @samp{Color} which can be accessed like a record field. @smallexample Var Foo: ColoredInteger ( green ); [...] Foo:= 7; if Foo.Color = red then inc ( Foo, 2 ) else Foo:= Foo div 3; @end smallexample @c ============================================================================ @node Pointer arithmetics @section Pointer Arithmetics @cindex pointer arithmetics GPC allows to increment, decrement, compare, and subtract pointers or to use them in @samp{for} loops just like the C language. @smallexample Var A: array [ 1..7 ] of Char; p, q: ^Char; i: Integer; [...] for p:= @@A [ 1 ] to @@A [ 7 ] do p^:= 'x'; q:= @@A [ 3 ]; while p > q do begin p^:= 'y'; dec ( p ); end (* while *); i:= q - p; @end smallexample Incrementing a pointer by one means to increment the address it contains by the size of the variable it is pointing to. For typeless pointers (@samp{Pointer}), the address is incremented by one instead. Similar things hold when decrementing a pointer. Subtracting two pointers yields the number of variables pointed to between both pointers, i.e.@: the difference of the addresses divided by the size of the variables pointed to. The pointers must be of the same type. @c ============================================================================ @node Type casts @section Type Casts @cindex type casts In some cases, especially when interfacing with other languages, Pascal's strong typing can be an obstacle. To temporarily circumvent this, GPC (and other Pascal compilers) defines explicit ``type casts''. To convert a value of one data type to another type, use the target type as a ``function'': @cindex Foo @cindex Bar @smallexample Type CharPtr = ^Char; CharArray = array [ 0..99 ] of Char; CharArrayPtr = ^CharArray; Var Foo: CharPtr; Bar: CharArrayPtr; [...] Foo:= CharPtr ( Bar ); @end smallexample Beware: Explicit type casts might have unexpected effects on different platforms since you cannot rely on a specific way the data is stored. If it is possible to avoid type casts (which holds for most cases), you should do that. For instance in the example above, you can make @samp{Foo} point to the first char in the array @samp{Bar^}: @smallexample Foo:= @@Bar^ [ 0 ]; @end smallexample When dealing with objects (see @ref{OOP}), it is often necessary---and safe---to cast a pointer to an object to a pointer of a ``bigger'' (derivated) object. In future releases, GPC will provide an operator @samp{as} for a safer approach to this problem. See also: @ref{absolute}. @c ============================================================================

1 0

GPC REFERENCE: SetLength
by Peter Gerwinski 01 Jun '98

01 Jun '98

Hello, folks! Here is a sketch for a `SetLength' reference section. Dose somebody know whether this > @samp{SetLength} is a Borland Delphi 1.0 extension. is really true? Yours, Peter -- Peter Gerwinski, Essen, Germany, http://home.pages.de/~Peter.Gerwinski/ Maintainer GNU Pascal - http://home.pages.de/~GNU-Pascal/ - gpc-980511 PGP key on request - 6C 94 45 BE 28 A4 96 - 0E CC E9 12 47 25 82 75 Fight the SPAM and UBE! - http://spam.abuse.net/ - http://maps.vix.com/ @c ---------------------------------------------------------------------------- @node SetLength @unnumberedsec SetLength @cindex SetLength @unnumberedsubsec Syntax @smallexample Procedure SetLength ( Var S: String; NewLength: Integer ); @end smallexample @unnumberedsubsec Description @samp{SetLength} explicitly assigns a new length @samp{NewLength} to the string parameter @code{S}. The contents of the string is @emph{not} changed; if the operation increases the length of the string, the characters appended at the end are @emph{undefined}. If you want to use @samp{SetLength}, please enable ``extended syntax'' (@samp{--extended-syntax} or @samp{(*$X+*)}). @unnumberedsubsec Standards @samp{SetLength} is a Borland Delphi 1.0 extension. @unnumberedsubsec Example @example Program TestSetLength; (*$X+*) (* Enable "dangerous" features *) Var S: String ( 26 ); begin S:= 'Hello, world!'; SetLength ( S, length ( 'Hello' ) ); writeln ( S ); (* 'Hello' *) SetLength ( S, 26 ); writeln ( S ); (* 'Hello, world!(%$@Â§"!"Â§$Â§"$' *) (* undefined characters ^^^^^^^^^^^^^ *) SetLength ( S, 42 ); (* The overflow is *not* (yet) detected *) writeln ( S ); (* This might cause a runtime error. *) end. @end example @unnumberedsubsec See also @ref{@ref{length}, @ref{String}, @ref{SetType}. @c ----------------------------------------------------------------------------

3 3

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

2000

1999

1998

1997

1996

1995

Gpc June 1998