This is ../p/doc/info/gpc-hr.info, produced by makeinfo version 4.0
from gpc.texi.

INFO-DIR-SECTION GNU programski alati
START-INFO-DIR-ENTRY
* GPC: (gpc).                     GNU Pascal prevodilac (compiler).
END-INFO-DIR-ENTRY
INFO-DIR-SECTION Pojedini alati
START-INFO-DIR-ENTRY
* GPC: (gpc)Pozivanje GPC-a.      GNU Pascal prevodilac (compiler).
END-INFO-DIR-ENTRY

   Ova datoteka dokumentira GPC prevodilac (engl. compiler).

   Copyright (c) 1998-2002 Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License", "The GNU
Project", "The GNU Manifesto" and "Funding for free Software" are
included exactly as in the original, and provided that the entire
resulting derived work is distributed under the terms of a permission
notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License", "The GNU Project", "The GNU Manifesto" and "Funding for Free
Software" and this permission notice, may be included in translations
approved by the Free Software Foundation instead of in the original
English.


File: gpc-hr.info,  Node: Top,  Next: Dobrodošli,  Up: (dir)

GNU Pascal
**********

   Ovaj priručnik dokumentira kako se pokreće, instalira i održava GNU
Pascal Compiler (GPC), kao i njegove nove značajke i eventualne
nekompatibilnosti, te kako prijavljivati bugove.  Odgovara GPC-u
20020510 (GCC 2.95.x).

* Menu:

Uvod:

* Dobrodošli::        Dobrodošli na GNU Pascal ...
* Naglasci::          Neke od GPC-ovih interesantnih značajki.
* News::              Novosti - Nova svojstva GNU Pascala (engleski).
* FAQ::               Lista često postavljana pitanja o GNU Pascalu.

Instalacija:

* Installation::      Instalacija - kako obaviti download, prevesti i
                      instalirati GNU Pascal (engleski).

Korištenje GNU Pascala:

* Borland Pascal::    Brzi vodič za prelaz sa Borland Pascala na GNU Pascal.
* Invoking GPC::      Pozivanje GPC-a (opcije komandne linije podržane od GNU
                      Pascala).
* Programming::       Programerov vodič u GPC (engleski).
* Reference::         Abecedni GPC jezični referentni priručnik (engleski).
* Keywords::          Pascalove ključne riječi i operatori podržani u GPC-u.
* Support::           Gdje dobiti podršku za GNU Pascal; kako prijaviti bug.

Razvoj:

* To Do::             GNU Pascalova "za napraviti" lista (engleski).
* Internals::         Interne strukture - kako dobiti više informacija o samom
                      GPC-ovom kodu (engleski).

Dodatak:

* Suradnici::         Suradnici na GNU Pascal projektu.
* Resursi::           resursi za korištenje s GPC-om.

* Copying::           Kopiranje -- GNU General Public License -- licenca,
                      Vaša prava i obaveze kad koristite GPC (engleski).
* Library Copying::   Kopiranje biblioteka -- GNU Lesser General Public
                      License -- licenca, Vaša prava i obaveze kod
                      korištenja pojedinih biblioteka.
* GNU::               GNU projekt.

* GPC indeks::        Indeks koncepta i imena simbola (nedovršeno).

