Newsletter #9-#10 - Moorecad.com

Generjc Routines ano Variable Types in PASCAL
07/£7/7720~
Gen~rjc koutin~s ann vAriaoLe lyoes in PASCAL
U7/27/(72Uo
generate a run time test. Tnis, holds, tOo, if the additional predicate
is not e,aluable at compile time.
--------------------------------
In _egbreit"s ECL system there exists a campi ler as well as an
interpreter. both fully compatible. Each may call the other as a
suoroutine. Therefore the compiler is able to e,aluate parts of a
campi lation un't (routine) and to use the ,alue instead of the form.
So predicates of a generic form may be e,aluated by tne campi ler and
a campi le time selection may be done. In the generic form carried
o,er to P~SCAL-GVr, preoicates are not allowed. There are two reasons
for this aecision:
1. we ha,e no interpreter in our system. Therefore, predicates are
not e,aluable at compile-time, and a run time selection is necessary
for each call of a generic routine with predicates, e,en if
the co,ering of all argument types is asserted. 50 the numeer of
possible run ti~e errors increases.
2. by design, ~ decision in a generic form '5 a decision deeending
on the types, nOt on the 'alues of the arguments. Accoroingly,
ereciicates in a generic form snould De eredicates on types only.
The type classes that are oefined implicitly by predicates,
howe'er, dO not ha,e suCh a specific structure that the compiler
is aole to hanole them (e.g. aLL one-Dimensional arrays). The
comO; ler .ill nDt be able tD determ'ne any component statically.
Therefore a static type cheCking .i II no De possiele inside the
brancn and sa the advantages of tne generic ferm w; II ee lest.
Union types in the sense of EL1, no~e,er, fit to the reguirements
of PASCAL. First, tne structure of eaCh alternati,e is kno.n to the
compiler, so there is no difference to a normal PASCAL type after
the selection of one single alternat;,e ;n a generic form. second,
the type constancy during tne lifetime of a union-typee parameter
allows a stack implement.tion of sUCh parameters. when the proce-
Dure is entereD, the defjnite type with its length oecomes known
(Since this happens at r~n time, runtime type descriptors ha,e to be
generated by the compiler). Since the length is unchangeaDle, an
aooress on the staCk may be Computed for eaCh union-typee parameter
and the argument ,a lues may ue copiee. Access to the parameter
,alues is ;noirect ,ia the compile-time-computable local aedress,
~here a poihter fO tne run-time-computable real adoress ;s to be
storeD. Since .e are able to put uniDn-typed parameters on the
stack as oPPDsea to the PASCAL heap (.here flexible-length parameters
.oulD ha,e to De pUt), there are nD problems with RELEASEcommanas
of the user. So union-typee parameters do not mess UP
PASCAL"s storage management SCheme.
The demand for static type cneCK;ng implies that eaCh generic
par.met~r is fi.ea to a aetined, camp; ler-kno.n type (including a
union type) at the entry into a generic branCh. If that type is a
union, operatiDns on tne parameter are restricteo to assignments and
eQuality t~sts inside the oranCh, s,nce static tyDe checking requires
IUlly f;xee operano types for any Otner operation. This restriction
tDrces a progra~~er to .rite oo.n reDeatedly si~ilar branches for
similar, Out different tyues (e.~. array of ;nt~gervs. array of
real). Tne PASCAL can,entiun of ident,fyinq a type oy jts na~e,
nOt vy its structure, aisenaolps uS to oefine arrays of un;ons and
sO to hanDle si~ilar structures in a single Dr~nCh, since we then
hao to ha,e ,ariables 01 type array of unions. uniDn-typed ,ariables,
nD.e,er, will not be alluweD, since (a) each ,ariable must
ha,e an unchangeaole type ltnere is no chance Df a postponement of
type choice as .ith parameters) ane (n) union-typed ,ariables .ould
impose further neea fnr run time type cneCkS. So the oisad,antage
of multiple .riting ~c~n can not oe remedieu oy using unions. we
.ill see later that there is a slight impro,ement oy use of ,ariable
types.
.ith the gj,en restrictions, the generic form is easily transferaule
to PASCAL. Tnus, a PASCAL-GVT prOcedure bOdY may ae either
a normal PASCAL proceDure Dr a generic form. The only ,iolation of
static ty~e checking ay the use Df a gener,c form may occur if only
oartjal cD,erin~ is gi,en at compile time and thus a run time check
is needed tor branch selection. If at run time the cDmo,natiDn Df
argument types daes not fit to any of the branChes, a type-dependent
run time error will result, ,iDlating the principle of static
tyoe checKing. Tnis, nowever, onlt oCCurS at a well-defined interface,
wnere the user MOy expect it. ~esides, tn~ number of run t;me
branch selections .ill narmally be small.
-.------
tyPe JNT.~R.¥ ~ array l,..J of INTEGE~;
UNION s one~f \1~TtGE", INTAkRAY);
nrOceoure P (P~RA: uNION; PA~B: oneof (CHAR, INTEGER»;
generic (PAkA,PARb) of
lINTAR"AY,ChAkJ Deg;n ena;
lINTEGER,INTE&EkJ cegin end
end;
Types 8S values
--------------.
In eASlAL, typeS are statiC oescrlPtions of the structure of .
class Of oDjects. In EL1, nowe,er, type generators are callable
functions and deliver a type ,alue. Ihe comDi ler e,aluates such
generators unCer assistance Of the interpreter. Consequently, useruefined
tyDe functions as .ell a5 type ,ariables are permitted. If
a type functiDn is not e'aluaole at compile time, a call to the
interpreter is generatee, i,e. type checKing is oelegated to run time.
rYDP v8r;acles may be -frozen', i.e. p.vaLu¥tea in an interpreted
en,ironment of 8 cDmpllation stev, and tneir ,alue may oe used as a
type constant jn the compilation unit. "untrozen" type ,ariables,
aqain, require type checKing at run time. The facilities of evaluating
tYDe functions and freezinG tyoe ,arlaoles enable. the compiler
to nail ao~n variable typ~s. Tne ninaing of routines to typts
;s trar'~fered from pro9rsmm1ng t~mc to campi le time, Out an inte~-
~retec pnvirQnment has to oe ne involvea in this process.