9.5. What the Standard does not Say

An implementation might enforce a certain limit even though one is
not specified in the standard. This section tries to list most of
the places where this might be the case:

[The stack]
     (Also called: the external data queue) is not formally
     defined as a concept of the language itself, but a concept to
     which the REXX language has an interface. Several limits
     might apply to the stack, in particular the maximum length of
     a line in the stack and the maximum number of lines the stack
     can hold at once.

     There might also be also be other limits related to the
     stack, like a maximum number of buffers or a maximum number
     of different stack.  These concepts are not referred to by
     REXX, but the programmer ought to be aware of them.

[Files]
     May have several limits not specified by the definition of
     REXX, e.g. the number of files simultaneously open, the
     maximum size of a file, and the length and syntax of file
     names. Some of these limits are enforced by the operating
     system rather than an implementation.  The programmer should
     be particularly aware of the maximum number of simultaneously
     open files, since REXX does not have a standard construct for
     closing files.

[Expression nesting]
     Can in some interpreters only be performed to a certain
     level. No explicit minimum limit has been put forth, so take
     care in complex expressions, in particular machine generated
     expressions.

[Environment name length]
     May have some restrictions, depending on your operating
     system.  There is not defined any limit, but there exists an
     error message for use with too long environment names.

[Clause length]
     May have an upper limit. There is defined an error message
     “Clause too long” which is supposed to be issued if a clause
     exceeds a particular implementation dependent size. Note that
     a “clause” does not mean a “line” in this context; a line can
     contain multiple clauses.

[Source line length]
     Might have an upper limit. This is not the same as a “clause”
     (see above). Typically, the source line limit will be much
     larger than the clause limit. The source line limit ought to
     be as large as the string limit.

[Stack operations]
     Might be limited by several limits; first there is the number
     of strings in the stack, then there is the maximum length of
     each string, and at last there might be restrictions on the
     character set allowed in strings in the stack. Typically, the
     stack will be able to hold any character. It will either have
     “memory” as the limit for the number of string and the length
     of each string, or it might have a fixed amount of memory set
     aside for stack strings.  Some implementations also set a
     maximum length of stack strings, often 2*8 or 2*16.



 PREV   NEXT