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: Keywords,  Next: Support,  Prev: Reference,  Up: Top

Pascalove ključne riječi i operatori podržani u GNU Pascalu.
************************************************************

   Ovo poglavlje daje popis svih ključnih riječi koje GNU Pascal
razumije.

   Bez posebnih specificiranih opcija, ključne riječi mogu biti
redefinirane kako bi se učinilo mogućim da se svaki korektni ISO 7185
program uspješno prevede. Međutim, možete koristiti prekidače
prevodiočevog (engl. compiler) dijalekta (npr. `--extended-pascal' ili
`--borland-pascal' da bi se naznačilo GPC-u da se riječi danog
standarda ne smiju redefinirati.

   Ključne riječi su preuzete iz slijedećih standarda:

   * ISO 7185 Pascal (SO)

   * ISO 10206 Extended Pascal (EP)

   * ANSI preliminarni Object Pascal (OP)

   * Borland Pascal 7.0 (BP)

   * Borland Delphi (BD)

   * Pascal-SC (PXSC, Pascal eXtensions for Scientific Calculations -
     Pascal proširenja za znanstvene proračune)

   * VAX Pascal (VP)

   * GNU Pascal proširenja

   GPC dozvoljava da slobodno re-definirate sve što nije rezervirana
riječ u ISO 7185 Pascalu u vašem programu ili izabranom dijalektu. Npr.
ne morate mijenjati svoj kod ako koristite ime poput `Restricted' ili
`Value' ili neko slično, osim ako prevodite sa `--extended-pascal'
opcijom.

   U slijedećoj je tablici popis svih poznatih ključnih riječi s kratkim
opisom. Linkovi upućuju na duže opise u referentnom priručniku.

   (Napomena: Tablica nije prevedena jer se generira automatski, kao i
zbog stručnosti termina i izraza, za koje je teško pronaći adekvatni
prijevod).

absolute (BP, BD, GPC) (*note absolute::)
     overloaded variable declaration

abstract (OP, GPC) (*note abstract::)
     abstract object type or method declaration

all (GPC) (*note all::)
     `export' (*note export::) extension (`export foo = all')

and (any) (*note and::)
     Boolean or bitwise `and' operator or part of the `and then' (*note
     and then::) operator

and_then (EP, OP, GPC) (*note and_then::)
     short-circuit Boolean `and' (*note and::) operator

array (any) (*note array::)
     array type declaration

as (OP, BD, GPC) (*note as::)
     object type membership test and conversion

asm (BP, BD, GPC) (*note asm::)
     GNU style inline assembler code

asmname (GPC) (*note asmname::)
     linker name of routines and variables

attribute (GPC) (*note attribute::)
     attributes of routines and variables

begin (any) (*note begin::)
     begin of a code block, part of a `to begin do' (*note to begin
     do::) module constructor

bindable (EP, OP, GPC) (*note bindable::)
     external bindability of files

case (any) (*note case::)
     multi-branch conditional statement or variant `record' (*note
     record::) type

class (OP, BD, GPC) (*note class::)
     OOE/Delphi style object class (not yet implemented)

const (any) (*note const::)
     constant declaration or constant parameter declaration

constructor (OP, BP, BD, GPC) (*note constructor::)
     object constructor

destructor (OP, BP, BD, GPC) (*note destructor::)
     object destructor

div (any) (*note div::)
     integer division operator

do (any) (*note do::)
     part of a `while' (*note while::) or `for' (*note for::) loop, a
     `with' (*note with::) statement, or a `to begin do' (*note to
     begin do::) or `to end do' (*note to end do::) module constructor
     or destructor

downto (any) (*note downto::)
     part of a `for' (*note for::) loop when counting downwards

else (any) (*note else::)
     alternative part of an `if' (*note if::) statement, default `case'
     (*note case::) label or part of the `or else' (*note or else::)
     operator

end (any) (*note end::)
     end of a code block, end of a `case' (*note case::) statement, end
     of a `record' (*note record::) or object declaration, part of a
     `to end do' (*note to end do::) module destructor

export (EP, OP, BP, BD, GPC) (*note export::)
     module interface export

exports (BP, BD, GPC) (*note exports::)
     library export (not yet implemented)

external (UCSD, BP, BD, GPC) (*note external::)
     declaration of external objects

file (any) (*note file::)
     non-text file type declaration

for (any) (*note for::)
     loop statement where the number of loops is known in advance

forward (UCSD, BP, BD, GPC) (*note forward::)
     declaration of a routine whose definition follows below

function (any) (*note function::)
     function declaration

goto (any) (*note goto::)
     statement to jump to a `label' (*note label::)

if (any) (*note if::)
     conditional statement

import (EP, OP, GPC) (*note import::)
     module interface import

implementation (NOT_SP) (*note implementation::)
     module or unit implementation part

in (any) (*note in::)
     set membership test or part of a `for' (*note for::) loop when
     iterating through sets

inherited (OP, BP, BD, GPC) (*note inherited::)
     reference to methods of ancestor object types

inline (GPC) (*note inline::)
     declaration of inline routines

interface (NOT_SP) (*note interface::)
     module or unit interface part

interrupt (BP, BD) (*note interrupt::)
     interrupt handler declaration (not yet implemented)

is (OP, BD, GPC) (*note is::)
     object type membership test

label (any) (*note label::)
     label declaration for a `goto' (*note goto::) statement

library (BP, BD, GPC) (*note library::)
     library declaration (not yet implemented)

mod (any) (*note mod::)
     integer remainder operator

module (EP, OP, GPC) (*note module::)
     EP style or PXSC style module

nil (any) (*note nil::)
     reserved value for unassigned pointers

not (any) (*note not::)
     Boolean or bitwise `not' operator

object (BP, BD, GPC) (*note object::)
     BP style object declaration

of (any) (*note of::)
     part of an `array' (*note array::), `set' (*note set::) or typed
     `file' (*note file::) type declaration, a `case' (*note case::)
     statement, a variant `record' (*note record::) type or a `type of'
     (*note type of::) type inquiry

only (EP, OP, GPC) (*note only::)
     import specification

operator (PXSC, GPC) (*note operator::)
     operator declaration

or (any) (*note or::)
     Boolean or bitwise `or' operator or part of the `or else' (*note
     or else::) operator

