PLACE |

spec |

solutions |

Oberon |

The program is written in Oberon-2, currently the most widely implemented version of the language. It is contained in a module, which is the compilation unit in Oberon. The very first line is a pseudo-comment marking the module's body as an entry point of a (the) program's execution.

The module's body, which is the main part of the program (near its end) calls the procedure `readln`

to obtain a text line from the standard input. The line is stored in a dynamically allocated buffer pointed to by `p`

. If non-empty, it is processed by the function `evalrpn`

, which returns `TRUE`

or `FALSE`

to distinguish a successfully computed RPN expression from one that turns to be syntactically erroneous.

As Oberon has no standard library and no built-in I/O facilities, for communicating with the console the program makes use of the modules `In`

and `Out`

, defined in the so called ‘*Oakwood guidelines for Oberon-2*’. Among other things, the said document provides, albeit unofficially, a ‘standard’ library for the language which is indeed present in most Oberon-2 implementations.

The `readln`

procedure accepts the input a character at a time. Tab characters (`09X`

) are changed to spaces. If the size of the current input buffer becomes insufficient, a twice as large buffer is allocated, the contents of the current buffer are copied into it, and `p`

is pointed at the new buffer, while the old one gets garbage-collected. Upon end-of-line, which is signified by the character `0AX`

(ASCII Line Feed), the procedure returns. It is made sure that if only whitespace was input, the character count `nc`

is 0, so that the main program knows that the line was empty. If no more input at all is available (`In.Done`

is false), the built-in procedure `HALT`

is called to terminate the program. Note that the loop in the main program is itself infinite: it is `readln`

through calling `HALT`

that ensures the program's termination.

The function procedure `evalrpn`

extracts tokens in sequence, examines each one to determine whether it is an arithmetic operator or a number, and takes corresponding actions. It maintaines a stack `stk`

in which it places the numeric value of a token or the result of an operation. The stack is a dynamically allocated array of sufficiently large size, based on the length of the input line being processed. The array is being reused across invocations of `evalrpn`

for different RPN expressions: a new array is only allocated when there is a risk that the current one is not large enough to accomodate the amount of intermediate values for some new expression.

The individual tokens are not actually being extracted in `evalrpn`

. A ‘token’ is just a portion of the character sequence pointed at by `p`

, starting at position `i`

and ending at position `j-1`

in that sequence. The function procedure `getNumber`

which tells `evalrpn`

whether a token is a number and computes that number, being local to `evalrpn`

uses the values of `i`

and `j`

directly rather than receiving them as parameter values. `getNumber`

processes a token by accumulating a numeric value from the digits in it and accounting for whether and where there are a decimal dot and an arithmetic sign. The result is stored in the `evalrpn`

's variable `x`

. That variable's value eventually gets stored onto the stack as `evalrpn`

calls `push`

(which also happens with `x`

being the result of an arithmetic operator evaluation).

For character sequences that do not parse as numbers `getNumber`

returns `FALSE`

, which `evalrpn`

re-sends to its own caller. `evalrpn`

also returns `FALSE`

if `stk`

lacks one or both needed arguments for an arithmetic operator, or if it stores more than one number when the expression evaluation ends. Thus all cases of incorrect RPN expression syntax are properly detected and the main program gets informed that the expression evaluation failed.

As Oberon descends from Pascal, it is not unreasonable to draw parallels between the implementations of the RPN calculator in the two languages. In several ways the one in Oberon is simpler and its structure better reflects the problem than that in Pascal, due to the higher expressive level of the more recent language. Still, the two programs are of very similar size, in fact being among the largest in this collection. The level of verbosity seems to have somehow remained constant through the evolution of Pascal.

<* MAIN+ *> MODULE rpn; IMPORT In,Out; TYPE PString = POINTER TO ARRAY OF CHAR; VAR p: PString; stk: POINTER TO ARRAY OF REAL; bufsz,nc,stksz: INTEGER; PROCEDURE readln; VAR c: CHAR; i: INTEGER; q: PString; BEGIN nc := 0; LOOP In.Char(c); IF ~In.Done THEN HALT(0) ELSIF c=0AX THEN RETURN ELSIF c=09X THEN c := " " END; IF (nc>0) OR (c#" ") THEN IF nc=bufsz THEN bufsz := 2*bufsz; NEW(q,bufsz); FOR i:= 0 TO nc-1 DO q^[i] := p^[i] END; p := q END; p^[nc] := c; INC(nc) END END END readln; PROCEDURE evalrpn(): BOOLEAN; VAR nstk,i,j: INTEGER; x,y: REAL; c: CHAR; PROCEDURE getNumber(): BOOLEAN; VAR k,s,dp: INTEGER; BEGIN s := 1; IF (c="+") OR (c="-") THEN IF c="-" THEN s := -1 END; INC(i) END; x := 0.; dp := -1; FOR k:=i TO j-1 DO CASE p^[k] OF "0".."9": x := 10*x+ORD(p^[k])-ORD("0") | ".": IF dp=-1 THEN dp := k ELSE RETURN FALSE END ELSE RETURN FALSE END END; k := j-i; IF dp>=0 THEN DEC(k) END; IF k=0 THEN RETURN FALSE END; IF dp>=0 THEN FOR k:=1 TO j-dp-1 DO x := x/10 END END; x := s*x; RETURN TRUE END getNumber; PROCEDURE push; BEGIN stk^[nstk] := x; INC(nstk) END push; PROCEDURE pop(): REAL; BEGIN DEC(nstk); RETURN stk[nstk] END pop; BEGIN (* evalrpn *) i := 1 + nc DIV 2; IF stksz<i THEN stksz := i; NEW(stk,stksz) END; nstk := 0; i := 0; LOOP WHILE (i<nc) & (p^[i]=" ") DO INC(i) END; IF i=nc THEN RETURN nstk=1 END; j := i; WHILE (j<nc) & (p^[j]#" ") DO INC(j) END; c := p^[i]; IF (j=i+1) & ((c="+") OR (c="-") OR (c="*") OR (c="/")) THEN IF nstk<2 THEN RETURN FALSE END; y := pop(); x := pop(); CASE c OF "+": x := x+y | "-": x := x-y | "*": x := x*y | "/": x := x/y END ELSIF ~getNumber() THEN RETURN FALSE END; push; i := j END END evalrpn; BEGIN (* main *) bufsz := 100; NEW(p,bufsz); stksz := 0; In.Open; Out.Open; LOOP readln; IF nc>0 THEN IF evalrpn() THEN Out.Real(stk[0],0) ELSE Out.String("error") END; Out.Ln END END END rpn.

boykobbatgmaildotcom