Inter-Office MemorandumToCedar UsersDateDecember 18, 1981FromEd SatterthwaiteLocationPalo AltoSubjectCedar 7T10 Language and Compiler ChangesOrganizationCSLXEROX Filed on: [Indigo]Lang>Cedar7T10.BravoDRAFTThe document [Indigo]Lang>Cedar6T5.press describes the Cedar language. This memosummarizes the significant changes to the language and compiler since that document was prepared.Types in CedarThis section sketches some current thinking about the Cedar type system and might help you tounderstand the motivation for some of the changes described below. (See also Lampson, Cedarabstract machine [CedarAM.memo, February 1980].)Types as PredicatesEvery type is characterized by some predicate; a value x has type T iff x satisfies the predicate forT. In general, such predicates are defined in terms of a set of marks (tags, etc.) carried by eachvalue; however, the Mesa type system is designed so that most mark manipulation can be donestatically (by the compiler), and the usual representations of most values do not include explicitmarks.A given expression has some fixed syntactic type that depends upon the form of the expression andthe declared types of constituent identifiers. The value denoted by an expression always satisfies thepredicate characterizing its syntactic type, but such a value will often satisfy predicates characterizingother types as well. In this sense, a Cedar value may have an arbitrary number of types. Forexample:If Thing is a variant record type with a variant red, a reference to a Thing might simultaneouslysatisfy the predicates for REF ANY, REF Thing, and REF Thing[red] (formerly REF red Thing, seebelow).An opaque type and the corresponding concrete type are distinct, even within an exporter of theconcrete type, but the predicates for the two types are identical.Roughly speaking, the primary job of the predicates associated with types is to provide correctanswers to questions about low-level representational conventions so that, e.g., the Cedar garbagecollector can operate correctly.The form ISTYPE[x, T] returns the result of applying the predicate characterizing T to the value x.In Cedar 7T10, ISTYPE has been redefined to work in a somewhat more general and uniform way,and the operations of NARROWing and (type-based) SELECTion have been defined in terms of ISTYPE.Н]Оg║pТiНІОc8qН]rТX Н-єqН7BrНІО]ШqН]rН-єqН7BrНІОYqН]rП(Н-єqН7BrНЭОSЛsrНЇОMqТFП1Н?┬uНЇОGrТ└П=Т┘НЇОEtТ┬П%Т┴П<НЇОARvТX НЇО>rТ╟ПGТ╠НЇО<\ТІП"ТЇП5wНЇО:ЄТrНЇО5ЎwТXНЇО2prТ▓ Т⌠П-wr wrwrНЇО0хwrТїП"Т╗П@НЇО/!ТЇП$Т╦П7НЇО-zТ╧Т╨ПEНЇО+рНЇО(└Т▄П"w rП1НЇО&эТ─П!Т│ПFНЇО%5Т┌ПjНЇО#▌ТюП>ТаНЇО!ФН ЛОkТ▀wrП)wrТ▄wrН ЛОдТ²qrqrТ·wrqrwrwrqrwrwrН ЛОН ЛО╒Т└П[Т┘Н ЛОЗТПBНЇО╛ТеП(ТфП7НЇОТўТ╞ПHНЇО]ТНЇОТ°qrwrwrП>wrТ² wrНЇОgТ≥qrТ П)НЇО юТ─qrqrТ│qr .Э y>Г^┴3Cedar 7T10 Changes2Types as Clusters of OperationsIn addition to its predicate, a cluster of operations (sometimes called a group) can be associated witha type. The main purposes of this grouping are to provide a number of packaging conveniencesand to support so-called "object oriented" notation. If x has (syntactic) type T, x.Op[args] meansOp[x, args] where Op is found by looking in the cluster associated with T. Two types may becharacterized by the same predicate but have different associated clusters; in current Cedar, this istrue of, e.g., an opaque type and the corresponding concrete type.Each of the type constructors in Cedar supplies a standard and implicitly defined cluster for eachtype that it constructs. The only mechanism currently available for the explicit construction of sucha cluster is the interface module, and previous versions of Cedar have limited support of thismechanism to opaque types. If T is an opaque type declared by, e.g., T: TYPE;in some interface Defs, operations (procedures) declared in Defs become components of the clusterassociated with T and may be invoked using object notation. Cedar 7T10 extends this support toallow construction of similar clusters for record types. If T is declared in Defs by T: TYPE = RECORD [ ... ];the operations declared in Defs become part of the cluster associated with T. In this case, however,they augment the operations already supplied for T by the RECORD type constructor.Defining clusters in this way has some drawbacks. The use of interfaces as the units of groupingsomewhat overloads the existing notion of an interface; note that all operations declared in aninterface become parts of the clusters of all types declared in that interface. Also, requiring a typeand the operations in its cluster to be defined in the same interface occasionally conflicts with othercriterea for partitioning interfaces. On the other hand, this method of defining clusters seems tocover the important cases well enough to be acceptable in practice. In addition, there is a fairlywell worked-out plan for supporting clusters in a comprehensive, uniform way and for using themto explain parts of the Cedar abstract machine. We therefore recommend the following styleguidelines for your Cedar programming:Partition interfaces so that a single interface defines both a main type T (record or opaque) andall the operations to be provided in the cluster of T (or REF T). Define multiple main typeswithin an interface only if the sets of meaningful operation names for those types are disjoint.Use object notation in clients of interfaces designed to support it; i.e., use x.Op[args] inpreference to Defs.Op[x, args].(For Humus veterans) Avoid interface designs that require clients to write x.Op[x, args],x.ops.Op[x, args] or the like. Use an inline definition of Op within Defs to achieve such aneffect. LANGUAGE CHANGESSyntax for Discriminated TypesIf V is a type expression designating some variant record type with variant a, V[a] is a typeexpression designating the discriminated type. Thus forms such asObject[red] Object[red][short] Object[red][long][80]are equivalent to the old formsred Object short red Object long red Object[80].ЪНЇОfЯvТНGОНЇОbwТXНЇО^оrТ└wrП#wrТ┘НЇО](Т╗Т╘ПQНЇО[─Т╒П5ТёwrwrwrwrwrНЇОYыwrwrТ╧wrwrТ╨wrНЇОX2Т⌡Т°ПUНЇОV┼ТПBНЇОS<ТёПYТєНЇОQ■Т┬ПaТ┴НЇОOМТпП&ТяП8НЇОNFТwrП%НЇОL·wrqrНЇОJВТ≈wrП&wrП!НЇОIPТ÷wrТ═ПNНЇОG╗ТП=wrwrНЇОFwrqrqrНЇОDZТ┴wrТ┼wrНЇОB╡ТП1wrqrНЇО?dТ═Т║ПDНЇО=╪ТиП7ТйП(НЇО<Т▓П-Т⌠П:НЇО:nТ┴П\Т┼ НЇО8фТ╛ПcНЇО7Т╙П6Т╚П-НЇО5xТ⌡ПTТ° НЇО3пТтП&ТуП5НЇО2)ТП&Н ЛО/ўТ█ПIwrН ЛО.Т╗П3Т╘wrqrwrН ЛО,_Т═П`Н ЛО)ДТКПJТЛwrwrwrН ЛО(=Т wrwrwrwrН ЛО%бТТТУП7wrwrwrwrН ЛО$wrwrwrwrТЄwrП,wrwr Т╣Н ЛО"sТНЇО}vТXНЇО[НЇОrТвwrПHwrwrwrТьНЇОeТПAН ЛОЎwrwrТXwrwrwrwrwrwrwrНЇОТН ЛОowrТXwrwrwrwrwrwrwrwrЪ╛Ї(=ГXЦґCedar 7T10 Changes3In Cedar 7T10, both forms are acceptable, but you will eventually have to convert to the former asCedar moves toward a unified syntax for expressions and type expressions.Type DiscriminationCedar 7T10 unifies the mechanisms for discriminating variant records with those for discriminatingvalues with type REF ANY. This unification affects the operators ISTYPE and NARROW as well asdiscriminating selection.Type TestingThe primitive function ISTYPE tests whether a given value satisfies the predicate characterizing aspecified type. You will probably have little direct use for ISTYPE; its importance lies in its use todefine other, more common operations as described below. Let x be an expression with syntactictype S. In Cedar 7T10, the value of ISTYPE[x, T] is determined as follows, where V is any variantrecord type:(1) It is TRUE (at compile time) ifS and T are equivalent types; orS is an opaque type and T is the corresponding concrete type; orS is a concrete type exported as the opaque type T.The last two cases are recognized only within program modules that export the concrete type.(2) It is determined dynamically by a test of the value x, yielding TRUE or FALSE, ifS is REF ANY and T is REF U for any U except ANY; orS is equivalent to V and T is equivalent to V[a]; orS is equivalent to REF V and T is equivalent to REF V[a]; orS is equivalent to (LONG) POINTER TO V and T is equivalent to (LONG) POINTER TO V[a];where V[a] is a particular variant of V, perhaps discriminated to several levels. Note that the resultis TRUE if the value of x is NIL.(3) In all other cases, ISTYPE is unimplemented and is treated as a compile-time error.Subsequent versions of Cedar will provide a more general definition and implementation of ISTYPE.Note in particular that ISTYPE cannot currently be used to test a value for membership in asubrange.NarrowingNARROW[x, T] allows a value x to be viewed as a value of type T and succeeds iff ISTYPE[x, T] isTRUE. More precisely, NARROW[x, T] has (syntactic) type T, and its value is given byIF ISTYPE[x, T] THEN x ELSE ERROR where isRTTypesBasic.NarrowRefFault[x, CODE[T]]if ISTYPE[x, REF ANY]RTTypesBasic.NarrowFault[]otherwise.ЪНЇОfЯvТНGОНЇОbrТ▌П)Т▐П9НЇО`vТПIНЇО\TvТXНЇОYrТ√Т≈ПLНЇОW^ТІqrТЇqrqr НЇОUЇТНЇОPаwТXНЇОMrrТ╨qrП&Т╩НЇОKкТ∙Т√П.qrП#НЇОJ#Т÷П8Т═wrНЇОH|Т∙wrqrwrТ√wrП"wrНЇОFуТН ЛОC├ТX qrНMОAwrwrНMО?dwrwrП'НMО=╪wrП0wrНMО;etТFП\Н ЛО89rТXП8wr qrqrНMО5ЎwrqТFrТXwrqrwrwrqrНMО4wrwrwrwrwrНMО2pwrqrwrwrqrwrwrНMО0хwrqТFrТXwrwrqТF rТXwrwrН ЛО.MwrwrwrП@Н ЛО,іqrwrqrН ЛО)WqrП9НЇО& Т▀Т▄ПDqrНЇО$aТшqrП-ТэНЇО"╨НЇОдwНЇОuqrwrТ·wrwrТ÷wrqrwrwrНЇОнqrТqrwrwrwrН ЛОSqТFrwrТXwrqrwrqТFrТXНЇОьН ЛО]wrw rwrqrwrН'сqrwrqТFrН ЛОІwrw rН'с ╗Їo>ГX°┘Cedar 7T10 Changes4The following situations correspond to the three cases enumerated in the definition of ISTYPE above:(1) NARROW[x, T] is guaranteed (at compile time) to succeed.(2) NARROW[x, T] may succeed or fail at run time.(3) NARROW[x, T] is unimplemented.Case (2) arises only when the syntactic type of x is related to T in one of the ways described abovefor ISTYPE. In Cedar 7T10, case (3) is treated as a compile-time type error. Fine point: NARROW[x, T]is also considered a compile-time error if the only possible value of x yielding TRUE is NIL. Use x = NIL instead.In case (1), NARROW is an identity operation but can be useful to change the (syntactic) type of xwithout using a LOOPHOLE or requiring any code to be executed. Example:Defs: DEFINITIONS = { T: TYPE; R: TYPE = RECORD [g: REF T, ... ]; Pn: PROC [r: REF R]; ... }.Impl: PROGRAM EXPORTS Defs = { T: PUBLIC TYPE = RECORD [n: NAT, ...]; Pn: PUBLIC PROC [r: REF Defs.R] = { r.g.n _ 0; -- invalid; r.g^ is opaque, with no field selection operations NARROW[r.g, REF T].n _ 0;-- valid (because Impl exports Defs) ...}; }.As before, NARROW[x, T] may be written as NARROW[x] when the target type T is implied bycontext.Discriminating SelectionThe syntactic form of WITH ... SELECT that is currently used for REF ANY discrimination has beenextended to discriminate any value for which ISTYPE performs a dynamic test of that value (see case(2) in the discussion of ISTYPE). The formWITH v SELECT FROM v1: T1 => s1; v2: T2 => s2; ... vn: Tn => sn; ENDCASE => se;is, by definition, equivalent tou: T = v;IF u # NIL AND ISTYPE[u, T1] THEN {v1: T1 _ NARROW[u]; s1}ELSE IF u # NIL AND ISTYPE[u, T2] THEN {v2: T2 _ NARROW[u]; s2} ...ELSE IF u # NIL AND ISTYPE[u, Tn] THEN {vn: Tn _ NARROW[u]; sn}ELSE se;where T is the (syntactic) type of v. The tests against NIL are omitted if T does not have a NILvalue.НЇОfЯvТНGОНЇОbrТ│П#Т┌П4qrН ЛО_ёТXqrwrwrП-Н ЛО]ШqrwrwrП"Н ЛО\TqrwrwrНЇОYыТ┴Т┼wrwrП#НЇОX2Т┬qrПEtqtxtxtНЇОVўТ÷П.Т═xt qtqtxtqtНЇОS┌rТ·qrПJТ÷wНЇОQшrТqrП0Н ЛОO`wrТXq rН ЛОM╧wrqrН ЛОLwrqrqrwrqrwrН ЛОJjwrqrwrqrwrН ЛОHцН ЛОFHwrqТFrТXwrН ЛОD═wrqТF rТXqrwrqrН ЛОBЫwrqТF rТXwrqrwrН ЛОARwrwrwrН лwrwrП/Н ЛО?╙qrwrwrqrwrwrН лwrwrН ЛО> Н ЛО<\НЇО9 Тн Тоqrwrwrqrwrwr НЇО7fНЇО2pwТXНЇО/!rТ╛qrqrТґНЇО-zТ├Т┤qrП0НЇО+рТqrН ЛО){qrТXwrqТFН ЛО'ВrТXwrwrwrН ЛО&swrwrwrН ЛО$НqН ЛО#jrwrwrwrН ЛО!ФqrwrНЇО≤ТН ЛО@wrТXwrwrН ЛО╪qТFwrТXqТFwrТXwrqrwrwrqrwrwrН ЛО8qТFwrТXqТFwrТXwrqrwrwrqrwrwrН ЛОЄqН ЛО0ТFwrТXqТFwrТXwrqrwrwrqrwrwrН ЛО╛qТFwrНЇО1Т╟wrwrqrwrТ╠qНЇО┴rvЇB=ГWиЩCedar 7T10 Changes5Note that this form always copies the discriminated value. Thusr: REF V;. . .WITH r SELECT FROM x: REF V[a] => { ... x ...};-- x is a copy of r with type REF V[a] ... ENDCASE;WITH r^ SELECT FROM x: V[a] => { ... x ...};-- x is a copy of r^ with type V[a] ... ENDCASE;Contrast these with the old form of variant record discrimination, which does not copy thediscriminated value and reevaluates the discriminating expression each time that it is used:WITH x: r SELECT FROM a => { ... x ... };-- x is a synonym for r^ (but with syntactic type V[a]) ... ENDCASE;The new forms are easier to make type-safe, and you should use them whenever possible.Unfortunately, the old form is still required, at least outside the checked language, for dealing with computed variantsand with pointers having non-standard dereferencing operations, such as the current relative pointers).Interaction with Opaque TypesIf T is any exported type, REF T must have the "standard" implementation of type discrimination.We impose this requirement in anticipation of making REF ANY discrimination work correctly withopaque types (it still doesn't in 7T10). As a consequence, discriminated variant record types cannotbe exported as the concrete values of opaque types.Object NotationThe form x.Op[args] is interpreted as Defs.Op[x, args] if the type of x is (REF | POINTER TO)* Tfor some opaque type T declared in an interface, the principal instance of which is Defs. In otherwords, all the operations defined in Defs become part of the cluster of the type T.This convention applies within the corresponding DEFINITIONS module (for writing inlines, etc.) aswell as within importers of such modules. This is only a notational extension; the bindings ofimplicitly imported values are determined as before.The clustering mechanism has also been extended in Cedar so that all operations declared in aninterface become components of the clusters of any record types defined in that interface. With thisextension, Op can be inline in more interesting ways. In addition, you may now be able to useobject notation more extensively to invoke operations in existing interfaces, many of which arewritten in terms of (concrete) record types.Note that every operation declared in an interface module becomes part of the cluster of every(record or opaque) type declared in that interface. Although the type of a particular operationnormally will make it a useful component of only one cluster, its name appears in every othercluster and potentially hides or precludes a more appropriate definition of that name for thatcluster. You therefore should define more than one main type per interface only if the sets ofmeaningful operation names for those types are disjoint.ЪНЇОfЯvТНGОНЇОbrП@Н ЛО_фwrТXqrwrН ЛО]▓qТFН ЛО[]rТXwrqТFН ЛОYыrТXwrqrwrwr wrН▐wr wr qrwrwrН ЛОXUqН ЛОVяrqrН ЛОTyqrwrqТF Н ЛОRУrТXwrwrwr wrНwr wr wrН ЛОQqqН ЛОOМrqrНЇОL·ТНП2ТОП(НЇОJВТП\Н ЛОH|qrТXwrqrqН ЛОFуrwr wrНеwrwrwrwrН ЛОE-qН ЛОC├ТFrТXqrНЇОAТЫП+ТЗП+НЇО?┤tТ÷ПfТ═НЇО>&ТПgНЇО9TwТXНЇО6rТ wrТ⌡qrwrП@НЇО4^Т²Т·qrП#НЇО2ІТ┼ПIТ▀НЇО1ТП3НЇО,МvТXНЇО)·rТ░ wrwrwrТ▒wrwrwrwrwrqrq rwНЇО'ВrТ∙wrП(Т√wr НЇО&OТП%wrП(wНЇО#rТ╚П1q rТ╛П&НЇО!YТЎТ©ПGНЇО╡ТП4НЇОcТ╠Т╡ПBНЇО╪Т│П.Т┌П7НЇОТґ wrП>ТўНЇОmТхТиПPНЇОфТП,НЇОwТ╩Т╪ПEНЇОпТҐП`НЇО)ТюПQТаНЇО │ТтП1ТуП-НЇОзТЇП8Т╦П'НЇО 3ТП8 ьЇ Л>Г^≥Cedar 7T10 Changes6Other points to note when using this convention with record types include the following:In determining the binding of Op, the field identifiers declared in T take precedence over theidentifiers declared in the interface Defs.A value x with a record type T having a single component can be coerced to a value with thetype of that component. In the form x.id, the lookup of id considers first the field identifier ofthe single component, then identifiers declared in the interface defining T, and finally anyinterpretation given to id by applying the coercion. You abuse this feature at your own risk(but see the discussion of clusters above). Example:Defs1: DEFINITIONS = { ... T1: TYPE = RECORD [f1: REF Defs2.T2]; ... OpN: PROC [self: T1, ...]; ...}.Defs2: DEFINITIONS = { ... T2: TYPE = RECORD [ ... ]; ... OpM: PROC [self: REF T2, ...]; OpN: PROC [self: REF T2, ...]; ...} r1: Defs1.T1; r2: REF Defs2.T2; ... r1.OpN[...] means Defs1.OpN[r1, ...]-- from the cluster defined by Defs1 ... r1.OpM[...] means Defs2.OpM[r1.f1, ...]-- from the cluster defined by Defs2 (after coercion) ... r2.OpN[...] means Defs2.OpN[r2, ...] ... r1.f1.OpN[...] means Defs2.OpN[r1.f1, ...]-- dubious stylePredeclared TypesTo support the currently recommended Cedar standards, the types BOOL, INT and CHAR arepredeclared, with the following definitions: BOOL: TYPE = BOOLEAN; CHAR: TYPE = CHARACTER; INT: TYPE = LONG INTEGER;Also, the definition of the predeclared type CONDITION has been changed. The default value forthe timeout interval now is effectively infinite; i.e., a WAIT on a condition variable with defaultinitialization will never time out. (The previous default provided a timeout after 100 ticks.) Use aruntime procedure such as Process.SetTimeout to change the default setting.Rope LiteralsThe Cedar language now provides rope literals. Such a literal is denoted by a quoted string, e.g.,"This is a rope literal". Its value is a reference to a rope object in the standard (counted) zoneprovided by the Cedar system.The target type established by the context in which a quoted string literal appears determines theinterpretation of that literal. There are three cases:НЇОfЯvТНGОНЇОbrПXН ЛО^РТ╒ТёwrП$wrН ЛО]nТП&wrН ЛОZCТ≥wrwrТ П-Н ЛОX©Т▌П%wrwrТ▐wrП(Н ЛОW;Тя ТрП@wrН ЛОUЇТўwrТ╞П@Н ЛОT3ТП5Н ЛОQwrТXq rН ЛОO┐Н ЛОMЪwrqrqrwrqrwrwrН ЛОL{Н ЛОJВwrqrwrwrН ЛОIsН ЛОFkwrq rН ЛОDГН ЛОCcwrqrqrН ЛОAъН ЛО@[wrqrwrqrwrН ЛО>вwrqrwrqrwrН ЛО=SН ЛО:KwrwrwrН ЛО8фwrqrwrwrН ЛО5ЎwrwrwrwrwrН){wН ЛО4:rwrwrwrwrwrwrН){wrН ЛО2ІwrwrwrwrwrН ЛО12wrwrwrwrwrwrwrН){НЇО-vНЇО)ДrТЎП*Т©wrwrwrНЇО(`ТП,Н ЛО%5ТXwrqrwrН ЛО#╠wrqrwrН ЛО"-wrqrqrwrНЇОТ┬Т┴wrП)НЇО}ТюП:qrП%НЇОЫТ▒ПMТ▓НЇОuТwrw rНЇОSvТXНЇОrТ²П$Т·П?НЇО]ТґП6ТўП-НЇОІТНЇОgТёТєПSНЇО юТП7╗Ї y=Г]▓÷Cedar 7T10 Changes7If the target type is Rope.ROPE, Rope.Ref or Rope.Text, the quoted string denotes a rope literaland has type Rope.Ref.If the target type is any other REF type, the literal has type REF TEXT.Otherwise, the literal has type STRING.In the first case, the test is actually for equivalence between the target type and either REF Rope.RopeRep or REFRope.TextRep. The matching is performed on the names of the interface (Rope) and referent type (RopeRep or TextRep),not on the structure of the referent type. Since this is a loophole in the type checking, use nonstandard versions of theRope interface very cautiously.Escape Convention for LiteralsCedar provides an escape convention to allow denotations of nonprinting characters in character andstring literals (cf. the escape convention for the language C). The escape character is \, and thefollowing codes are recognized: Code Interpretation\n, \N, \r, \RAscii.CR\t, \TAscii.TAB\b, \BAscii.BS\f, \FAscii.FF\l, \LAscii.LF-- note that \n = LF in C\ddddddC-- where d is an octal digit, ddd < 377B\\\\''\""Anything else following a \ is an error.You can use the escape convention in character literals (e.g., '\n or '\032) or string literals (e.g.,"abc\ndef").APPLY and RETURNCedar is based upon a model of interprocedural control transfer in which the construction of anargument record is clearly separated from the actual transfer of control. In the usual forms forspecifying call or return, however, these operations are syntactically indivisible. There are nowalternative syntactic forms that allow you to invoke transfer operations using already constructedargument records.This extension is not fully general. The existing record must have a type compatible with the type required by thetransfer operation, and the only types compatible with argument record types are other argument record types. Suchtypes are defined implicitly by the definitions of transfer types, and they are always anonymous. Thus you cannotdeclare variables having such types, nor can you construct values with such types unless the target type is established bya transfer operation of some sort. The operator APPLY is used to apply a value with some transfer type to an argument record. Thesyntactic form isCall ::=...|APPLY [ Expression , Expression ]|APPLY [ Expression , Expression ! CatchSeries ]The type of the first Expression must be some transfer type (i.e., a type built using PROC, SIGNAL,ERROR, PROCESS, PORT or PROGRAM), and the second Expression must have a record type asgood as the argument type required for the transfer (see below). The effect is to invoke the transferЪНЇОfЯvТНGОН ЛОbrТ┴Т┼wrwrwrwrwrwrП*Н ЛО`vТwrwrН ЛО]ШТXqrqТFrН ЛО[─ТXqrНЇОXUtТ╡П[qtТЁxtxtqНЇОVТxtxtТ─Т│xtxtxtНЇОU■Т▀ПZТ▄НЇОT3xtТНЇОP4vТXНЇОMrТ│Т┌ПRНЇОK└ТґПXТў НЇОJТН ЛОG┘ТXН°ОG.Ч#ОG┘НеНУОG.Ч5ОG┘ Н ЛОE Н лwrwН ЛОCcrН лwrwН ЛОA╪rН лwrwН ЛО@rН лwrwН ЛО>mrН лwrwН.зrН ЛО<фwН лwrН.зwrwryrН ЛО;Н лrН ЛО9wН лrН ЛО7пН лrНЇО5xП(НЇО2LТ╟П.Т╠П8НЇО0хНЇО,іzvТXzНЇО){rТ╞Т╟ПAНЇО'ВТ╣ТІПOНЇО&sТеП)ТфП9НЇО$НТ╦П&Т╧П<НЇО#jТНЇО btТ╘ПEТ╙П.НЇО%ТіПFТїП-НЇОГТ╣ПbТІНЇО╙Т▄ПzНЇОlТП#НЇОdrТ qrП4Т⌡НЇОЮТН ЛОe{rТXНеН лНеОЎН лqr{ r{ rНеОН лqr{ r{ r{ rНЇО КТ┘{ rТ├qrqrНЇОgqrТЎqrqrqr{ rНЇО ЦТ│ Т┌П[ dЇ °=Г]o║Cedar 7T10 Changes8operation appropriate to the type of the first Expression, i.e., to call a procedure, raise a signal,join a process, etc. The scope of the optional catch phrase is just the transfer itself.Note that the first Expression implies a target type for the second, which can be (but normallywould not be) a constructor. For example,p[x, y]can be written asAPPLY[p, [x, y]]q[x]can be written asAPPLY[q, [x]] -- not APPLY[q, x]The corresponding forms for returning an existing record areReturnStmt ::=...|RETURN Call|RETURN ( Expression )ResumeStmt ::=...|RESUME Call|RESUME ( Expression )In these forms, the required type is established by the context in which the statement appears. Thetype of the Call or Expression must be a record type as good as the result type of the procedurebody in which the ReturnStmt appears (or of the catch phrase in which the ResumeStmtappears).An argument record type T1 is as good as an argument record type T2 if both of the followingconditions are satisfied:T1 and T2 have the same number of fields, say n.For each i, 1 < i < n, the type of the i-th component of T1 is as good as the type of the i-thcomponent of T2; in addition, if both these components are named, the names are identical (i.e.,names of field selectors must match, but an anonymous component matches any namedcomponent). Note that this rule is more liberal than the rule for explicitly declared record types.In the terminology of the Mesa 5 manual, T1 is as good as T2 iff T1 conforms freely to T2; e.g., [0..10) is as good as[0..100). In the new view of types, we would say that T1 is as good as T2 iff the predicate for T1 implies the predicatefor T2.In Cedar 7T10, the constructs described above do not work for empty argument records; i.e., you cannot nest applicationsof procedures taking/returning nothing.Examples:P1: PROC [x, y: INT] RETURNS [m, n: INT] = {...};P2: PROC [m, n: INT] RETURNS [u, v: INT] = {...};P3: PROC [a, b: INT] RETURNS [u, v: INT] = { RETURN APPLY[P2, P1[a, b]]};i, j: INT;. . .[i, j] _ APPLY[P2, IF i < j THEN P1[i, j] ELSE [j, i]];[i, j] _ APPLY[P3, [0, 0] ! s => {GOTO L}]; -- [i, j] _ P3[0, 0 ! s => {GOTO L}]ЪНЇОfЯvТНGОНЇОbrТ═П/{ rП"Т║ НЇО` ТПYНЇО]nТё{ rП0ТєНЇО[ЙТП*Н ЛОYowrwrТXwrНЎН лqrwrwrwrН ЛОWхwrwrНЎН лqrwrwrН.зqrwrwrНЇОT²ТП<Н ЛОR"{ rТXНеН лНеОPzН лqr{НеОNсrН лqr{ rН ЛОLX{ rНеН лНеОJ╠Н лqr{НеОI rН лqr{ rНЇОEчТ┬Т┴ПUНЇОDZ{r{ rТ┼ПBНЇОBжТм{ rТн{ НЇОARrНЇО>&Т╡ ТЁwО=≥tО>&rП'wО=≥tО>&rНЇО<\ТН ЛО9АwО9TtО9АrТXwО9TtО9АrП%wrН ЛО7┴Т⌠wryrwryrТ■wrwrwО6ЭtО7┴rwrН ЛО5ЎТ└wО51tО5ЎrП2Т┘Н ЛО3ТТВП$ТЬП-Н ЛО2LТНЇО/УПWНЇО-юtТ▓П)xО-3tО-ю Т⌠xО-3tО-юxО-3tО-юxО-3tО-юНЇО,Т┤П7xО+▄tО, Т┬xО+▄tО,xО+▄tО,НЇО*rТxО)ЕtО*rНЇО(`Т│ПUТ┌П#НЇО'#ТП'НЇО$wН ЛО!═rТXqrwrwrwrqrwrwrwr Н ЛО%wrqrwrwrwrqrwrwrwr Н ЛО╙wrqrwrwrwrqrwrwrwrН ЛОqrqrwrwrwrwrН ЛО┤wrwrqrН ЛОЮН ЛО9wrwrqrqrwrwrqrwrwrwrqrwrwrН ЛО▒wrwrqrwr wrqrwrН.зwrwrwrwrqrwrЪzЇJ=ГTаCedar 7T10 Changes9COMPILER CHANGESVersion StampsIn its intermodule type checking, Cedar uses so-called version stamps to identify independentlycompiled modules. The version stamps computed by the Cedar 7T10 compiler are functions of theidentity of that compiler and of its inputs. You can now recompile the same source file, with thesame included modules, the same compiler and the same switch settings to get an object file withthe same version stamp.This stamp, which is essentially a 48 bit hash, is computed recursively as follows. Assume that anyexisting derived object (including the compiler itself) has a version stamp. The stamp for a newderived object is a hash ofthe creation time of the source filethe version stamp of each bcd mentioned in the DIRECTORY clausethe version stamp of the compilerthe compiler switches (with those controlling only compile-time feedback masked off)There is also a 7T10 binder that computes version stamps for its output in the same way.NoteIn the past, the version stamp has been a concatenation of a machine identifier and the creationtime of the derived object. Many existing utility programs therefore print the version stampformatted as a machine and network number, a date and a time. These programs give strange-looking output but, in all cases known to us, perform correctly.Tioga Source FilesThe compiler and binder ignore text in Tioga trailers. Any occurrence of a pair of NUL characters(characters with value 0C) in a source file marks the logical end of that source file.File LockingThe Cedar 7T10 compiler is designed to be run under control of the system modeller. It alsoexports an interface allowing it to be run from Tajo or from the temporary Cedar executive. Whenit is run in this mode, the (rather minimal) facilities in PreCascade for obtaining exclusive access toa file are bypassed. Use caution.Compiler SwitchesThe Cedar compiler is no longer able to generate object code for an Alto (or D-machine emulatingan Alto). The switches /a and /l are ignored.There is a Cedar switch /c; if it is set (the default), the code for FORK assumes the availability ofthe Cedar runtime. If you plan to run your program directly under Pilot, compile with /-c. Ifyou are in doubt about how your processes will interact with the Cedar runtime, consult a wizard.ЪНЇОfЯvТНGОНЇОbТXНЇО]Ш НЇОZґrТгП>ТхП!НЇОYТ█ПMТ▌НЇОW^Т ПCТ⌡НЇОUЇТ═П5Т║П+НЇОTТНЇОPаТ▌П"Т▐ПBНЇОOТ╚П;Т╛П&НЇОMrТН ЛОJGТXП$Н ЛОHцП/qrН ЛОG?П!Н ЛОE╩ПTНЇОB▐ПXНЇО?dwНЇО<ИrТґП'ТўП9НЇО;AТэП2ТщП+НЇО9 ТЄП1Т╣П*НЇО7СТП@НЇО3пvТXНЇО0╔rТ┼П,Т▀П6НЇО/!ТПVНЇО*ЪvТXНЇО'сrТЎП)Т©П3НЇО&OТ┬ПJТ┴НЇО$кТ█Т▌ПbНЇО#GТП"НЇО%vТXНЇОжrТ█Т▌ПNНЇО/Т|r|rНЇОЮТ≥|r Т qrНЇО9Т╔П"ТіП5|rНЇО▒Т≥Пa ЇJ=ГTаЖ TIMESROMAN HELVETICA TIMESROMAN LOGO TIMESROMAN HELVETICA TIMESROMAN TIMESROMAN TIMESROMAN MATH HELVETICA HELVETICA GACHA м S{g%a,_4Т< BЪЪj/E C≤J3╧ЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪЪCedar7T10.bravo SatterthwaiteDecember 18, 1981 10:08 AM