Jeffery C.The implementation of Icon and Unicon.2004

175

runerr(111, &Arg1);

/*

* The returned result is the variable to which assignment is

* being made.

*/

Arg0 = Arg1; /*

*All the work is done by doasgn. Note that Arg1 is known

*to be a variable.

*/

if (!doasgn(&Arg1, &Arg2)) Fail;

Return;

}

Note that assignment may fail. This can occur as the result of an out­of­range assignment to &pos and is indicated by a returned value of 0 from doasgn.

Like dereferencing, assignment is trivial for variables that are not trapped. The routine doasgn begins as follows:

doasgn(dp1, dp2)

struct descrip *dp1, *dp2;

{

register word i1, i2; register union block *bp; register struct b_table *tp; int (*putf)();

union block *hook;

char sbuf1 [MaxCvtLen], sbuf2[MaxCvtLen]; extern struct descrip tended[];

extern struct b_lelem *alclstb(); extern char *alcstr();

tended[1] = *dp1; tended[2] = *dp2; ntended = 2; assign:

if (!Tvar(tended[1])) *VarLoc(tended [1]) = tended [2];

else switch (Type(tended[1])) {

An array of descriptors in the basis is used, since garbage collection may occur at various places in doasgn, and it is important to assure that the descriptors pointed to by dp1 and dp2 are processed properly by the garbage collector. The value of the global variable ntended specifies how many tended descriptors are in use at any time.

As for dereferencing, there are three types of trapped variables to be considered. Assignment to a substring trapped variable is rather complicated:

case T_Tvsubs: /*

*An assignment is being made to a substring trapped

*variable. The tended descriptors are used as

*follows:

*

*tended[1] -the substring trapped variable

*tended[2] -the value to assign

*tended[3] -the string containing the substring

177

alcstr(StrLoc(tended[3]) + i2, StrLen(tended[3]) -i2); /*

* Calculate the length of the new string. */

StrLen(tended[5]) = StrLen(tended[3]) - StrLen(tended[4]) + StrLen(tended [2]);

bp->tvsubs.sslen = StrLen(tended [2]); tended[1] = bp->tvsubs.ssvar; tended[2] = tended[5];

/*

*Everything is set up for the actual assignment. Go

*back to the beginning of the routine to do it.

*/

goto assign;

At the end of this case, no assignment has been made yet. Instead, tended[1] and tended [2] contain, respectively, the variable to which assignment is to be made and the value to be assigned. This is the same situation that exists at the beginning of the routine. The actual assignment is made by transferring back to the beginning. Note that, at this point, tended[1] may contain a trapped variable.

Table­element trapped variables have the same possibilities for assignment as for dereferencing. The processing is more complicated, since it may be necessary to convert a table­element trapped­variable block into a table­element block and link it into a chain:

case T_Tvtbl: /*

*

*The tended descriptors are used as follows:

*tended[1] -the table element trapped variable

*tended[2] -the value to be assigned

*tended[3] -subscripting value

*/

/*

*Point bp to the trapped-variable block, point

*tended[3] to the subscripting value, and point tp to

*the table-header block.

*/

ntended = 3;

bp = BlkLoc(tended[1]);

if (bp->tvtbl.title == T_Telem) { /*

*The trapped-variable block already has been

*converted to a table-element block. Just assign

*to it and return.

*/

bp->telem.tval = tended[2]; ntended = 0;

return 1;

}

tended[3] = bp->tvtbl.tref;

tp = (struct b_table *)BlkLoc(bp->tvtbl.clink); /*

*Get the hash number for the subscripting value and

*locate the chain that contains the element to which

178

* assignment is to be made. */

i1 = bp->tvtbl.hashnum;

i2 = SlotNum(i1, TSlots);

bp = BlkLoc(tp->buckets[i2]); /*

*Traverse the chain to see if the value is already in

*the table. If it is there, assign to it and return. */

hook = bp;

while (bp != NULL && bp->telem.hashnum <= i1) { if (bp->telem.hashnum == i1 &&

equiv(&bp->telem.tref, &tended[3])) { bp->telem.tval = tended[2];

ntended = 0; return 1;

}

hook = bp;

bp = BlkLoc(bp->telem.clink);

}

/*

*The value being assigned is new. Increment the table

*size, convert the table-element trapped-variable

*block to a table-element block, and link it into the

*chain.

*/

I ­>size++;

if (hook == bp) { /* it goes at front of chain */

.= BlkLoc(tended[1]); bp->telem.clink = tp->buckets[i2]; BlkLoc(tp->buckets[i2]) = bp; tp->buckets[i2].dword = D_Telem;

}

else { /* it follows hook */ bp = BlkLoc(tended[1]);

bp->telem.clink = hook->telem.clink; BlkLoc(hook->telem.clink) = bp; hook->telem.clink.dword = D_Telem;

}

bp->Mbl.title = T_Telem; bp->telem.tval = tended [2]; ntended = 0;

return 1;

In the case of a keyword trapped variable, the assignment routine that is pointed to from the keyword trapped­variable block is called to perform the assignment

case T_Tvkywd: ntended = 2;

putf = BlkLoc(tended[1])->tvkywd.putval; if ((*putf)(&tended[2]) == NULL) {

ntended = 0;

return 0; /* assignment fails */

}

ntended = 0; return 1;

180

Another example is

out := open("log", "a")

for which the value of out is

Note that the file status is 10, corresponding to being open for writing and appending. Closing a file, as in

close(out)

merely changes its file status:

12.3.2 Reading and Writing Data

The function read(f) reads a line from the file f. In UNIX, a line is just a string of characters up to a newline character. There is no limit on the length of a line and the length of a line cannot be determined before it is read. On the other hand, there must be a place to store the line. Consequently, a limit is placed on the length of a line that can be read by read(f). This limit is an implementation parameter, which is usually 2,048 characters.

Characters are read into a buffer until a newline character is encountered or the limit is reached. A predictive need request is then made to assure that there is enough space in the allocated string region for the string, and the string is copied from the buffer into the string region.

The function reads(f, i) reads i characters from the file f. These characters may include newline characters. There is no limit on i; since the maximum length of the string to be read is known before characters are read. A predictive need request can be made to assure

181

that there is enough space in the allocated string region. Characters are then read directly into the allocated string region without the use of an intervening buffer.

When strings are written, they are written directly from the allocated string region. There is no need to perform any allocation or to use an intermediate buffer.

Several strings can be concatenated on a file by

write(s1 , s2, ..., sn)

This avoids the internal allocation and concatenation that is required for

write(s1 || s2 || ...|| sn)

12.4 Diagnostic Facilities

Icon's diagnostic facilities consist of

●The function image(x), which produces a string representation of the value of x.

●The function display(f, i), which writes the names and values of identifiers in at most i levels of procedure call to the file f.

●Tracing of procedure calls, returns, resumptions, and suspensions.

●Run­time error termination messages.

Procedure tracing is done in invoke, pret, pfail, and psusp. If the value of &trace is nonzero, it is decremented and an appropriate trace message is written to standard error output. See Sec. 2.1.12 for an example.

The function display(f, i) must locate the names and values of local identifiers and arguments. The names are in the procedure block for the current procedure, which is pointed to by the zeroth argument of the current procedure call. The values are on the interpreter stack as described in Sec. 10.3.3.

Run­time termination messages are produced by the C routine runerr(n, dp), where dp is a pointer to the descriptor for the offending value. The value NULL is used for dp in cases where there is no offending value to print.

In all of these diagnostic situations, string representations of values are needed. The string representation for the" scalar" types string, cset, integer, and real is similar to what it is in the text of a source­language program. Long strings and csets are truncated to provide output that is easy to read. Other types present a variety of problems. For procedures, the type and procedure name are given.

A list, on the other hand, may be arbitrarily large and may contain values of any type, even lists. While the name may suffice for a procedure, often more information about a list is needed. As a compromise between information content and readability, only the first three and last three elements of a long list are included in its string representation. Since lists and other nonscalar types may be elements of lists, their representation as elements of a list is more restricted, witt only the type and size being shown.

Since trace, display, and error output are written to files, the string representations can be written as they are determined, without regard for how long they are. The function image (x), on the other hand, returns a string value, and space must be allocated for it. A more

182

limited form of string representation is used for nonscalar values, since the space needed might otherwise be very large.

EXERCISES

12.1It is possible to conceive of meaningful ways to convert any type of data in Icon to any other. For example, a procedure might be converted to a string that consists of the procedure declaration. How would such a general conversion feature affect the way that types are converted in the run­time system?

12.2On computers with 16­bit words, Icon has two representations for integers internally (see Sec. 4.1.3). Describe how this complicates type conversion.

12.3How would the addition of a new numeric type, such as complex numbers, affect type conversion?

12.4How big would MaxCvtLen be if Icon had 512 different characters? 128? 64?

12.5Suppose a large­integer type were added to Icon to allow arithmetic on integers of an arbitrarily large size.

* How would this affect the numerical conversion routines? * How "would this affect cvstr and the routines that call it?

12.6List all the source­language operations that perform assignment.

12.7The routine doasgn returns the value 0 if assignment cannot be made. This signal results in a failure return in the functions that call doasgn (see Sec. 12.2.2). Why not use Fail in doasgn?

12.8Assuming that x, y, z, and w all have string values, diagram the structures that are produced in the course of evaluating the following expressions:

x[y] := z z := x[y]

x[y] := z[w] x[y][z] := w

Repeat this exercise for the case where all the identifiers have tables as values.

12.9Give an expression in which a table­element trapped variable points to a table­ element block rather than to a table­element trapped­variable block.

12.10Give an expression in which a table­element trapped variable points to a table­ element trapped­variable block, but where there is a table­element block in the table with the same entry value.

12.11Why are tended descriptors needed in doasgn but not in deref?

12.12Show an expression in which, at the end of the case for assignment to a substring trapped variable, the variable to which the assignment is to be made is a trapped variable. Can such a trapped variable be of any of the three types?

12.13Why is the string produced by read(f) not read directly into the allocated string region?

12.14Are there any circumstances in which write(x1, x2, ..., xn) requires the allocation of storage?

183

12.15Identify all the portions of blocks for source­language values that are necessary only for diagnostic output. How significant is the amount of space involved?

12.16The use of trapped variables for keywords that require special processing for assignment suggests that a similar technique might be used for substring and table­ element trapped variables. Evaluate this possibility.

184

Part II: An Optimizing Compiler for Icon

by Kenneth W. Walker