(Napomena: naslovi nekih poglavlja nisu prevedeni zbog unakrsnih referenci iz
           neprevedenih poglavlja priručnika i prema njima. Ponegdje u
           izborniku bi se mogao pojaviti problem oko `č' i sl. zbog buga
           u GNU `info' <= 4.0f programu.)


File: gpc-hr.info,  Node: Dobrodošli,  Next: Naglasci,  Prev: Top,  Up: Top

Dobrodošli na GNU Pascal ...
****************************

   ...  slobodni 32/64-bitni Pascal prevodilac (engl. compiler) iz
kolekcije GNU prevodilaca (GNU CC ili GCC), koji kombinira Pascal
"front-end" s dokazanim GCC "back-end"-om za generiranje koda i
optimizaciju. Osim njega kolekcija trenutno uključuje prevodioce za
Adu, C, C++, Objective C, Chill, FORTRAN, i Javu.  Za razliku od
pretvarača koda kao što je p2c, ovo je istinski prevodilac, ne samo
konverter (u drugi jezik, najčešće C).

   Ova verzija GPC-a odgovara GCC verziji 2.95.x.

   Svrha GNU Pascal projekta je da proizvede jedan Pascal prevodilac
(zvan GNU Pascal ili GPC) koji

   * kombinira jasnoću Pascala s moćnim alatima pogodnim za
     programiranje iz realnog života,

   * podržava jednako Pascal standard i Extended Pascal standard
     standard kao definiran od ISO, ANSI i IEEE (ISO 7185:1990, ISO/IEC
     10206:1991, ANSI/IEEE 770X3.160-1989),

   * podržava druge Pascal standarde (UCSD Pascal, Borland Pascal,
     dijelove Borland Delphija i Pascal-SC) toliko dok to služi jasnoći
     i korisnosti,

   * može biti distribuiran pod GNU licencnim uvjetima, i

   * može generirati kod i izvršavati se na svakom računalu za koje GNU
     C prevodilac može generirati kod i vrtiti se na njemu.

   Pascal je originalno dizajniran za učenje. GNU Pascal donosi pogodan
način da se prijeđe na izazovne programerske zadatke bez učenja potpuno
novog jezika.

   Trenutno izdanje implementira Standard Pascal (ISO 7185, razine 0 i
1), veliki podskup Extended Pascala (ISO 10206, težeći potpunom
ispunjavanju standarda), visoko je kompatibilan sa Borland Pascalom
(verzija 7.0) sa nekim Delphi proširenjima, te pruža mnogo korisnih GNU
proširenja.

   Ovaj priručnik sadrži

   * pregled nekih od GPC-ovih najinteresantnijih svojstava, vidi *Note
     Naglasci::,

   * listu novih svojstava od zadnjeg izdanja, vidi *Note News::,

   * GNU Pascal često postavljana pitanja, vidi *Note FAQ::,

   * instalacijske instrukcije, vidi *Note Installation::,

   * QuickStart Guide - brzi vodič za programere vične Turbo
     Pascal/Borland Pascal prevodiocima, vidi *Note Borland Pascal::,

   * listu opcija komandne linije za pozivanje prevodioca, vidi
     "Pozivanje GPC-a" (*Note Invoking GPC::),

   * Programerski vodič u GPC, koji opisuje Pascal programski jezik
     općenito i GPC specifične aspekte. Vidi *Note Programming::,

   * abecednu referencu GPC jezika, vidi *Note Reference::,

   * listu ključnih riječi i operatora podržanih od GNU Pascala, vidi
     Ključne riječi *Note Keywords::,

   * informacije o tome kako prijavljivati bugove u GNU Pascalu i kako
     dobiti podršku, vidi *Note Support::,

   * listu poznatih bugova i stvari za napraviti, također listu
     ispravljenih bugova i nedavno implementiranih svojstava, see *Note
     To Do::,

   * neke informacije za one koji su zainteresirani kako GNU Pascal
     radi iznutra, see *Note Internals::,

   * listu ljudi koji su doprinijeli koja kaže tko je razvijao i tko
     održava GNU Pascal, vidi *Note Suradnici::,

   * GNU General Public License - GNU Opću javnu licencu, koja vas
     informira o vašim pravima i odgovornostima za korištenja,
     modificiranja i distribucije GNU Pascala, vidi *Note Copying::,

   * ostale tekstove o Free Softwareu i GNU Projektu kojima se
     namjeravalo odgovoriti na pitanja kao "što je GNU?" koja bi sada
     mogli imati u umu, vidi *Note GNU::.

   Ako ste upoznati s programiranjem u Standard Pascalu (ISO 7185),
vjerojatno ćete moći jednostavno početi i prevesti svoje programe.
Također, većina ISO Extended Pascal standarda (ISO 10206) je ugrađena u
GNU Pascal. Extended Pascal svojstva koja još uvijek nedostaju iz GPC-a
su `qualified' module import, `protected' module export, skupovni
tipovi s promjenljivim granicama, inicijalizatori strukturiranih
vrijednosti (engl. structured value initializers) i izrazi kao donje
granice raspona (engl. subrange lower bounds).

   Ako ste Borland Pascal programer, vjerojatno biste trebali početi
čitati QuickStart vodič od BP do GNU Pascala, vidi *Note Borland
Pascal::. Ako ste radoznali o novim mogućnostima koje GPC nudi, možete
dobiti ideju iz pregleda GPC naglasaka (*note Naglasci::), i čitati
više detalja o njima u Programmer's Guide to GPC (*note Programming::)
i u abecednom GPC referentnom priručniku (*note Reference::).

   I, molimo vas, razmislite također kako biste doprinijeli GNU Pascal
projektu. Molimo podržite naš rad doprinoseći GNU Pascalu programskim
primjerima, prijavama bugova, dokumentiranjem, ali čak i vlastitim
poboljšanjima prevodioca.

   Sva registrirana imena korištena u ovom priručniku pripadaju njihovim
respektivnim vlasnicima.


File: gpc-hr.info,  Node: Naglasci,  Next: News,  Prev: Dobrodošli,  Up: Top

Neke od najinteresantnijih značajki GPC-a
*****************************************

   GNU Pascal prevodilac (GPC) je, kao što ime govori, Pascal
prevodilac (engl.  compiler) iz GNU obitelji (*note GNU::). Ovo znači:

   * GPC je 32/64-bitni prevodilac,

   * nema ograničenja kao što je 64 kB ili 640 kb limit poznat iz nekih
     operacijskih sustava - čak i na tim sustavima -,

   * radi na svim operacijskim sustavima podržanim od GNU C prevodioca,
     uključujući

        - Linux (http://www.linux.org) na Intelu, Alphi, S390, i na svim
          ostalim podržanim tipovima hardvera,

        - BSD obitelj: FreeBSD (http://www.freebsd.org), NetBSD
          (http://www.netbsd.org), OpenBSD (http://www.openbsd.org),

        - DOS sa 32 bita, koristeći DJGPP
          (http://www.delorie.com/djgpp/) ili EMX
          (http://www.leo.org/pub/comp/os/os2/leo/gnu/emx+gcc/index.html),

        - MS-Windows 9x/NT, koristeći Cygwin (http://cygwin.com) ili
          mingw (http://www.mingw.org),

        - OS/2 sa EMX
          (http://www.leo.org/pub/comp/os/os2/leo/gnu/emx+gcc/index.html),

        - MIPS-SGI-IRIX,

        - Alpha-DEC-OSF,

        - Sparc-Sun-Solaris,

        - HP/UX
      i druge,

   * može služiti kao nativni prevodilac ili prevodilac između sistema
     (engl. cross-compiler) - između svih podržanih sistema,

   * proizvodi visoko optimirani kod za sve te sisteme,

   * slobodan je softver Free Software
     (http://www.gnu.org/philosophy/free-sw.html) (Open-Source Software
     (http://www.opensource.org)) u skladu sa *GNU General Public
     License* (http://www.gnu.org/copyleft/gpl.html) licencom (*Note
     GNU::, za primjedbe i prijevode),

   * kompatibilan je sa ostalim GNU jezicima i alatima kao što su GNU C
     i GNU debugger (ili, ako više volite, program za simboličko
     ispravljanje pogrešaka u ispravljanom programu).


   Prevodilac podržava slijedeće jezične standarde i kvazi-standarde:

   * ISO-7185 Pascal (*note Resursi::),

   * većinu dijelova ISO-10206 Extended Pascala,

   * Borland Pascal 7.0,

   * dijelove Borland Delphi i Pascal-SC (PXSC).

   Neki naglasci:

   * Iz Standard Pascala: Mnogi popularni Pascal prevodioci tvrde da
     proširuju Standard Pascal, ali im nedostaju ove važne značajke.

        - Polja kao konformni parametri - standardni i komforan način
          prosljeđivanja polja (ARRAY) varijabilne veličine procedurama
          i funkcijama.  [Example (conformantdemo.pas)]

        - Prosljeđivanje lokalnih procedura kao proceduralnih
          parametara - s punim pristupom svim varijablama "nadređene"
          procedure.  [Example (iteratordemo.pas)]

        - Automatski datotečni međuspremnici (engl. file buffers) i
          standardne `Get' i `Put' procedure. Predviđajuće čitanje
          (engl. read-ahead) bez privremenih varijabli. [Example
          (filebuf1demo.pas)] Ovo dozvoljava, na primjer, da se
          provjeri ulaz iz tekst datoteka prije čitanja bez konverzije
          kroz znakovne nizove (engl. strings). [Example
          (filebuf2demo.pas)]

        - Istinski pakirani zapisi (RECORD) i polja. Pakira 8 Booleovih
          varijabli u jedan bajt.  [Example (packdemo.pas)]

        - Interne datoteke. Ne morate se brinuti o kreiranju
          privremenih imena datoteka i njihovom brisanju kasnije.
          [Example (intfiledemo.pas)]

        - Globalni `goto'. (Da, `goto' ima svoju ulogu kada nije
          ograničen na trenutni potprogram.) [Example (parserdemo.pas)]

        - Automatski postavlja diskriminantu varijabilnog zapisa
          (RECORD) u `New'.  [Example (variantdemo.pas)]

        - Skupovi (SET) proizvoljne veličine. [Example
          (bigsetsdemo.pas)]

   * Iz Extended Pascala:

        - Znakovni nizovi (strings) proizvoljne duljine.  [Example
          (stringschemademo.pas)]

        - `ReadStr' i `WriteStr'. Čitajte iz i pišite u znakovne nizove
          sa punim komforom `ReadLn'/`WriteLn'.  [Example
          (rwstringdemo.pas)]

        - Rutine za predstavljanje datuma i vremena neovisne od sistema
          (prenosive).  [Example (datetimedemo.pas)]

        - Iteracija pomoću članova skupa:
          `for Ch in ['A' .. 'Z', 'a' .. 'z'] do ...' [Example
          (bigsetsdemo.pas)]

        - Proširene operacije nad skupovima (simetrična diferencija,
          `Card')

        - Generalizirane `Succ' i `Pred' funkcije
          (`foo := Succ (bar, 5);').

        - Kompleksni brojevi. [Example (mandelbrot.pas)] [Example
          (parserdemo.pas)]

        - Operatori za potenciranje (`pow' i `**') za realne i
          kompleksne brojeve.

        - Inicijalizirane varijable. [Example (initvardemo.pas)]

        - Funkcije mogu vraćati vrijednost tipa zapis ili polje
          (Record, Array).

        - Varijable za imenovanu povratnu vrijednost u funkcijama.
          [Example (returnvaluedemo.pas)]

        - Moduli.

        - Ne-dekadski brojevi u bazama od 2 do 36: `baza#broj'.

        - `MinReal', `MaxReal', `EpsReal', `MaxChar' konstante.

        - Schemata - Pascalov način da se dobiju dinamička polja bez
          nestašnih trikova [Example (schemademo.pas)]

        - Lokalne varijable mogu imati dinamičku veličinu.  [Example
          (dynamicarraydemo.pas)]

        - Pristup odsječcima polja - pristupa se dijelovima polja kao
          manjem polju, čak i na lijevoj strani operacije dodjele
          vrijednosti (engl. assignment) [Example (arrayslicedemo.pas)]

   * Kompatibilan sa Borland Pascalom 7.0 s objektima (BP):

        - Podržava jedinice (UNIT), objekte, ..., i čini čak i stvari
          kao `absolute' varijable prenosivima. [Example (absdemo.pas)]

        - Dolazi s prenosivim verzijama standardnih BP jedinica sa punim
          izvornim kodom.

        - Istinski mrežno-transparentna CRT jedinica: možete izvršavati
          svoje CRT aplikacije lokalno ili dok ste prijavljeni udaljeno
          (remote login), bez potrebe za brigom o različitim tipovima
          terminala. Kompatibilna s BP jedinicom, ali s mnogim
          proširenjima, kao npr. preklapajući prozori.  [Example
          (crtdemo.pas)]

        - Potpuno funkcionalna GUI (X11) verzija CRT (također potpuno
          mrežno transparentna).

        - `Random' funkcija koja može proizvesti iste sekvence
          pseudo-slučajnih brojeva kao i ona u BP - ako vam je to
          potrebno umjesto mnogo jače elaboriranog inicijalnog
          algoritma.

        - Podržava proceduralne varijable u stilu BP-a, jednako kao i
          procedure kao parametre iz Standard Pascala. [Example
          (procvardemo.pas)]

        - `Ports' jedinica dozvoljava pristup I/O portovima na
          sistemima gdje to ima smisla. [Example (portdemo.pas)]

        - Specijalne kompatibilnostne značajke za pomoć u migraciji s
          BP-a na GPC, kao `GPC for BP' jedinica koja pruža neke od
          GPC-ovih značajki za BP, te neke rutine za pristup skupovima
          velikih memorijskih blokova na uniforman način pod GPC-om i
          BP-om (čak i u tzv. realnom modu).  [Example (bigmemdemo.pas)]

        - Dolazi sa BP-kompatibilnom `binobj' uslugom.  [Example
          (binobjdemo.pas)]

   * Iz Borland Delphija:

        - `abstract' tipovi objekata i metoda

        - `is' i `as' operatori za testiranje pripadnosti objekta tipu

        - komentari s `//'

        - `Setlength' procedura za znakovne nizove (string) čini
          nepotrebnim korištenje trikova kao što je pridodjeljivanje
          "nultom karakteru".

        - `Initialize' i `Finalize' za rukovanje varijablama na niskoj
          razini.

   * Iz Pascal-SC (PXSC):

        - Korisnički redefinirani (preopterećeni) operatori. Zbrajajte
          svoje vektore sa `+'.

   * Pažljivo definirana GNU proširenja pomažu vam da učinite svoje
     programe iz realnog života prenosivima:

        - 64-bitni cjelobrojni tipovi sa i bez predznaka.

        - Specijalni tipovi garantiraju kompatibilnost sa drugim GNU
          jezicima kao što je GNU C. Direktive kao `{$L foo.c}' čine
          jednostavnim održavanje projekata pisanih u više jezika, npr.
          uključivanje koda pisanog u drugim jezicima u Pascal programe
          [Primjer (Pascal dio) (c_gpc.pas)] [Primjer (C dio)
          (c_gpc_c.c)],

        - ili uključivanje Pascal koda u programe pisane u drugim
          jezicima.  [Primjer (Pascal dio) (gpc_c_pas.pas)] [Primjer
          (Pascal jedinica) (gpc_c_unit.pas)] [Primjer (C dio)
          (gpc_c_c.c)]

        - Proširenja kao `BitSizeOf' i `ConvertFromBigEndian' pomažu
          rješavanju problema s različitim tipovima i unutrašnjim
          poretkom (engl. endianess - big endian, little endian).
          [Example (endiandemo.pas)]

        - Male sitnice kao što su `DirSeparator', `PathSeparator',
          `GetTempDirectory' pomažu vam da pišete programe koji
          izgledaju i osjećaju se "kod kuće" na svim operativnim
          sistemima.

        - `PExecute' rutina dozvoljava izvođenje 'child' procesa na
          prenosiv način koji u potpunosti iskorištava višezadaćne
          (engl. multitasking) okoline.  [Example (pexecutedemo.pas)]

        - GNU GetOpt rutine daju komforan pristup kratkim i dugim
          opcijama u komandnoj liniji u Unix-stilu sa i bez argumenata.
          [Example (getoptdemo.pas)]

        - Rutine kao `FSplit' ili `FSearch' ili `FExpand' znaju o
          specifičnostima raznih operativnih sistema.  [Example
          (fexpanddemo.pas)]

        - `FormatTime' funkcija pušta vas da formatirate vrijednosti
          datuma i vremena, prema raznim pravilima formatiranja.
          [Example (formattimedemo.pas)]

   * Korisne i prenosive GNU standardne jedinice:

        - `Pipe' jedinica daje međuprocesnu komunikaciju čak i pod
          običnim DOS-om. [Example (pipedemo.pas)] [Demo proces za
          primjer (demoproc.pas)]

        - GNU multipreciznostna `GMP' jedinica omogućava aritmetiku
          cijelih, realnih i racionalnih brojeva proizvoljne
          preciznosti.  [Primjer: faktorijele (factorial.pas)]
          [Primjer: Fibonaccijev niz (fibonacci.pas)] [Primjer:
          potenciranje (power.pas)] [Primjer: potenciranje realnih
          brojeva (realpower.pas)] [Primjer: pi (pi.pas)]

        - POSIX funkcije poput `ReadDir', `StatFS' ili `FileLock'
          pružaju efikasno, lako za korištenje i prenosivo sučelje
          (engl. interface) prema operacijskom sustavu. [Example
          (readdir.pas)] [Example (statfsdemo.pas)], [Example
          (filelockdemo.pas)]

        - `DosUnix' jedinica kompenzira neke nekompatibilnosti između
          dviju obitelji operacijskih sustava.  [Example
          (dosunixdemo.pas)]

        - `MD5' jedinica izračunava MD5 sume poruka (engl. message
          digest), u skladu s RFC 1321. [Example (md5demo.pas)]

        - `FileUtils' jedinica pruža neke rutine za rukovanje
          datotekama i direktorijima na višoj razini.  [Example
          (findfilesdemo.pas)]

        - `StringUtils' jedinica pruža neke rutine za rad sa znakovnim
          nizovima na višoj razini. [Example (stringhashdemo.pas)]

        - `Intl' jedinica za internacionalizaciju.  [Example
          (gettextdemo.pas)] [Example (localedemo.pas)]

        - `Trap' jedinica za hvatanje grešaka u vremenu izvođenja
          (runtime-errors) i njihovo obrađivanje unutar programa.
          [Example (trapdemo.pas)]

        - `HeapMon' jedinica koja pomaže detektirati "curenje" memorije
          (engl. memory leaks) u vašim programima.

   Demo programi spomenuti gore su raspoloživi na WWW-u jednako kao i u
GPC distribucijama, binarnim i source.

   Nedostaci:

   * GNU simbolički debugger (GDB) još ne razumije Pascal sintaksu i
     tipove; potrebno je koristiti C sintaksu kod ispravljanja programa
     GDB-om.

   * Sa GPC-om prevođenje traje dulje nego s npr. Borland Pascalom.

   *Suradnici dobrodošli!*

   Sposobni, predani programeri su uvijek dobrodošli u GNU Pascal tim.
Ako želite biti nezavisni od kompanija kojima morate plaćati za
prevodilac sa mnogo restriktivnijim uvjetima licenciranja koji se
izvršava na _jednom_ operacijskom sustavu, budite pozvani da se
pridružite razvojnom timu, *Note Suradnici::.


File: gpc-hr.info,  Node: News,  Next: FAQ,  Prev: Naglasci,  Up: Top

New Features of GNU Pascal.
***************************

   There's a number of new or changed features which are listed in the
following sections. Features without further description refer to new
routines or options.

* Menu:

* News - General Changes And Possible Incompatibilies with Previous Versions::
* News - Command Line Options and Compiler Directives::
* News - Compiler and RTS Built-in Declarations::
* News - Units::
* News - GPC Manual::
* News - Demo Programs::
* News - Utilities::
* News - Test Suite::
* Legend::


File: gpc-hr.info,  Node: News - General Changes And Possible Incompatibilies with Previous Versions,  Next: News - Command Line Options and Compiler Directives,  Up: News

General Changes And Possible Incompatibilies with Previous Versions
===================================================================

   This release of GPC has been cleaned up substantially. Consequently,
a few old and obsolete features have been dropped or replaced by
cleaner, more flexible or otherwise more useful ones. This might lead
to minor problems with old programs, but we suppose they're very rare
(many programmers might not even know about the old features) and easy
to overcome. The most important ones are listed here, the rest of them
is contained in the following sections and marked with `(@)'.

   * The executables `bpc', `pc' and `epc' as well as the dialect
     specific behaviour if GPC is invoked by those names have been
     dropped. What they did was equivalent to `gpc --borland-pascal',
     `gpc --classic-pascal' or `gpc --extended-pascal', respectively,
     and you can use these forms now. If you need them often, you can
     put them in scripts or aliases called `bpc' etc., of course.

   * `asmname' in variable and constant declarations must now come
     after the type (e.g. `var foo: Integer = 42; asmname 'bar';').
     Furthermore, `asmname' doesn't imply `external' anymore for
     variables.

   * The internal file handling in the RTS was changed from using
     `FILE *' pointers to integer file handles, to make it more
     efficient and to get rid of some problems. Accordingly, the
     `CFile' field in `BindingType' was replaced by a `Handle' field,
     the `AssignCFile' procedure by an `AssignHandle' procedure, and
     the `GetFile' function was removed (a substitute is the function
     `FileHandle' which has already existed in previous releases).

   * The option `--no-nested-comments' (to allow comments like `{ *)'
     as the standard requires) has been renamed to `--mixed-comments'
     (note the inverted value). Accordingly, the compiler directives
     `{$N+}' and `{$N-}' have been renamed to `{$no-mixed-comments}' and
     `{$mixed-comments}'. The default, when no dialect options are
     given, is still `--no-mixed-comments' (i.e., what used to be
     `--nested-comments').

   * A new option `--nested-comments' to allow real nested comments
     like `{ { } }' (also available as a compiler switch, like almost
     all command-line options). Note the new meaning of this switch, so
     if you used it before, you'll probably have to change it to
     `--no-mixed-comments' (see above). If nested comments are enabled,
     comments are also allowed within compiler directives and macros -
     however, compiler directives within other compiler directives are
     still not allowed, and compiler directives within comments are, of
     course, still ignored.

   * C style character escapes (`\n', `\007' etc.) are now the default
     for strings enclosed in double quotes, while single quoted strings
     do not allow them (according to the standard).  Accordingly, a
     verbatim `"' in a double quoted string is now obtained with `\"'
     rather than `""' (but a verbatim `'' in a single quoted string
     still with `''', of course).  Therefore, the option
     `--[no-]char-escapes' and the compiler directives `{$E+}'/`{$E-}'
     have been dropped. If you used these features, please change to
     the appropriate kind of quotes.

   * Macros are no more expanded in `--borland-pascal' and `--delphi'
     modes. Expanding them causes a few problems with strange sources
     written for BP which use the same name for a conditional define
     and an identifier. Macros can be turned on/off, independently of
     the dialect, with the new switches `--[no-]macros'. (B)

   * Macros and conditionals defined with `{$define}' are now
     case-insensitive. (B) Macros and conditionals defined with
     `--define' on the command line are still case-sensitive for
     compatibility to other GNU compilers. In addition, GPC provides
     `{$csdefine}' or `--csdefine' and `{$cidefine}' or `--cidefine' to
     define case sensitive or insensitive macros or conditionals,
     respectively. If you have defined macros or conditionals with
     `{$define}' and rely on them being case-sensitive, change it to
     `{$csdefine}' now.

   * The mechanism for including GPC code into code written in other
     languages has changed and is now more robust. A header gpc-in-c.h
     is provided for inclusion of GPC code into C programs, and a demo
     program GPC_C_Pas (together with C code calling it) is supplied to
     demonstrate this. (Including C code into GPC programs works as
     before.)

   * The preprocessor is now called `gpcpp' (it was `gpc-cpp' before).
     If you have installed an older GPC version, please remove gpc-cpp
     now. If you have any scripts that refer to gpc-cpp directly,
     change the reference to gpcpp. If you use DJGPP, and you added the
     GPC specific sections to djgpp.env as described in the FAQ, please
     change `[gpc-cpp]' to `[gpcpp]'.

   * In `--borland-pascal' mode, GPC now ignores everything after
     `end.'. (This also takes care of "^Z" characters at the end of Dos
     text files). In particular, multiple units or modules in one file
     don't work anymore in `--borland-pascal' mode. (B)

   * GPC has introduced a few new keywords which may break programs
     that use those names as identifiers. Most of them are only
     "conditionally reserved", i.e. they act as keywords only in those
     situations where the keyword makes sense, and can be used as
     identifiers elsewhere. While this does not eliminate all possible
     conflicts, it avoids a number of them. Among the new keywords are
     `attribute', `class' and `published'. (D, partly)


File: gpc-hr.info,  Node: News - Command Line Options and Compiler Directives,  Next: News - Compiler and RTS Built-in Declarations,  Prev: News - General Changes And Possible Incompatibilies with Previous Versions,  Up: News

Command Line Options and Compiler Directives
============================================

   (Here are GPC's _new_ options. For an overview of the options, see
*Note Invoking GPC::.)

   * `-x Pascal'/`--language=Pascal' works now; new option `-x
     Preprocessed-Pascal'/`--language=Preprocessed-Pascal' to compile
     without preprocessing

   * `{$ifopt}' works now, with short directives like in BP (`{$ifopt
     X+}') (B) and also with long directives (`{$ifopt
     extended-syntax}')

   * Local compiler directives and defines can be specified with
     `{$local}' and `{$endlocal}'.

   * Delphi (or C++) style `//' comments in default and `--delphi'
     modes, and a switch `--[no-]delphi-comments' to turn them on/off
     explicitly. (D)

   * `-W[no-]implicit-abstract' (warn if an object type not declared
     `abstract' contains an abstract method)

   * `-W[no-]inherited-abstract' (warn if an abstract object type
     inherits from a non-abstract one)

   * `-W[no-]typed-const' (warn about BP style misuse of typed
     constants)

   * `-W[no-]near-far' (warn about use of the obsolete BP compatible
     `near' and `far' directives)

   * `-W[no-]underscore' (warn about double/leading/trailing
     underscores in identifiers)

   * `-W[no-]mixed-comments' (warn about use of mixed comments)

   * `-W[no-]nested-comments' (warn about use of nested comments)

   * `-W[no-]semicolon' (warn about a semicolon after `then', `else' or
     `do')

   * `-W[no-]field-name-problem' (don't warn about a problem with field
     names)

   * `-W[no-]object-directives' (don't warn about unimplemented
     `private', `protected' and `public' directives)

   * `-W[no-]warnings' (enable/disable warnings)

   * All `-Wfoo' warning options also work as `{$W foo}' compiler
     directives. In contrast to the last alpha release, there must now
     be a space after the `W'. (@)

   * `--no-default-paths' (disable standard unit etc. paths)

   * `--no-unit-path', `--no-object-path' (disable any unit/object
     paths given so far)

   * `--[no-]read-base-specifier' (in read statements, allow
     non-decimal input with `n#')

   * `--[no-]read-hex' (in read statements, allow hexadecimal input
     with `$')

   * `--[no-]read-white-space' (in read statements, require whitespace
     after numbers)

   * `--[no-]io-checking' (same as `{$I+}', `{$I-}')

   * `--[no-]double-quoted-strings'

   * `--[no-]stack-checking', also as compiler directives
     `{$[no-]stack-checking}' or `{$S+}'/`{$S-}' (B)

   * `--[no-]typed-address', also as compiler directives
     `{$[no-]typed-address}' or `{$T+}'/`{$T-}' (B)

   * `--[no-]transparent-file-names' (derive the external file names
     from the file variable names

   * `--[no-]progress-messages', `--[no-]progress-bar' (output
     information to give progress messages or display a progress bar
     while compiling, using suitable utilities)

   * `--init-modules=foo:bar' (initialize the named modules in addition
     to those imported regularly; kind of a kludge)

   * `{$[no-]debug-statement[=foo]}' (call a procedure automatically
     before each statement for debugging)

   * `--big-endian', `--little-endian', `--print-needed-options' for
     targets whose endianness can vary

   * The `--[no-]c-numbers' switch has been removed. If you really used
     C style octal or hex numbers (`0400', `0xf00'), you can easily
     convert them to the Extended Pascal notation (`8#400', `16#f00')
     or (hex only) to the Borland Pascal notation (`$foo'). (@)

   * `{$gnu-pascal}' is now completely equivalent to `--gnu-pascal';
     `{$gnu-pascal}' has been added to all units shipped with GPC, so
     they can also be compiled when `--borland-pascal' or other dialect
     options are given on the command line.

   * `{$if}' directives now understand Pascal operators like `and',
     `or', `not' (C operators are also still understood).

   * `{$P+}'/`{$P-}' was replaced by `{$[no-]pedantic}' (or
     `--[no-]pedantic' on the command line)

   * The single-letter compiler directives are now BP compatible.
     Those that are not meaningful or not necessary in GPC (e.g.
     `{$F+}', `{$O...}', or `{$M}' with only numbers following) are
     ignored in `--borland-pascal' mode and warned about otherwise. (B)
     Note: `{$W+}'/`{$W-}' is now also ignored in `--borland-pascal'
     mode (it is the only single-letter directive left that has a
     different meaning in BP and in GPC, and besides, the BP meaning
     can be safely ignored in GPC).  To enable/disable warnings in
     `--borland-pascal' mode, you can use `{$W [no-]warnings}' now. (@)

   * The RTS command line options are now also available as long
     options; new RTS options `--version' (print RTS version and exit),
     `--abort-on-error' (abort with SIGABRT on runtime error),
     `--error-file', `--error-fd' (dump runtime error messages and
     strack trace to given file name or FD).

   * RTS command line options are now recognized after `--gpc-rts'
     instead of `-Grts'. Also, a single option can be given with
     `--gpc-rts=OPTION'. This is allowed multiple times. (@)

   * The items of `--field-widths' are now delimited by `:' rather than
     `,' so they can be distinguished from the `,' used to delimit
     several compiler options. (@)

   * Files with `.pp' or `.dpr' extension are recognized as Pascal
     sources. (D)

   * New options `--classic-pascal' and `--classic-pascal-level-1'
     (equivalent to `--standard-pascal' and
     `--standard-pascal-level-1', and meaning to supersede the latter
     in the future)

   * New predefined symbol `__GPC_VERSION__'



File: gpc-hr.info,  Node: News - Compiler and RTS Built-in Declarations,  Next: News - Units,  Prev: News - Command Line Options and Compiler Directives,  Up: News

Compiler and RTS Built-in Declarations
======================================

   * Syntax:

        - New operators `is' and `as' for objects

        - `shl' and `shr' can also be used as procedures now.

        - `mod' with negative right operand now works like in BP.  (B)

        - Expressions like `-2 * +3' are now allowed without
          parentheses. (B)

        - The alternative address operator `&' was removed.  (`@' is
          still there.) (@)

        - `register' directive

        - `asmname' and `uses ... in' now allow concatenated strings

        - `asmname' for programs, units and module interfaces

        - Directives with double underscores like `__asmname__',
          `__inline__' have been dropped. The same directives without
          underscores have been available for a long time. Furthermore,
          GPC now supports `^const' to create a pointer to a constant
          (which could be done in a C like fashion with the `__const__'
          directive before). (@)

   * Types:

        - Abstract methods and object types

        - PObjectType with fields `Size', `NegatedSize', `Parent' and
          `Name', returned by `TypeOf' and required by `SetType'

        - ByteBool, ShortBool, WordBool, MedBool, LongBool, LongestBool,
          Boolean(42) (D?)

        - Type qualifiers like `__byte__' or `__unsigned__' have been
          dropped. GPC has been supporting "real" type names like
          `Byte' or `ByteWord' for a long time, and it's easy to change
          to them. Similar for `__cstring__' and `__void__' where
          `CString' and `Void' are available. (@)

        - `nil' is accepted as a value of any procedural/functional
          type (B)


   Some of the following declarations are built into the compiler,
others are declared in the `GPC' module.

   * Files and I/O:

        - SeekEOF, SeekEOLn (B)

        - IOErrorFile

        - New parameter `ElementSize' to ReverseBytes,
          ConvertFromLittleEndian, ConvertFromBigEndian,
          ConvertToLittleEndian, ConvertToBigEndian,
          BlockReadLittleEndian, BlockReadBigEndian,
          BlockWriteLittleEndian, BlockWriteBigEndian (@)

        - ReadStringLittleEndian

        - ReadStringBigEndian

        - WriteStringLittleEndian

        - WriteStringBigEndian

        - GetTempFileNameInDirectory

        - PathExists

        - DataDirectoryName

        - AssignBinary

        - HasWildCardsOrBraces

        - BraceExpand

        - MultiFileNameMatch

        - GlobOn

        - MultiGlob

        - MultiGlobOn

        - QuoteFileName

        - UnQuoteFileName

        - ReadLink

        - FExpandQuoted

        - ForceAddDirSeparator

        - FindNonQuotedChar

        - FindNonQuotedStr

        - NameExtFromPath

        - SystemInfo

        - GetMountPoint

        - FileMove

        - ChMod

        - ChOwn

        - IOSelect

        - IOSelectRead

        - FileNameLoCase

        - FileNamesCaseSensitive (constant)

        - DirRoot (constant)

        - MaskNoStdDir (constant)

        - QuotingCharacter (constant)

        - EnvVarChars (constant)

        - EnvVarCharsFirst (constant)

        - WildCardChars (constant)

        - FileNameSpecialChars (constant)

        - ShellExecCommand (constant)

        - DataReady renamed to CanRead (@)

        - FileLock, FileUnlock

        - MemoryMap, MemoryUnMap

        - RuntimeErrorErrNo

        - InOutResCErrorString

        - CStringStrError

        - `StatFS' is now a function rather than a procedure. (@)

        - `InOutResStr' was renamed to `InOutResString', is now a
          `PString' rather than a `CString', and is now in the `GPC'
          module rather than built into the compiler. (@)

        - New parameter `ErrNoFlag' to `IOError', `IOErrorInteger',
          `IOErrorCString' and `IOErrorFile' (@)

        - New parameter `Quoted' to RelativePath (@)

        - New parameter `Prefix' to ConfigFileName (@)

        - New parameter `AccessTime' to SetFileName (@)

        - ExpandEnvironment recognizes `~user'

        - Each of the parameters `Dir', `Name' and `Ext' to `FSplit'
          may now be `Null'.

        - New fields `User', `Group', `Mode', `Device', `INode',
          `Links', `SymLink', `TextBinary' and `Special', `CloseFlag' in
          `BindingType'

        - The variable `TextFilesBinary' has been dropped. Instead, you
          can now use the procedure `AssignBinary' or the field
          `TextBinary' in `BindingType'. (@)

        - File sizes can now be bigger than `Integer' (e.g. 64 bit
          files on 32 bit machines) if supported by the OS via
          lseek64() or llseek() (e.g. Linux, Solaris, IRIX).

        - Renamed the file mode constants from `fmFOO' to `fm_FOO'. (@)

        - `GetIOErrorMessage' now returns a string rather than a
          `CString'. (@)

        - In `GlobBuffer', the fields `Count' and `Result' (pointer to
          an array of `CString's, 0 baser) were replaced by `Result', a
          pointer to an array of pointers to strings, 1 based). (@)

   * Strings:

        - FormatString

        - FormatStringTransformPtr

        - Integer2String

        - IsUpCase

        - IsLoCase

        - IsAlpha

        - IsAlphaNum

        - IsAlphaNumUnderscore

        - IsSpace

        - IsPrintable

        - Renamed the CString routines in the RTS so they get a
          `CString' prefix, moved the BP compatibility identifiers for
          the same routines into the `Strings' unit (B) (@)

        - MemCompCase

        - StrEqualCase

        - PosCase

        - LastPosCase

        - PosFromCase

        - LastPosTillCase

        - IsPrefixCase

        - IsSuffixCase

        - LTrim (VS/Pascal compatibility :-)

        - LineBreak (constant)

        - SetEnv (makes obsolete libc's PutEnv (@))

        - UnSetEnv

        - GetCEnvironment

        - DisposePPStrings

        - `SetLength' does not require extended syntax anymore.

        - The environment variable management is now implemented in
          Pascal, so it's independent of libc differences (e.g. the
          presence or not of `environ'). Access via `GetEnv' etc. works
          unchanged.

        - The `Environment' variable is now a schema which contains the
          environment variables as CStrings. (@)

        - Empty and case-sensitive environment variables are allowed
          within GPC programs even under Dos.

   * Random:

        - SeedRandom

        - SeedRandomPtr (variable)

        - Randomize is called automatically when necessary (except when
          using the BP compatible random number generator in the System
          unit (B)).

   * Memory:

        - ReAlloc; previous ReAlloc function (libc) renamed to CReAlloc
          (@)

        - ReAllocPtr (variable)

        - ForEachMarkedBlock

        - AllocateBigMem, DisposeBigMem, MoveToBigMem, MoveFromBigMem,
          MapBigMem for uniform access to big memory blocks for GPC and
          BP (B)

   * Time:

        - Sleep

        - SleepMicroSeconds

        - Alarm

        - GetCPUTime

        - GetMicroSecondTime

        - GetDayOfWeek

        - GetDayOfYear

        - GetSundayWeekOfYear

        - GetMondayWeekOfYear

        - GetISOWeekOfYear

        - FormatTime

        - The constant `MonthLength' was replaced by a function of the
          same name that handles leap years. (@)

        - DayOfWeekName (constant)

        - InvalidYear (constant)

        - New parameters `TimeZone', `DST', `TZName1', `TZName2' to
          `UnixTimeToTime' (@)

        - New fields `TimeZone', `DST', `TZName1', `TZName2' in
          `TimeStamp'

   * Misc:

        - Include and Exclude for sets (B)

        - InitProc (D)

        - Initialize (D)

        - Finalize (D)

        - IsInfinity

        - IsNotANumber

        - SplitReal

        - Ln1Plus

        - ReturnAddress

        - FrameAddress

        - Runtime errors are now printed with their address to help
          debugging (using addr2line), and the address is stored in
          ErrorAddr. (B)

        - RegisterRestoreTerminal

        - UnregisterRestoreTerminal

        - RestoreTerminal

        - ExecuteNoTerminal

        - SetProcessGroup

        - SetTerminalProcessGroup

        - GetTerminalProcessGroup

        - IsTerminal

        - GetTerminalName

        - SetInputSignals

        - GetInputSignals

        - GetShellPath

        - GetPasswordEntryByName

        - GetPasswordEntryByUID

        - GetPasswordEntries

        - StrSignal

        - Kill

        - WaitPID

        - InstallSignalHandler

        - BlockSignal

        - SignalBlocked

        - Constants for the signals

        - UserID

        - GroupID

        - IllReservedAddress, IllPriviledgedInstruction, IllReservedOp
          were removed. (@)



File: gpc-hr.info,  Node: News - Units,  Next: News - GPC Manual,  Prev: News - Compiler and RTS Built-in Declarations,  Up: News

GPC Units
=========

   * Compiler features related to units:

        - `uses' and `import' may now occur multiple times in a
          program, unit/module interface or unit/module implementation,
          even between declarations.

        - `gpc-main' settings are now possible in units

        - `public' and `private' directives for interfaces

   * CRT:

        - Works now under Cygwin and mingw.

        - DJGPP: support for 40 column modes (requires updated PDCurses
          library)

        - Renamed the the conditional to get an X11 version from
          XCURSES to X11. (@)

        - Renamed GetScreenSize to ScreenSize (WinCRT compatibility)
          (B) (@)

        - WindowOrg, WindowSize, Cursor, Origin, InactiveTitle,
          AutoTracking, WindowTitle, (variables), ScrollTo, TrackCursor
          (WinCRT compatibility) (B)

        - SimulateBlockCursor, SimulateBlockCursorOff

        - Curses is not initialized at the beginning of the program, but
          rather when the first CRT routine is called. (B)

        - CRTInit to explicitly initialize CRT and also set some
          defaults (PCCharSet and update level) to more natural (and
          less BP compatible) values.

        - CRTSetTerminal

        - CRTAutoInitProc (variable)

        - CRTNotInitialized

        - CRTSavePreviousScreen

        - CRTSavePreviousScreenWorks

        - Any of the parameters to GetWindow may now be `Null'.

        - Support for panels (overlapping windows): GetActivePanel,
          PanelNew, PanelDelete, PanelBindToBackground,
          PanelIsBoundToBackground, PanelActivate, PanelHide, PanelShow,
          PanelHidden, PanelTop, PanelBottom, PanelMoveAbove,
          PanelMoveBelow, PanelAbove, PanelBelow, IgnoreCursor

        - Replaced the variables PCCharSet and UseControlChars by
          routines SetPCCharSet, GetPCCharSet, SetControlChars,
          GetControlChars. (@)

        - SetScreenSize

        - SetMonochrome

        - Renamed IsMonoMode to IsMonochrome. (@)

        - On ncurses platforms, changing the screen is now done through
          a shell command definable in the environment variable
          `RESIZETERM' (which defaults to `resize', `SVGATextMode' and
          `setfont'). The variables `crt_setfont_command_80_25',
          `crt_setfont_command_80_50', `crt_setfont_command_40_25' and
          `crt_setfont_command_40_50' (Linux only) were removed. (@)

        - CRTUpdate

        - CRTRedraw

        - SetScroll

        - CRTSetCursesMode

        - RestoreTerminalClearCRT

        - CtrlKey

        - AltKey

        - AltGrKey

        - ExtraKey

        - constants chCtrlA ... chCtrlZ, kbCtrlA ... kbCtrlZ

        - Catch some signals and return pseudo function keys for them if
          CheckBreak is False.

        - React to screen size changes by external events and return a
          pseudo function key.

        - Reduced the (already small) system-dependent code, and added
          an overview of the few problematic features in the comment at
          the beginning of crt.pas.

   * RegEx:

        - RegExPosFrom

        - CharSet2RegEx

        - Support for converting subexpression or complete matching
          references to upper or lower case while replacing them with
          `\u7' or `\l7'.

        - In `RegExType', the field `Error' is now of type `PString'
          rather than `CString'. (@)

   * GMP:

        - mpf_exp

        - mpf_ln

        - mpf_pow

        - mpf_arctan

        - mpf_pi

        - The unit now works with version 4.x of the GMP library, but it
          also still works with version 2.x or 3.x.

   * System:

        - SetTextBuf (B)

        - CompToDouble (D)

        - DoubleToComp (D)

        - AllocMemCount (D)

        - AllocMemSize (D)

        - Assert (D)

        - DefaultAssertErrorProc

        - AssertErrorProc (variable) (D)

        - NoErrMsg (variable) (D)

        - RealToBPReal, BPRealToReal to convert between binary BP
          compatible 6 byte reals and GPC's reals (useful, e.g., for
          binary file exchange with BP programs) (B)

        - Ofs, Seg, Ptr, CSeg, DSeg, SSeg, SPtr (mostly useless and only
          for BP compatibility) (B)

        - A number of variables like SelectorInc (mostly useless and
          only for BP compatibility) (B)

        - Renamed the `__BP_INTEGERS__' conditional to
          `__BP_TYPE_SIZES__'. (@)

        - New conditional `__BP_PARAMSTR_0__'

   * Dos, WinDos:

        - GetCBreak

        - SetCBreak

        - GetVerify

        - SetVerify

        - Renamed the `_Borland_16_Bit_' conditional to
          `__BP_TYPE_SIZES__'. (@)

        - Intr, MsDos, only under DJGPP if `__BP_UNPORTABLE_ROUTINES__'
          is defined. (B)

        - DosVersion, SetDate, SetTime, only if
          `__BP_UNPORTABLE_ROUTINES__' is defined (emulated on
          non-DJGPP). (B)

   * Pipe:

        - New parameter `Process' to Pipe (@)

        - WaitPipeProcess

   * PExecute:

        - Routines moved to the `Pipe' unit. The `PExecute' unit does
          not exist anymore. (@)

   * GetOpt:

        - ResetGetOpt

        - `GetOptErrorFlag' is now True by default. (@)

        - Integrated into the RTS so you don't need a `uses GetOpt'
          directive anymore. (@)

        - Renamed the variables and constants used (see gpc.pas under
          `Command Line Option Parsing'). (@)

        - `GetOptLong' can now optionally derive the short options from
          the `LongOptions' array.

   * DosUnix:

        - OEM2Latin1

        - Latin12OEM

   * WinCRT:

     New unit (identical to CRT) (B)

   * HeapMon:

     New unit for (simple) heap checking.

   * Trap:

     New unit for runtime error trapping.

   * MD5:

     New unit for computing MD5 message digests.

   * FileUtils:

     New unit with some file and directory utilities.

   * StringUtils:

     New unit with some string utilities.

   * Intl:

     New unit for internationalization.

   * GPC-BP:

     A `GPC' unit for BP to provide some GPC compatibility to BP
     programs and make it easier to gradually convert them to GPC. (G)


   A few of the units (in particular: CRT, GMP and RegEx) require
libraries. The sources of the libraries, with small patches where
necessary, as well as binaries for i586-pc-linux-gnu,
i586-pc-linux-gnulibc1, m68k-linux, sparc-sun-solaris2, i386-pc-go32,
i386-pc-cygwin32 and i386-pc-mingw32 are available from
     `http://www.gnu-pascal.de/libs/'


File: gpc-hr.info,  Node: News - GPC Manual,  Next: News - Demo Programs,  Prev: News - Units,  Up: News

GPC Manual
==========

   * Some very obsolete sections of the manual (e.g., the output of
     running the PVS test suite on an Alpha machine in 1995 ;-) were
     removed.

   * The manual was restructured. Several partly overlapping chapters
     were included into the Programmer's Guide, and the overlapping
     material was merged into more coherent sections.

   * The BP QuickStart Guide was left a separate chapter and completed
     with a section about differences between BP and GPC, especially
     mentioning endianness issues.

   * A lot of new material was added to the `Programming' and
     `Reference' chapters.

   * The list of command-line options and the list of keywords for the
     various dialects were updated, and from now on, they are
     automatically kept up to date, directly from the source. The
     `Invoking GPC' chapter does not contain all options inherited from
     GCC anymore (these can be found in the GCC manual, anyway), but
     rather more extensive descriptions of the most commonly used GPC
     options, with examples.

   * The interface of all units included with GPC, together with a
     short description of the units, is now included in the manual. The
     interface, also that of the `GPC' module which describes the
     interface to the Run Time System, is formatted more nicely,
     especially in the printed version of the manual.

   * The `Support' chapter was updated, now including information about
     GPC's Test Suite and how to report bugs most effectively, as well
     as up-to-date contact information.

   * The installation instructions were updated, now matching the
     current GPC and GCC versions.

   * The FAQ, the To-Do list, and the list of new features (this one
     :-) were integrated into the manual.

   * The list of authors in the manual was updated, and the list of
     contributors was included from the WWW page.

   * The manual was integrated with GPC's WWW pages, i.e. most of the
     WWW pages were synchronized with the corresponding information in
     the manual, and both now contain the same information.

   * The GNU Pascal Coding Standards (English, German and Croatian)
     have been added.

   * Translation of the manual into Croatian has started.