or_else (EP, OP, GPC) (*note or_else::)
     short-circuit Boolean `or' (*note or::) operator

otherwise (EP, OP, GPC) (*note otherwise::)
     default case label

packed (any) (*note packed::)
     declaration of packed `record' (*note record::) or `array' (*note
     array::) types, also packed ordinal subranges

pow (EP, OP, GPC) (*note pow::)
     exponentiation operator with integer exponent

private (BP, BD, GPC) (*note private::)
     private object fields

procedure (any) (*note procedure::)
     procedure declaration

program (any) (*note program::)
     start of a Pascal program

property (OP, BD, GPC) (*note property::)
     variable properties (not yet implemented)

protected (EP, OP, BD, GPC) (*note protected::)
     read-only formal parameters and protected object fields

public (BP, BD, GPC) (*note public::)
     public object fields

published (BP, BD, GPC) (*note published::)
     published object fields

qualified (EP, OP, GPC) (*note qualified::)
     import specification

record (any) (*note record::)
     structured type declaration

repeat (any) (*note repeat::)
     loop statement

resident (BP, BD) (*note resident::)
     library export specification (not yet implemented)

restricted (EP, OP, GPC) (*note restricted::)
     restricted type specification

segment (UCSD) (*note segment::)
     segment specification (not yet implemented)

set (any) (*note set::)
     set type declaration

shl (BP, BD, GPC) (*note shl::)
     bitwise left shift operator

shr (BP, BD, GPC) (*note shr::)
     bitwise right shift operator

static (GPC) (*note static::)
     static variable declaration

then (any) (*note then::)
     part of an `if' (*note if::) statement or part of the `and then'
     (*note and then::) operator

to (any) (*note to::)
     part of a `for' (*note for::) loop when counting upwards or a `to
     begin do' (*note to begin do::) or `to end do' (*note to end do::)
     module constructor or destructor

type (any) (*note type::)
     type declaration or part of a `type of' (*note type of::) type
     inquiry

unit (UCSD, BP, BD, GPC) (*note unit::)
     UCSD and BP style unit declaration

until (any) (*note until::)
     end of a `repeat' (*note repeat::) statement

uses (UCSD, BP, BD, GPC) (*note uses::)
     unit import

value (EP, OP, GPC) (*note value::)
     variable initializer

var (any) (*note var::)
     variable declaration or reference parameter declaration

view (OP, GPC) (*note view::)
     object class view (not yet implemented)

virtual (OP, BP, BD, GPC) (*note virtual::)
     virtual object method declaration

volatile (GPC) (*note volatile::)
     volatile variable declaration

while (any) (*note while::)
     loop statement

with (any) (*note with::)
     automatic `record' (*note record::) or object field access

xor (BP, BD, GPC) (*note xor::)
     Boolean or bitwise `exclusive or' operator


File: gpc-hr.info,  Node: Support,  Next: To Do,  Prev: Keywords,  Up: Top

Gdje dobiti podršku za GNU Pascal; kako prijaviti bugove
********************************************************

   (Podrška)

   Ovdje možete pronaći informaciju o tome gdje potražiti najsvježije
informacije o GPC-u, kako dobiti podršku (profesionalnu ili
dobrovoljnu), kako koristiti GPC-ovu test kolekciju, i kako
prijavljivati nove bugove s na koje bi mogli naići.

   Ako imate problema s GNU Pascalom, molimo pogledajte relevantne
dijelove GPC priručnika. Najnovija verzija priručnika je na
raspolaganju na adresi `http://www.gnu-pascal.de/gpc-doc.html' za
online pregledavanje.  Također možete napraviti download kompletnog
priručnika u HTML formatu (tar.gz) (`gpc-html.tar.gz' on GPC's WWW home
page).  Ovaj je priručnik također dostupan i u DVI formatu (gzip)
(`gpc.dvi.gz' on GPC's WWW home page) i PostScript formatu (gzip)
(`gpc.ps.gz' on GPC's WWW home page) za ispis na štampač.

   Ako vam priručnik ne pomaže, evo što vam predlažemo:

*Note FAQ::                Provjerite u GPC FAQ-u

* Menu:

* Mailing List::           Pridružite se GPC mailing listi
* Arhive mailing listi::   Pogledajte u arhivama mailing liste
* Newsgroups::             Pitajte na newsgroupi (grupa vijesti na USENETu)
* Profesionalna podrška::  Potražite individualnu podršku za GPC
* Krahovi prevodioca::     Kad se compiler skrši ...
* Reporting Bugs::         Pronađite kako prijaviti GPC bugove
* Testing::                Testiranje - ako imate GPC source, naučite kako
                           pokrenuti Test Suite (kolekciju testova)
			   da testirate bugove koje prijavljujete.


File: gpc-hr.info,  Node: Mailing List,  Next: Arhive mailing listi,  Up: Support

GPC mailing lista
=================

   (Mailing lista)

   Postoji posebna mailing lista posvećena GNU Pascalu. Možete pisati
