Astrobe Forum

• The range of values for INTEGER, REAL and LONGREAL are not prescribed.
• LONGREAL and REAL may be identical

• There is no longer any distinction between a character constant and a string constant containing a single character. Both are enclosed in double-quotes.
• Single-character strings can be assigned to variables of type CHAR.
• Single-quotes can no longer be used as an alternative for double-quotes for string constants.
• Strings can be assigned to any array of characters, provided the number of characters in the string is not greater than that of the array. If it is less, a null character is appended. (i.e. a null character is no longer always present).
• The character set is a standard character set but is not necessarily Latin-1.

• CASE labels can be single-character strings. The selector is CHAR.

• INCL, EXCL are reintroduced from the original version of Oberon for including / excluding an element in a SET
• SHORT and LONG are reintroduced for converting LONGREAL to REAL and vice versa.
• FLOOR can be used with LONGREALs as well as REALs.
• LSR has been replaced by ROR.
• ORD can be used with a SET as a parameter
• ABS can no longer be used with a SET as a parameter

I think the elimination of single quote string delimiters is unfortunate

(there is no \" convention for including double quotes in a string).

Is ORD now the way to determine the number of elements in a set? (The report states that it returns the "ordinal", whatever that is.)

kevinhely wrote:I think the elimination of single quote string delimiters is unfortunate (there is no \" convention for including double quotes in a string).

because they are easier to type in the US keyboard layout

It is also interesting to note the asymmetry between the types CHAR and String

MODULE CharString3;

IMPORT Out, Main, Strings;

CONST
  quotes = 22X;

TYPE
  String = ARRAY 255 OF CHAR;
  
VAR
  s: String;
  (* ch: CHAR; Correction: *)
  ch: ARRAY 1 OF CHAR;

PROCEDURE Substitute(newCh, oldCh: CHAR; VAR s: ARRAY OF CHAR);
VAR
  i: INTEGER;
BEGIN
  i := 0;
  WHILE (i < LEN(s)) & (s[i] # 0X) DO 
    IF s[i] = oldCh THEN s[i] := newCh END;
    INC(i)
  END;
END Substitute;


PROCEDURE ProcessEscapes(VAR s: ARRAY OF CHAR);
BEGIN
  (* Replace '\\' with '\' 
             '\q' with '"' 
    This is an exercise for the reader ....
  *) 
END ProcessEscapes;
  

BEGIN

(* Ex.1 *)  
  Out.String("\q = "); Out.Char(quotes); Out.Ln;
  
(* Ex.2 *)   
  s := "\q = ?";
  s[5] := quotes;
  Out.String(s); Out.Ln;

(* Ex.3 *)
  s := "\q = ?";
  Substitute(quotes, "?", s);
  Out.String(s); Out.Ln;

(* Ex.4 *)
  s := "\q = ";
  Strings.Append(quotes, s);
  Out.String(s); Out.Ln;

(* Ex.5 *)
  s := "\q = ";
  ch := quotes;
  Strings.Append(ch, s);
  Out.String(s); Out.Ln;

(* Ex.6 *)
  s := "\\q = \q";
  ProcessEscapes(s);
  Out.String(s); Out.Ln
    
END CharString3.

\q = '
\q = '
\q = '
\q = '
\q = '
\\q = \q

PROCEDURE Append*(src: ARRAY OF CHAR; VAR dest: ARRAY OF CHAR);

it is a central property of Oberon-07 that each literal constant (and expression) has a unique and unambiguous type

VAR
   char: CHAR;
   charString: ARRAY 1 OF CHAR;
   string: ARRAY 2 OF CHAR;

char := "X";
charString := "X"; (* Identical to charString[0] := "X"; *)
string := "X";     (* Identical to string[0] := "X"; string[1] := 0X; *)
string := "XX";    (* Identical to string[0] := "X"; string[1] := "X"; *)

CASE char OF
  "X": .....