na listu, npr. ako imate probleme s instaliranjem GPC-a ili ako ste
našli problem u vezi s GPC-om (molim pogledajte *Note Reporting Bugs::).
Možete također diskutirati i davati sugestije za poboljšanje GPC-a i,
vrlo dobrodošli, ponuditi svoju pomoć ili doprinijeti kod,
dokumentaciju ili drugi rad. Poruke na listu bi trebale biti na
engleskom.

   Da biste se pretplatili na listu, pošaljite naredbu
     subscribe gpc vaša@email.adresa
   u tijelu poruke na <majordomo@gnu.de> (*ne* na `gpc@gnu.de'!).
Subject: polje poruke se ignorira. (Molimo zamijenite
`vaša@email.adresa' vašom pravom email adresom.)  Za više informacija,
pošaljite redak `help' na <majordomo@gnu.de>.

   Možete poslati poruku na mailing listu šaljući email na adresu liste
<gpc@gnu.de> kao da je riječ o osobi.

   Za napuštanje mailing liste, pošaljite naredbu
     unsubscribe gpc vaša@email.adresa
   na <majordomo@gnu.de>.

   Postoji još jedna (malog prometa) najavna lista,
<gpc-announce@gnu.de> na koju se možete pretplatiti da biste ostali
informirani. Da se pretplatite na listu, napišite email s
     subscribe gpc-announce vaša@email.adresa
   u tijelu poruke na <majordomo@gnu.de>. Ako biste željeli najaviti
doprinos, servis ili događaj u relaciji s GPC-om, pozvani ste da
šaljete na ovu listu radije nego na `gpc@gnu.de', ali molimo vas ne
koristite najavnu listu za pitanja ili diskusije.  Molimo uočite da se
sva pošta pristigla na najavnu listu preusmjerava također i na
regularnu listu, tako da se nećete morati pretplatiti na obje liste u
slučaju da ne želite ništa propustiti.

   Postoji i mailing lista za njemačko govorno područje,
<gpc-de@gnu.de>. Za pretplaćivanje pošaljite naredbu
     subscribe gpc-de vaša@email.adresa
   u tijelu poruke na <majordomo@gnu.de> (vrijede natuknice odozgo).


File: gpc-hr.info,  Node: Arhive mailing listi,  Next: Newsgroups,  Prev: Mailing List,  Up: Support

Arhive GPC mailing listi
========================

   Možda se o vašem problemu već diskutiralo na listi. Postoji
pretraživa arhiva mailing liste na WWW-u. Može se pregledavati ili
pretraživati na
     `http://www.gnu-pascal.de/crystal/gpc/en/' (engleski)
     `http://www.gnu-pascal.de/crystal/gpc/de/' (njemački)

   Arhiva njemačke GPC liste je na
     `http://www.gnu-pascal.de/crystal/gpc-de/de/' (njemački)
     `http://www.gnu-pascal.de/crystal/gpc-de/en/' (engleski)


File: gpc-hr.info,  Node: Newsgroups,  Next: Profesionalna podrška,  Prev: Arhive mailing listi,  Up: Support

Newsgroupe (grupe USENET vijesti) relevantne za GPC
===================================================

   Za dobivanje podrške, možete također pitati Usenet grupu vijesti za
pomoć. Postoji više grupa u vezi s Pascalom, ali nijedna nije
specijalizirana samo za GNU Pascal, pa koristite onu koja najbolje
odgovara vašem problemu. Za opća pitanja o Pascalu, preporučujemo
slijedeću:

`news://comp.lang.pascal.misc'       Pascal in general and ungrouped
                                     Pascals.

   Pitanja glede Pascal sintakse mogu biti zgodna u:

`news://comp.lang.pascal.ansi-iso'   Pascal according to ANSI and ISO
                                     standards.

   Slijedeća grupa je sklonište za početnike, odgovarajući pitanja koja
se mogu primijeniti za gotovo bilo koji Pascal. Međutim, ako imate
GPC-specifično pitanje ne postavljajte ga tamo - koristite GPC mailing
listu. A i kada ste u nedoumici koristite GPC maling listu.

`news://comp.lang.pascal.borland'    Borland Pascal questions.

   Ne zaboravite vratiti nazad što ste pribavili. Nitko od nas ne
dobiva novac za odgovaranje na vaša pitanja (ukoliko nas sami ne
platite). Molimo dajte svoj udio odgovarajući na pitanja drugih.


File: gpc-hr.info,  Node: Profesionalna podrška,  Next: Krahovi prevodioca,  Prev: Newsgroups,  Up: Support

Gdje naći profesionalnu podršku za GPC
======================================

   GPC je slobodan software i dolazi *bez ikakve garancije*.

   Ako želite potražiti profesionalnu podršku, možete unajmiti pojedinca
ili poduzeće koja pruža takvu uslugu.

   G-N-U GmbH (http://www.g-n-u.de) izvodi velike dijelove razvoja GNU
Pascala. Ova kompanija nudi specijalnu podršku za GPC i može se
kontaktirati na <info@g-n-u.de>.

   Više općenito, za pronalaženje kompanije ili pojedinca koji nudi
podršku i ostale savjetodavne usluge za free software, pogledajte u GNU
Service Directory (http://www.gnu.org/prep/service.html).


File: gpc-hr.info,  Node: Krahovi prevodioca,  Next: Reporting Bugs,  Prev: Profesionalna podrška,  Up: Support

Kad se compiler skrši ...
=========================

   Ako se prevodilac skrši u radu, otkrili ste bug. Pouzdan prevodilac
se nikad ne ruši. Da biste ljudima koji održavaju pomogli ispraviti
bug, važno je da nam pošaljete problem report.

   Ako ste na Unixu, možete pronaći gdje se prevodilac srušio ako
omogućite coredumpove, zatim učitate prevodilac (`gpc1') plus core
datoteku u debugger (`gdb /vaš_put_ovdje/gpc1 core'), da bi se dobio
ispis stoga (engl. stacktrace). Uključite ovaj ispis stoga u svoju
prijavu buga.


File: gpc-hr.info,  Node: Reporting Bugs,  Next: Testing,  Prev: Krahovi prevodioca,  Up: Support

Kako prijaviti GPC bug
======================

   (Prijava bugova)

   Ako se susretnete s bugom u GPC-u, molimo provjerite da li je to
jedan od već poznatih bugova (*note Known Bugs::). Ako nije, molimo
prijavite ga na GNU Pascal mailing listu (*note Mailing List::). Na taj
način, oni uvijek stižu održavateljima. Molimo primijetite slijedeće
točke.

   * Molimo vas pošaljite deskripciju problema. Nastojte dati koliko
     god je više informacija moguće, s punim tekstom eventualnih poruka
     o greškama s kojima ste se susreli, ili opisom kako se neki izlaz
     razlikuje od očekivanoga. Uvijek specificirajte operacijski sustav
     i tip stroja (npr. izlaz `uname -a' ako niste sigurni) kao i
     verziju GPC-a koju ćete dobiti ako otkucate `gpc -v'.

   * Dobar članak o podnošenju prijave buga može se naći na
     `http://www.chiark.greenend.org.uk/~sgtatham/bugs.html' ili
     `http://freshmeat.net/news/2000/02/26/951627540.html'

     Još jedan dobar članak "How To Ask Questions The Smart Way"
     (Postavljati pitanja na mudar način) je na raspolaganju na adresi
     `http://www.tuxedo.org/~esr/faqs/smart-questions.html'


   Ako je problem u samom prevodiocu, ne u procesu instalacije ili
nečem poput toga, molimo priložite test program koji reproducira
problem, i uočite donje natuknice. Možete također slati test programe
za mogućnosti koje rade u GPC-u kako bi osigurali da se neće pokvariti
u budućim izdanjima.

   * Test program treba biti što je moguće kraći, ali *u svakom
     slučaju*, molimo pošaljite *kompletan* program i *učinite
     sigurnim* da isti još uvijek reproducira problem prije nego što
     nam ga pošaljete. Prečesto, korisnici su nam slali kod koji je
     sadržavao očite sintaksne pogreške daleko prije aktualnog
     problema, ili samo fragmente koda o kojima smo mogli samo izdaleka
     nagađati. To je neproduktivno za nas, a i vama ne pomaže da
     riješite svoj problem.


   Preferirani oblik test programa je forma koju automatizirani GPC
Test Suite razumije. Molimo, ako je ikako moguće, šaljite svoje test
programe u ovoj formi što bi trebalo biti lako za učiniti, kako mi ne
bi morali gubiti vrijeme da ih prilagodimo toj formi, te da se možemo
koncentrirati na rješenje problema.

   * Datoteka koja sadrži glavni program _mora_ imati ime koje završava
     sa `.pas' i mora sadržavati riječ `program' (case-insensitive, tj.
     veliko i odgovarajuće malo slovo se smatraju istim) te `;' u istom
     retku da uopće bude prepoznata od test skripte. Ostale datoteke
     koje završavaju sa `.pas' (npr. moduli i jedinice ili podatke koje
     program treba) ne smiju to sadržavati.

   * Kako Test Suite mora raditi vrlo ... hmph ... čudnim operacijskim
     sustavima, također imena se datoteka moraju razlikovati u prvih
     osam (8) znakova (case-insensitive) i ne bi smjela sadržavati
     ništa osim slova, znamenki, crtice, podvlake (engl. underscore) i
     jedne točke. Dalje, sve pomoćne datoteke (jedinice (unit), moduli,
     include i podatkovne datoteke) ne smije imati imena duža od "8+3"
     znakova. Često je dobra ideja koristiti vlastito ime, nadimak ili
     inicijale iza čega slijedi broj kao ime datoteke.

   * Ako vaš test program zahtijeva nake jedinice (units) ili module,
     nemojte im davati (odnosno njihovim 'interface' sučeljima u slučaju
     modula) uobičajena imena puput `Test', `Foo' ili `MyUnit', osim
     ako imate vrlo posebne razloge za to, budući da bi se mogli
     pojaviti suptilni problemi ako nekoliko testnih programa koristi
     isto ime. Umjesto toga, preporučen pristup je da se imenima
     jedinica/modula/interface-a nadoda prefiks (predmetak) - ime
     glavnog testnog programa ili njegova skraćenica (to je neophodno
     zbog restrikcija na imenima datoteka). Nadalje, molimo
     izbjegavajte korištenje jedinica i modula uopće, ako bug nije
     specifičan za njih; kako bi se test održavao što je moguće
     jednostavnijim.

   * Test program, kada se izvršava, treba proizvesti liniju izlaza
     koja se sastoji od niza `OK' (praćenog znakom za novi red,
     newline) ako je sve prošlo kao što je očekivano, ili bilo što
     drugo (npr. `failed', potencijalno praćeno razlogom pada na testu)
     ako je nešto pošlo krivo.

   * Međutim, ako je program namijenjen da provjeri da li GPC prepoznaje
     (namjernu) grešku u programu, stavite niz `WRONG' negdje u test
     programu, najbolje u komentaru u retku koji sadrži namjernu
     pogrešku, i postavite izlaz programa da bude `failed' ako se
     program greškom ipak prevede. `WRONG' testovi će biti pokrenuti s
     opcijom `-w' da se potisnu sva upozorenja, tako da će samo prave
     pogreške biti detektirane.

     *Primijeti:* Dok je moguće kombinirati nekoliko `OK' testova u
     jednom test programu (ako učinite sigurnim da ispisuje `OK' samo
     ako svi testovi uspješno prođu), ne možete staviti nekoliko
     `WRONG' testova u isti program. Razlog tome je što prevodilac neće
     uspjeti prevođenje (i test će se smatrati uspješnim) već i kad se
     pojavi samo `jedna' od očekivanih grešaka. Dakle, za `WRONG'
     testove, postavite samo jednu provjeru u testni program. Također,
     nastojite održavati takav test program što je moguće
     jednostavnijim, zbog izbjegavanja mogućnosti da ne bi pao zbog
     drugih problema (i zbog toga bi test pogrešno bio smatran
     uspješnim).

   * Ako bi test trebao samo provocirati GPC upozorenje, koristite
     `WARN' umjesto `WRONG'. Ovo će pokrenuti test bez `-w', ali sa
     `-Werror'. Međutim, ovakvi testovi će se također činiti uspješnim
     i ako proizvode grešku kod prevođenja, ne samo kod upozorenja.
     Stoga, kod provjeravanja za upozorenja, često je dobra ideja
     priložiti komplemetarni test (za kojeg se očekuje da uspije) i sa
     `-w' u `FLAG' ili direktivi prevodioca `{$W-}' da bi se osiguralo
     da je riječ zaista samo o upozorenju, a ne o pogrešci.


   Slijedeće specijalne mogućnosti testne aplikacije mogu biti korisne
za konstruiranje ponešto neuobičajenih testova:

   * Ako je očekivani ispis programa nešto osim `OK', stavite to u
     datoteku `<basename>.out' (gdje je `<basename>' ime testnog
     programa bez `.pas' nastavka).

   * Ako program očekuje neki ulaz, stavite ga u datoteku
     `<basename>.in'. Biti će automatski preusmjerena na standardni
     ulaz programa.

   * Ako test treba neke specijalne opcije proslijeđene GPC naredbenoj
     liniji, stavite ih u komentar sa prefiksom `FLAG', npr.

          (* FLAG --extended-pascal -Werror *)

   * Ime izvorne datoteke test programa bit će proslijeđeno kao prvi
     argument naredbene linije do test programa koji se izvršava.

   * Ako test treba biti pokrenut na specijalan način, možete popratiti
     program sa skriptom `<basename>.run' koja će pokrenuti stvarni
     test nakon što je testni program preveden. Ova skripta će biti
     pokrenuta od `sh' (bez obzira na prvu liniju). Da bi bila
     prenosiva, trebala bi koristiti samo standardne alate i značajke
     prisutne u svim `sh' kompatibilnim ljuskama (npr. `ash', `bash',
     ali ne neophodno i `csh'). Ime izvorne datoteke test programa će
     biti proslijeđeno kao prvi argument komandnoj liniji za izvršenje
     skripte u tom slučaju. Prevedena datoteka se uvijek naziva
     `./a.out' na većini sistema, ali, npr. `./a.exe' na Cygwin
     platformi. Environment varijabla `A_OUT' sadrži ime (npr. `a.out'
     ili `a.exe', tako da uvijek možete pozvati program sa
     `./"$A_OUT"').

   * Ako test treba biti preveden na specijalan način (npr. da se odluči
     da li preskočiti test), smjestite naredbe u skriptu (najbolje
     nazvanu `<basename>.cmp'), i staviti ime datoteke sa skriptom u
     komentar ispred čega dolazi `COMPILE-CMD:' u source test programa.
     Skripta za prevođenje će biti pokrenuta *umjesto* prevodioca i
     bilo koje druge akcije poduzete za taj test program, tako da vam
     to daje maksimalnu fleksibilnost u čemu god što trebate napraviti.
     Skripta će biti pokrenuta od `sh' (bez obzira na njenu prvu
     liniju). Da bi bila prenosiva, najbolje da koristi samo standardne
     alatke i značajke `sh' kompatibilnih ljusaka (vidi gore).  Prvi
     argument naredbene linije proslijeđen skripti za prevođenje bit će
     prevodilac kojeg treba koristiti, uključivo sve opcije. Drugi
     argument bit će ime izvorne datoteke sa test programom.  Za neke
     tipične testove postoje standardne skripte za prevođenje, npr.
     `ia32.cmp' koja će preskočiti test osim ako se pokrene na IA32
     procesoru. Ovo je neophodno npr. kad se testira asemblerski kod.
     Naravno, još uvijek je bolje izbjegavati situaciju da se mora
     koristiti takve skripte kad je god moguće.

   * U nekim biste slučajevima mogli poželjeti napisati "poslučajene"
     testove.  Ovo se u normalnim uvjetima ne preporuča, jer čini
     probleme težim za reproducirati, ali ponekad može biti korisno
     (npr. kad želimo pokriti velik raspon parametara). U takvim
     slučajevima može se koristiti slijedeća strategija:

          ...
          
          uses GPC;
          
          var
            RandomSeed: Integer;
          
          begin
            RandomSeed := Random (MaxInt);
            SeedRandom (RandomSeed);
          
            ... { vaši normalni testovi ovdje }
          
            { kad se ispisuje poruka o grešci: }
            if ... then
              begin
                WriteLn ('failed (', RandomSeed, ') ',
                         ... { možebitne dodatne informacije } );
                Halt
              end
          end.

     Ovo je pomalo neprirodno jer se pseudo-slučajni broj koristi za
     (ponovno) postavi 'sjeme' (inicijalno stanje) pseudo-slučajnog
     generatora, ali trenutno nema načina da se dobavi interno stanje
     istog (i zapravo niti nije predstavljeno jednim brojem, već stanjem
     jednog polja).

     Dajući vrijednost `RandomSeed' u poruci o grešci, bit će lako
     reproducirati problem stavljajući ovu vrijednost umesto `Random
     (MaxInt)'.  Samo budite sigurni da ste ispisali ovu vrijednost u
     *svakoj* poruci o bugu koju test program može proizvesti.



File: gpc-hr.info,  Node: Testing,  Prev: Reporting Bugs,  Up: Support

Pokretanje GPC Test Suite kolekcije testova
===========================================

   (Testiranje).

   _Opaska:_ Ako imate instaliranu binarnu distribuciju, obično nemate
Test Suite instaliran (možete napraviti download source distribucije da
ga pribavite, međutim), tako da se ovaj odlomak ne odnosi na vas. Ipak,
još uvijek možete pronaći u odlomku `Prilaganje programa u Test Suite'
kako prijaviti GPC bugove u obliku novih test programa kako bismo ih
mogli ispraviti što je prije moguće.

   Datoteke u test direktoriju i podstablima služe samo za testiranje
GPC-a i ne bi se smjele koristiti za druge svrhe.

   Opaska: Neki od testova nemaju smisla na svim sistemima. Oni su
opremljeni provjerama i bit će preskočeni ako pronađu sistem
nepogodnim. Preskočeni testovi *ne znače* GPC bug, osim ako mislite da
bi pojedini test imao smisla na vašem sistemu.

   * Da se pokrene čitava test kolekcija, otipkajte `make' u test
     direktoriju (ili `make check' u `p' objektnom direktoriju nakon
     izgradnje GPC-a).

   * Ispis će pokazati sve uočene greške (poželjno nijednu) i preskočene
     testove, i konačno sažetak dajući broj uspješnih, testova s
     greškom i preskočenih testova. Svaki test s greškom znači bug u
     GPC-u koji bi trebao biti prijavljen na GPC mailing listu,
     <gpc@gnu.de>.  Ne zaboravite napomenuti operacijski sustav na
     kojem ste pokrenuli testove i ostale relevantne informacije o tome
     što ste radili.

   * Također možete otipkati `make pascal.check-long' da dobijete dugi
     ispis koji je niz imena datoteka praćenih sa `OK' za uspješne
     testove, `SKIPPED' za preskočene testove (oboje velikim slovima),
     i ništa dodatno za testove koji su pali.

   * Da pokrenete samo određene testove, možete otipkati nešto poput
     `make MASK="foo[1-7]*.pas"' ili `make MASK="foo42.pas"
     pascal.check-long'.

   * Da počistite rezultate testova, otipkajte `make clean'.



File: gpc-hr.info,  Node: To Do,  Next: Internals,  Prev: Support,  Up: Top

The GNU Pascal To-Do List.
**************************

   This is the To-Do list for the GNU Pascal Compiler.

   The GNU Pascal development team is constantly working on making GNU
Pascal more reliable and more comfortable. However, there are some
known bugs which will take some time to be fixed (any help welcome!),
and we do not want to hide them from you. You might also be interested
to know what features are planned to be implemented in the future. This
list is meant to keep track of the known bugs and wanted features of
GPC.

   If you want to report a new bug or suggest a new feature, the best
way to do it is in the mailing list. This way, other GPC users can
provide additional ideas, perhaps work-arounds for bugs, and the GPC
maintainers can sooner start to think about how to solve the problem.
The GPC mailing list is <gpc@gnu.de>. To subscribe, send the command
`subscribe gpc your@email.address' in the body of a mail to
<majordomo@gnu.de> (the subject is ignored). An archive of the mailing
list can be found on `http://www.gnu-pascal.de/crystal/gpc/en/'.

   The list changes every few days. The present version refers to the
current GPC snapshot, 20020510.

   This list is part of the GNU Pascal Manual, included in GPC
distributions and snapshots. You can always browse the most current
version of the list on GPC's WWW page in HTML.  If you check the To-Do
list regularly you can decide if and when to try a new snapshort.

* Menu:

* Known Bugs::        Known bugs in GPC
* Planned Features::  Features planned for GPC
* Done::              Fixed bugs and implemented features


File: gpc-hr.info,  Node: Known Bugs,  Next: Planned Features,  Up: To Do

Known bugs in GPC
=================

   In the following sections, you can find information about GPC bugs
that are known to the developers. The list always corresponds to the
latest developer versions of GPC, usually not to the latest official
distribution.

   If you encounter a bug with GPC, please check whether it is one of
the known bugs. If not, report it to the GNU Pascal mailing list.  (But
always report if you solve the problem! :-)

   Entries will be removed from the list as soon as the problem is
solved in the developers' current GPC version. (Exception: If we can't
reproduce the problem, but someone else can, the entry will be removed
when we hear from this person that the problem is solved.)  Problems
which are announced to be solved, but for which we (or the person who
can reproduce the problem) did not get the proof (i.e., a GPC source
patch) yet, are marked `(ok)'.

   A message ID (like `<42@foo.bar>') refers to a message in the GPC
mailing list (or a newsgroup, denoted with `news:') where the topic was
discussed (often a bug report). A note of the form `(xy20001231)'
refers to an internal message of the GPC developers. A file name like
`(foo42.pas)' refers to the according program in the GPC test suite
included in the GPC source distribution.

   * give a warning rather than an error (and nothing in
     `--borland-pascal') when assigning/passing by value an object of
     derived type to one of a base type (and change the VMT pointer in
     the destination/actual parameter), don't change the VMT pointer
     when assigning to a polymorphic object (chief35[ab].pas), don't
     allow value parameters of abstract types, handle value parameters
     like variables in `is'/`as'

   * possible stack overflow when using string concatenation in a loop,
     and problem with string concatenation and `goto' (contourbug.pas,
     martin1.pas, fjf419.pas)

   * `setlimit' is applied when it shouldn't be ((a) variable/constant
     declarations, (b) `set of ShortCard', (c) constant sets)

   * the capacity of strings declared in interfaces of modules is not
     initialized (daj3.pas, sven14c.pas)

   * (subrange) components of packed arrays should be packed as well
     (but not other types) (daj14[ab].pas)

   * initializers of packed arrays don't work (emil5.pas)

   * some functions in boolean shortcuts are always called
     (fjf226[a-\infty].pas)

   * arithmetic expressions don't work as lower array/subrange bounds
     (fjf248.pas)

   * global dynamic variables don't work (john1.pas)

   * check for using, incrementing, ... unused variables
     <199711270257.VAA06393@mint.mint.net> (kevin2.pas), especially for
     strings, also for `for'-loop counters after the loop (EP 6.8.1)
     and modifying `for'-loop counters within the loop or in local
     routines <200005240807.EAA05355@mail.bcpl.net>

   * types declared in a module interface are not visible in the
     implementation (kevin13.pas, mod12.pas)

   * declaring a procedure in the implementation with the same name as
     an imported procedure doesn't work (chief18.pas), detect name
     collisions between imported EP modules (mod9.pas)

   * packed array/record fields don't work in `Read' etc. (tom5.pas)

   * dynamic sets don't work (->PPS)

   * there are some bugs with mathematical functions; GPC fails, for
     example, the Paranoia test

   * the compiler does not always recover well after a parse error
     <199911040915.KAA11168@humulus.daimi.au.dk>

   * count of parameters in error messages should not include `Self' in
     methods or internal parameters for conformant/open arrays
     <8F990E3D9A6FD1118F3B0000F81EA1D84985CE@exchsa2.dsto.defence.gov.au>

   * bug on machines with strict alignment requirements
     <199906021618.MAA06228@sten27.software.mitel.com>

   * forward referencing pointers generate debug info that appears as
     generic pointers; no information of `with' statements is currently
     given to the debugger

   * check parameter names in repeated forward etc. declarations
     <20010321204051.A611@plato>

   * check that all routines declared in an interface are implemented
     in the corresponding implementation

   * the warnings about uninitialized/unused variables don't work for
     strings, sets, etc.

   * Sparc with gcc-2.95.x: `goto' jumping out of two procedure nesting
     levels doesn't work (GCC bug; fixed in 3.0.1)
     <200111170922.KAA09125@goedel.fjf.gnu.de> (fjf558[op].pas) (->
     `Trap' unit)

   * AIX: `ReturnAddress' doesn't work after use of dynmamic variables
     (GCC bug)

   * powerpc: `--strength-reduce' doesn't work with `for' loops (ok?)


File: gpc-hr.info,  Node: Planned Features,  Next: Done,  Prev: Known Bugs,  Up: To Do

Features planned for GPC
========================

   In the following sections, you can find informations about features
which have been suggested and/or discussed for inclusion into GPC,
usually in the GPC mailing list. The division into the sections and the
names of the sections may change when this seems useful. The entries
within each section are in no particular order.

   Some of the entries may be a bit difficult to read. Double question
marks (`??') within the entries mean that it's not yet clear how to do
the thing. Triple question marks (`???') mean that it's not clear
whether to do it at all. ;-)

* Menu:

* Planned - Strings::            String types
* Planned - Records/arrays::     Record and array types
* Planned - Files::              Files
* Planned - Other types::        Other types
* Planned - Units and modules::  Units and modules
* Planned - OOP::                Object oriented programming extensions
* Planned - Misc::               Miscellaneous GPC topics
* Planned - Utilities::          Useful utilities for GPC


File: gpc-hr.info,  Node: Planned - Strings,  Next: Planned - Records/arrays,  Up: Planned Features

Planned features: Strings
-------------------------

   * const/var `AnyString' parameters and pointers (records internally,
     cf. gpc.pas) (GetCapacity; only for var parameters)

   * `SetLength' for non-Pascal string types; use truncate-flag

   * make work on all string types: string functions from
     rts/gstrings.pas, Concat/+ (function with conformant array;
     Optimize `s := s + ch') (fh19971105)

   * new option `--arrays-of-char-as-cstrings={none,zero-based,all}' to
     allow assigning [zero-based] arrays of char to cstring variables
     (warning otherwise) (cstrini2.pas); make padding of those arrays
     in initialized variables and in assignments dependent on this
     switch (fh19970921) (fjf57.pas, ok) and if the length matches
     exactly, give a warning (fh19971013) (cstrassign.pas); pass those
     arrays as cstrings in read*, write*, str (P_*STRING; current
     length=-1 in two places); compile time warning (and treatment as
     non-zero-based) if it's not clear at compile time if a conformant
     array or schema is zero-based or not, and an operation depends on
     this in the zero-based state

   * Short strings (Length, Capacity) and switches
     (tc19980326.2,tc19980327); allow `type x=string' (undiscriminated)
     when switch is set so that strings don't default to length 255
     (fh19971113) (fjf97.pas, ok); don't add a #0 terminator when
     passing as a CString parameter (automatically use String2CString)

   * automatically convert CStrings to Strings?

   * general switch `--bp-strings'

   * offer trimming string relations as functions

   * `WriteStr'-like function

   * wide characters

   * open array/string parameters (`$P', `$V' in BP; undocumented
     `OpenString' identifier in BP)

   * variables of type undiscriminated schema/strings -> remove
     pointers to string constants; functions returning undiscriminated
     schemata (pg19980813.3)


File: gpc-hr.info,  Node: Planned - Records/arrays,  Next: Planned - Files,  Prev: Planned - Strings,  Up: Planned Features

Planned features: Records/arrays
--------------------------------

   * array/record values/initializers: recognize indices and field
     names (sven4.pas), ISO structured constants (constdef.pas);
     variant records <C1256791.0021F002.00@synln01.synstar.de>; allow
     omitting fields; fields in arbitrary order ???; index/field name
     optional; arrays: warning/error when too few fields are given;
     initialized schemata; <200106170346.f5H3ksj22229@mail.bcpl.net>

   * initialized types in records/arrays (inirec[24].pas)

   * when applying `New' to a variant record type with a selector
     given, only allocate the space necessary for the selected variant
     (varrec2.pas) ???

   * Oregon and Vax Pascal structured constants
     <80256540.005E7D08.00@buffer1.quantel.com> ???

   * automatically detected upper array bounds in structured
     constants/intialized variables (-> PXSC)

   * simplify code generated to compute size of dynamical variables if
     no bitfields are involved

   * tagging feature for `with' statements (Sun Pascal) (tom6.pas)
     <200012022215.eB2MFD614424@wsinpa16.win.tue.nl>

   * transpose arrays (Fortran)? <news:918557$mke$1@nnrp1.deja.com>


File: gpc-hr.info,  Node: Planned - Files,  Next: Planned - Other types,  Prev: Planned - Records/arrays,  Up: Planned Features

Planned features: Files
-----------------------

   * `AnyFile' parameters and pointers

   * keep files in FDRList while they live, not only while they're
     open, so `_p_fdrdone' can be applied to all of them

   * packed files (EP) ??

   * `FormatString': left/center/both(?) justification (ok in RTS,
     NEG_WIDTH_LEFT_MASK etc.); rounding (PXSC) ???

   * improve TFDDs (also for typed and untyped files)
     (OpenProc/CloseProc)

   * read/write operators ???

   * let `Assign' call `_p_initfdr' in `--borland-pascal'


File: gpc-hr.info,  Node: Planned - Other types,  Next: Planned - Units and modules,  Prev: Planned - Files,  Up: Planned Features

Planned features: Other types
-----------------------------

   * UCSD Pascal's `Integer[n]' ??? BCD?

   * enum types with specified values ???; Inc, Pred, ... ??

   * enum type extensions (syntax??)

   * check for dereferencing nil pointers

   * general subtypes ???

   * type cast operators ???

   * make `SizeOf' work on specially declared untyped var and const
     parameters (`AnyType'?)

   * sparse sets; sets of arbitrary types ?? ???

   * optimize set constructors even better ???

   * superfluous warning with sets and variable elements (fh19970928)

   * initalization and finalization code for arbitrary types (e.g. GMP
     types)

   * give an error rather than a warning when casting between types of
     different size in {$X-}

   * storage class qualifiers (`external', `asmname', `static',
     `volatile', `attribute')

   * `SELECTED_REAL_KIND' for real types (cf. Fortran, drf) ?? ???

   * resize schemata (cf. `SetLength' in Delphi)

   * subranges with variable limits (couper[23].pas)


File: gpc-hr.info,  Node: Planned - Units and modules,  Next: Planned - OOP,  Prev: Planned - Other types,  Up: Planned Features

Planned features: Units and modules
-----------------------------------

   * qualified identifiers <34508F33.4F685BD1@keele.ac.uk> (also
     `program_name.identifier'?) (problem module.id vs. record.field);
     also for operators; `gpc' for built-in identifiers; duplicate
     identifiers in different units (fjf260[ab].pas); giving the same
     name to a routine in an interface and a local routine doesn't work
     (fjf240.pas); don't capitalize variable names in error messages
     and file name queries (store the casing of the first occurrence of
     an identifier) -> remove `{$no-debug-info}'

   * `external name', `asmname', ...; (-> BP, Delphi) ??, like `$L'
     (fh19990325.2)

   * modules without implementation ??? (pmod1.pas)

   * `asmname' for units

   * qualified import (mod10.pas)

   * inline functions in GPI files

   * unit inheritance (of a complete interface with one statement or
     selectively)
     <Pine.HPP.3.96.971105161603.28577A-100000@tea.geophysik.tu-freiberg.de>,
     <199711061008.LAA25341@agnes.dida.physik.uni-essen.de> ??; virtual
     procedures ???

   * allow accessing non-exported identifiers in the implementation of
     a module
     <Pine.BSI.3.96.971110210330.7570A-100000@malasada.lava.net>

   * `Initialization/Finalization' (Delphi: =`to begin/end do') (???)
     (only in `--delphi'?)


File: gpc-hr.info,  Node: Planned - OOP,  Next: Planned - Misc,  Prev: Planned - Units and modules,  Up: Planned Features

Planned features: OOP
---------------------

   * init VMT in initialized variables (fjf445*.pas)

   * `published', `public', `protected', `private' (scope limited to a
     unit in `--borland-pascal', and to the object type normally)

   * `ProcVar := Obj.Method' {$X+}; method pointers
     (`procedure/function of object') (-> Delphi) ???

   * VMT link (global, local, new: set to 0 or @VMT; destructor: reset
     to 0)

   * checks: `@Obj <> nil', `TypeOf (Obj) <> nil', `TypeOf (Obj)^.Size
     = -TypeOf (Obj)^.NegatedSize'; separate switches; function
     initialized (that does these 3 tests) ???

   * virtual constructors

   * `CLASS is CLASS' (implemented in Pascal with `Parent')

   * interfaces (cf. OOE, Java); `OBJ is INTERFACE' (not so easy?) ???;
     variables of type pointer to more than one interface [and class]
     (also possible!)

   * allow method-implementation right after the declaration ???

   * friends ???

   * `dynamic' (= `virtual' ?)

   * `class' (reference to an object type); allow classes and object
     types to inherit from each other; OOE;
     <01BD7A3A.6B187A20.prucha@helicon.co.at>; obpascal.zip

   * `New': Delphi syntax; Dispose?? (automatically?; set references
     automatically to nil) (-> FPC)

   * `--base-class=foo', `--base-object=bar' ???

   * properties <01BD7A3A.6B187A20.prucha@helicon.co.at>,
     <16131.199805071354@potter.cc.keele.ac.uk>

   * virtual constructors in interfaces (load)???

   * VMT problem with interfaces (my solution??? also with dynamic
     linking???)

   * VMTs (also for local classes (EP modules???)!) in GPI files,
     written to assembler file by main program; `--cfiles=foo': .s file
     with VMTs for C/assembler??? (also .h???)

   * method overloading ??? ??

   * class libraries (more or less TV compatible?/Free Vision/EFLIB)
     (streams as interface type?)

   * VMT: ClassID (64/128 bits?) default 0, error when duplicated,
     warning when 0 and inherited from class with <>0 ?, not allowed
     for abstract classes!; ClassName (also for abstract classes?); [];
     ProgrammerID, BaseClassID at beginning of unit (redeclarable?) ???

   * VMT: Children: list of pVMT

   * find class by ClassID/ClassName (implementable in Pascal with
     `Child')

   * object constants, class variables (-> other name for `VMT');
     virtual/static

   * store in GPI: whether ClassID used, ClassName used, which classes
     are instantiated

   * `asmname' for methods


File: gpc-hr.info,  Node: Planned - Misc,  Next: Planned - Utilities,  Prev: Planned - OOP,  Up: Planned Features

Planned features: Misc
----------------------

   * read Booleans and enum types from files, write enum types to
     files; `--[no-]read-range-checking' (also for subtypes of Char,
     Boolean and enum types!)

   * make it possible to declare routines as `iocritical' and
     `ignorable'

   * switch to warn about everything that could cause portability
     problems

   * document all compiler options and switches; make `gpc --help'
     output all the options ???

   * libraries (static/shared; DLL)
     <Pine.HPP.3.96.971110183550.7996B-100000@tea.geophysik.tu-freiberg.de>

   * smart linking

   * range
     <Pine.LNX.4.21.0012091605570.8168-100000@rusty.russwhit.com>,
     overflow (right operand of mod <=0 is an error), nil pointer,
     string length, object VMT (pointer, negative size field), etc.
     checking <199911040915.KAA11168@humulus.daimi.au.dk>; also for
     array slice access (miklos1.pas); check that strings converted to
     CStrings don't contain #0 characters; initialize strings (length
     field), pointers, ordinal values and reals(?) with invalid values
     if checking is on

   * overloading of unary operators

   * intel assembler syntax; BP BASM ???

   * function overloading (in units and static methods?? - with
     different parameters, override or overload?); asmname?? (perhaps:
     first occurrence of a procedure with normal asmname (=> all
     non-overloaded procedures get normal asmnames)?); cf. Delphi
     methods without `override'

   * and_else, or_then (names??); guarantee complete evaluation in
     `{$B+}' mode

   * `?:' (`x := if c then bar else baz')

   * C operators (`,', `=', `++'/`--' (pre/post), `+=', ...), as
     functions ?

   * `for var: type = foo to bar do' ???

   * error/exception handling (Java,Delphi?)
     <01BD7A3A.6B187A20.prucha@helicon.co.at> (tc20000623)

   * RTS checking (libgpc_g), switch?

   * simplify math functions
     <199708091006.MAA26576@agnes.dida.physik.uni-essen.de>

   * variable number of arguments <32F9CFE7.5CB@lmemw.ericsson.se> ??
     ???

   * multithreading support ?? ???

   * `--wirth-pascal' :-)

   * PXSC standard ... (`pxsc.zip', `contrib/peter/pxsc') (??)

   * Object Oriented Extensions (Technical Report) (??)

   * generic types (cf. OOE section C.1) (gentypes.pas) ???

   * default parameters (cf. OOE section C.4; Delphi 4?)
     (iniparm[12].pas)

   * Pascal++ standard ... (??) ???

   * allow `procedure foo; inline;'

   * compile time assertions ???

   * Ignore{Value,Result}/Discard and Swap for arbitrary types

   * make operators also available as functions

   * `absolute' with automatic type detection; `absolute' procedures
     (with automatic parameter detection) ???

   * Delphi features: CompToCurrency, CurrencyToComp, Slice, TypeInfo
     ???, dynamic arrays (tc19991012); Assert (tc20010225.2)

   * output column numbers in error messages ??

   * warn when `and' and `or' are combined without parentheses
     (-Wparentheses; on by default)

   * assembler blocks should be considered volatile by default ???
     (fh19980829.4)


File: gpc-hr.info,  Node: Planned - Utilities,  Prev: Planned - Misc,  Up: Planned Features

Planned features: Utilities
---------------------------

   * `gp' make utility to replace automake; compile and link programs,
     but compile units without linking and without a warning that there
     is nothing to link; store GPC version numbers, platform and
     options in GPD files and re-compile automatically in `--automake'
     mode when they don't match

   * C header to Pascal translator

   * gdb: Pascal types (sets, files, subranges, schemata, strings, ...)

   * `indent'-like source code formatter for Pascal

   * AT&T <-> Intel assembler syntax converter ???


File: gpc-hr.info,  Node: Done,  Prev: Planned Features,  Up: To Do

Fixed bugs and implemented features
===================================

* Menu:

* Fixed Bugs::            Problems that have been solved
* Implemented Features::  Features that have been implemented

