1 .\" $Id: pcref.doc,v 1.10 1994/06/24 10:02:16 ceriel Exp $
2 .\" tbl pcref.doc | troff
3 .ds OF \\fBtest~off:~\\fR
4 .ds ON \\fBtest~on:~~\\fR
5 .ds AL \\fBtest~all:~\\fR
73 \\fB\\n(CH.\\n+(SH.~\\$1\\fR
120 .TL "Amsterdam Compiler Kit-Pascal reference manual"
121 .AU "Johan W. Stevenson"
122 .DA "January 4, 1983"
127 This document refers to the (1982) BSI standard for Pascal [1].
128 Ack-Pascal complies with the requirements of level 1 of BS 6192: 1982, with
129 the exceptions as listed in this document.
131 The standard requires an accompanying document describing the
132 implementation-defined and implementation-dependent features,
133 the reaction on errors and the extensions to standard Pascal.
134 These four items will be treated in the rest of this document,
135 each in a separate chapter.
136 The other chapters describe the deviations from the standard and
137 the list of options recognized by the compiler.
139 The Ack-Pascal compiler produces code for an EM machine as defined in [2].
140 It is up to the implementor of the EM machine to decide whether errors like
141 integer overflow, undefined operand and range bound error are recognized or not.
143 There does not (yet) exist a hardware EM machine.
144 Therefore, EM programs must be interpreted, or translated into
145 instructions for a target machine.
146 The Ack-Pascal compiler is currently available for use with the VAX,
147 Motorola MC68020, Motorola MC68000,
148 PDP-11, and Intel 8086 code-generators.
149 For the 8086, MC68000, and MC68020,
150 floating point emulation is used. This is made available with the \fI-fp\fP
151 option, which must be passed to \fIack\fP[3].
153 .CH "Implementation-defined features"
154 For each implementation-defined feature mentioned in the BSI standard
155 we give the section number, the quotation from that section and the definition.
156 First we quote the definition of implementation-defined:
158 Possibly differing between processors, but defined for any particular
162 Each string-character shall denote an implementation-defined value of the
165 All 7-bits ASCII characters except linefeed LF (10) are allowed.
168 The values of type real shall be an implementation-defined subset
169 of the real numbers denoted as specified by 6.1.5 bu signed real.
171 The format of reals is not defined in EM.
172 Even the size of reals depends on the EM-implementation.
173 The compiler can be instructed, by the V-option, to use a different
174 size for real values.
175 The size of reals is preset by the calling program \fIack\fP
176 [3] to the proper size.
179 The type char shall be the enumeration of a set of implementation-defined
180 characters, some possibly without graphic representations.
182 The 7-bits ASCII character set is used, where LF (10) denotes the
183 end-of-line marker on text-files.
185 The ordinal numbers of the character values shall be values of integer-type,
186 that are implementation-defined, and that are determined by mapping
187 the character values on to consecutive non-negative integer values
190 The normal ASCII ordering is used: ord('0')=48, ord('A')=65, ord('a')=97, etc.
193 The post-assertions imply corresponding activities on the external entities,
194 if any, to which the file-variables are bound. These activities, and the
195 point at which they are actually performed, shall be
196 implementation-defined.
198 The reading and writing writing of objects on files is buffered.
199 This means that when a program terminates abnormally, IO may be
200 unfinished. Terminal IO is unbuffered.
201 Files are closed whenever they are rewritten or reset, or on
204 The predefined constant maxint shall be of integer-type and shall denote
205 an implementation-defined value, that satisfies the following conditions:
209 (a)~All integral values in the closed interval from -maxint to +maxint
210 shall be values of the integer-type.
212 (b)~Any monadic operation performed on an integer value in this interval
213 shall be correctly performed according to the mathematical rules for
216 (c)~Any dyadic integer operation on two integer values in this same interval
217 shall be correctly performed according to the mathematical rules for
218 integer arithmetic, provided that the result is also in this interval.
220 (d)~Any relational operation on two integer values in this same interval
221 shall be correctly performed according to the mathematical rules for
225 The representation of integers in EM is a \fIn\fP*8-bit word using
226 two's complement arithmetic.
227 Where \fIn\fP is called wordsize.
228 The range of available integers depends on the EM implementation:
229 For 2-byte machines, the integers range from -32767 to +32767. For 4-byte
230 machines, the integers range from -2147483647 to 2147483647.
231 The number -maxint-1 may be used to indicate 'undefined'.
234 The result of the real arithmetic operators and functions shall be
235 approximations to the corresponding mathematical results. The accuracy of
236 this approximation shall be implementation-defined
238 Since EM doesn't specify floating point format, it is not possible to
239 specify the accuracy. When the floating point emulation is used, and the
240 default size of reals is 8 bytes, the accuracy is 11 bits for the exponent,
241 and 53 bits for the mantissa. This gives an accuracy of about 16 digits,
242 and exponents ranging from -309 to +307.
245 The default TotalWidth values for integer, Boolean and real types
246 shall be implementation-defined.
249 integer 6 for 2-byte machines, 11 for 4-byte machines
253 ExpDigits, the number of digits written in an exponent part of a real,
254 shall be implementation-defined.
256 ExpDigits is defined as 3. This is sufficient for all implementations
257 currently available. When the representation would need more than 3
258 digits, then the string '***' replaces the exponent.
260 The character written as part of the representation of
261 a real to indicate the beginning of the exponent part shall be
262 implementation-defined, either 'E' or 'e'.
264 The exponent part starts with 'e'.
266 The case of the characters written as representation of the
267 Boolean values shall be implementation-defined.
269 The representations of true and false are 'true' and 'false'.
271 The effect caused by the standard procedure page
272 on a text file shall be implementation-defined.
274 The ASCII character form feed FF (12) is written.
276 The binding of the variables denoted by the program-parameters
277 to entities external to the program shall be implementation-defined if
278 the variable is of a file-type.
280 The program parameters must be files and all, except input and output,
281 must be declared as such in the program block.
283 The program parameters input and output, if specified, will correspond
284 with the UNIX streams 'standard input' and 'standard output'.
286 The other program parameters will be mapped to the argument strings
287 provided by the caller of this program.
288 The argument strings are supposed to be path names of the files to be
290 The order of the program parameters determines the mapping:
291 the first parameter is mapped onto the first argument string etc.
292 Note that input and output are ignored in this mapping.
294 The mapping is recalculated each time a program parameter
295 is opened for reading or writing by a call to the standard procedures
297 This gives the programmer the opportunity to manipulate the list
298 of string arguments using the external procedures argc, argv and argshift
299 available in libpc [6].
301 The effect of an explicit use of reset or rewrite
302 on the standard textfiles input or output shall be implementation-defined.
304 The procedures reset and rewrite are no-ops
305 if applied to input or output.
306 .CH "Implementation-dependent features"
307 For each implementation-dependent feature mentioned in the BSI standard,
308 we give the section number, the quotation from that section and the way
309 this feature is treated by the Ack-Pascal system.
310 First we quote the definition of 'implementation-dependent':
312 Possibly differing between processors and not necessarily defined for any
313 particular processor.
316 The order of evaluation of the operands of a dyadic operator
317 shall be implementation-dependent.
319 Operands are always evaluated, so the program part
321 if (p<>nil) and (p^.value<>0) then
323 is probably incorrect.
325 The left-hand operand of a dyadic operator is almost always evaluated
326 before the right-hand side.
327 Some peculiar evaluations exist for the following cases:
331 the modulo operation is performed by a library routine to
332 check for negative values of the right operand.
340 where set1 and set2 are compatible set types is evaluated in the
350 test set2 and set2+set1 for equality
359 where set1 and set2 are compatible set types is evaluated in the following steps:
368 test set1 and set1+set2 for equality
372 The order of evaluation, accessing and binding
373 of the actual-parameters for functions
374 shall be implementation-dependent.
376 The order of evaluation is from right to left.
378 The decision as to the order of accessing the variable and evaluating
379 the expression in an assignment-statement, shall be
380 implementation-dependent.
382 The expression is evaluated first.
384 The order of evaluation and binding of the actual-parameters for procedures
385 shall be implementation-dependent.
387 The same as for functions.
389 The effect of inspecting a text file to which the page
390 procedure was applied during generation is
391 implementation-dependent.
393 The formfeed character written by page is
394 treated like a normal character, with ordinal value 12.
396 The binding of the variables denoted by the program-parameters
397 to entities external to the program shall be implementation-dependent unless
398 the variable is of a file-type.
400 Only variables of a file-type are allowed as program parameters.
403 There are three classes of errors to be distinguished.
404 In the first class are the error messages generated by the compiler.
405 The second class consists of the occasional errors generated by the other
406 programs involved in the compilation process.
407 Errors of the third class are the errors as defined in the standard by:
409 An error is a violation by a program of the requirements of this standard
410 that a processor is permitted to leave undetected.
412 .SH "Compiler errors"
413 Error are written on the standard error output. Each line has the form:
415 <file>, line <number>: <description>
417 Every time the compiler detects an error that does not have influence
418 on the code produced by the compiler or on the syntax decisions, a warning
420 If only warnings are generated, compilation proceeds and probably results
421 in a correctly compiled program.
423 Sometimes the compiler produces several errors for the same line. They are
424 only shown up to a maximum of 5 errors per line. Warning are also shown up
425 to a maximum of 5 per line.
427 Extensive treatment of these errors is outside the scope of this manual.
429 Errors detected at run time cause an error message to be generated on the
430 diagnostic output stream (UNIX file descriptor 2).
431 The message consists of the name of the program followed by a message
432 describing the error, possibly followed by the source line number.
433 Unless the -L-option is turned on, the compiler generates code to keep track
434 of which source line causes which EM instructions to be generated.
435 It depends on the EM implementation whether these LIN instructions
436 are skipped or executed.
438 For each error mentioned in the standard we give the section number,
439 the quotation from that section and the way it is processed by the
440 Pascal-compiler or runtime system.
442 For detected errors the corresponding message
443 and trap number are given.
444 Trap numbers are useful for exception-handling routines.
445 Normally, each error causes the program to terminate.
446 By using exception-handling routines one can
447 ignore errors or perform alternate actions.
448 Only some of the errors can be ignored
449 by restarting the failing instruction.
450 These errors are marked as non-fatal,
452 A list of errors with trap number between 0 and 63
453 (EM errors) can be found in [2].
454 Errors with trap number between 64 and 127 (Pascal errors) are listed in [7].
456 It shall be an error if a value of type T2 must be
457 assignment-compatible with type T1, while
458 T1 and T2 are compatible ordinal-types and the value of
459 type T2 is not in the closed interval specified by T1.
461 The compiler distinguishes between array-index expressions and the other
462 places where assignment-compatibility is required.
464 Array subscripting is done using the EM array instructions.
465 These instructions have three arguments: the array base address,
466 the index and the address of the array descriptor.
467 An array descriptor describes one dimension by three values:
468 the lower bound on the index, the number of elements minus one and the
470 It depends on the EM implementation whether these bounds are checked. Since
471 most implementations don't, an extra compiler flag is added to force these
474 The other places where assignment-compatibility is required are:
481 procedures read and readln
483 the final value of the for-statement
485 For these places the compiler generates an EM range check instruction, except
486 when the R-option is turned on, or when the range of values of T2
487 is enclosed in the range of T1.
488 If the expression consists of a single variable and if that variable
489 is of a subrange type,
490 then the subrange type itself is taken as T2, not its host-type.
491 Therefore, a range instruction is only generated if T1 is a subrange type
492 and if the expression is a constant, an expression with two or more
493 operands, or a single variable with a type not enclosed in T1.
494 If a constant is assigned, then the EM optimizer removes the range check
495 instruction, except when the value is out of bounds.
497 It depends on the EM implementation whether the range check instruction
498 is executed or skipped.
500 It shall be an error if a value of type T2 must be
501 assignment-compatible with type T1, while T1 and T2 are compatible
502 set-types and any member of the value of type T2
503 is not in the closed interval specified by the base-type
506 This error is not detected.
508 It shall be an error if a component of a variant-part of a variant,
509 where the selector of the variant-part is not a field,
510 is accessed unless the variant is active for the entirety of each
511 reference and access to each component of the variant.
513 This error is not detected.
515 It shall be an error if
516 the pointer-variable of an identified-variable either denotes a
517 nil-value or is undefined.
519 The EM definition does not specify the binary representation of pointer
520 values, so that it is not possible to choose an otherwise illegal
521 binary representation for the pointer value NIL.
522 Rather arbitrary the compiler uses the integer value zero to represent NIL.
523 For all current implementations this does not cause problems.
525 The size of pointers depends on the implementation and is
526 preset in the compiler by \fIack\fP [3].
527 The compiler can be instructed, by the V-option, to use
528 another size for pointer objects.
529 NIL is represented here by the appropriate number of zero words.
531 It depends on the EM implementation whether de-referencing of a pointer
532 with value NIL causes an error.
535 It shall be an error to remove the identifying-value of an identified
536 variable from its pointer-type when a reference to the variable exists.
538 When the identified variable is an element of the record-variable-list of
539 a with_statement, a warning is given at compile-time. Otherwise, this error
542 It shall be an error to alter the value of a file-variable f when a
543 reference to the buffer-variable f^ exists.
545 When f is altered when it is an element of the record-variable-list of a
546 with-statement, a warning is given. When a buffer-variable is used as a
547 variable-parameter, an error is given. This is done at compile-time.
549 It shall be an error if
550 the stated pre-assertion does not hold immediately
551 prior to any use of the file handling procedures
552 rewrite, put, reset and get.
554 For each of these four operations the pre-assertions
555 can be reformulated as:
557 rewrite(f):~no pre-assertion.
559 put(f):~~~~~f is opened for writing and f^ is not undefined.
561 reset(f):~~~f exists.
563 get(f):~~~~~f is opened for reading and eof(f) is false.
565 The following errors are detected for these operations:
570 more args expected, trap 64, fatal:
572 f is a program-parameter and the corresponding
573 file name is not supplied by the caller of the program.
575 rewrite error, trap 101, fatal:
577 the caller of the program lacks the necessary
578 access rights to create the file in the file system
579 or operating system problems like table overflow
580 prevent creation of the file.
586 file not yet open, trap 72, fatal:
588 reset or rewrite are never applied to the file.
589 The checks performed by the run time system are not foolproof.
591 not writable, trap 96, fatal:
593 f is opened for reading.
595 write error, trap 104, fatal:
597 probably caused by file system problems.
598 For instance, the file storage is exhausted.
599 Because IO is buffered to improve performance,
600 it might happen that this error occurs if the
602 Files are closed whenever they are rewritten or reset, or on
609 more args expected, trap 64, fatal:
611 same as for rewrite(f).
613 reset error, trap 100, fatal:
615 f does not exist, or the caller has insufficient access rights, or
616 operating system tables are exhausted.
622 file not yet open, trap 72, fatal:
626 not readable, trap 97, fatal:
628 f is opened for writing.
630 end of file, trap 98, fatal:
632 eof(f) is true just before the call to get(f).
634 read error, trap 103, fatal:
636 unlikely to happen. Probably caused by hardware problems
637 or by errors elsewhere in the program that destroyed
638 the file information maintained by the run time system.
640 truncated, trap 99, fatal:
642 the file is not properly formed by an integer
643 number of file elements.
644 For instance, the size of a file of integer is odd.
646 non-ASCII char read, trap 106, non-fatal:
648 the character value of the next character-type
649 file element is out of range (0..127).
653 It shall be an error if a variant of a variant-part within the new
654 variable becomes active and a different variant of the variant-part is
655 one of the specified variants.
657 This error is not detected.
659 It shall be an error to use dispose(q) if the identifying variable has been
660 allocated using the form new(p,c1,...,cn).
662 This error is not detected. However, this error can cause more memory
663 to be freed then was allocated.
664 Dispose causes a fatal trap 73 when memory already on the free
667 It shall be an error to use dispose(q,k1,...,km) if the identifying
668 variable has been allocated using the form new(p,c1,...,cn) and m is not
671 This error is not detected. However, this error can cause more memory
672 to be freed then was allocated.
673 Dispose causes a fatal trap 73 when memory already on the free
676 It shall be an error if the variants of a variable to be disposed
677 are different from those specified by the case-constants to dispose.
679 This error is not detected.
681 It shall be an error if the value of the pointer parameter of dispose has
682 nil-value or is undefined.
684 The same comments apply as for de-referencing NIL or undefined pointers.
686 It shall be an error if a variable created using the second form of new is
687 accessed by the identified variable of the variable-access of a factor,
688 of an assignment-statement, or of an actual-parameter.
690 This error is not detected.
692 It shall be an error if the value of sqr(x) does not exist.
694 This error is detected for real-type arguments (real overflow,
697 It shall be an error if x in ln(x) is smaller than or equal to 0.
699 This error is detected (error in ln, trap 66, non-fatal)
701 It shall be an error if x in sqrt(x) is smaller than 0.
703 This error is detected (error in sqrt, trap 67, non-fatal)
705 In addition to these errors, overflow in the expression exp(x) is
706 detected (error in exp, trap 65, non-fatal; real overflow, trap 4, non-fatal)
709 It shall be an error if
710 the integer value of trunc(x) does not exist.
712 It depends on the implementations whether this error is detected.
713 The floating-point emulation detects this error (conversion error,
716 It shall be an error if
717 the integer value of round(x) does not exist.
719 It depends on the implementations whether this error is detected.
720 The floating-point emulation detects this error (conversion error,
723 It shall be an error if
724 the integer value of ord(x) does not exist.
726 This error can not occur, because the compiler will not allow
729 It shall be an error if
730 the character value of chr(x) does not exist.
732 Except when the R-option is off, the compiler generates an EM
733 range check instruction. The effect of this instruction depends on the
736 It shall be an error if the value of succ(x) does not exist.
738 Same comments as for chr(x).
740 It shall be an error if the value of pred(x) does not exist.
742 Same comments as for chr(x).
744 It shall be an error if f in eof(f) is undefined.
746 This error is detected (file not yet open, trap 72, fatal).
748 It shall be an error if
749 f in eoln(f) is undefined, or if eof(f) is true at that time.
751 The following errors may occur:
753 file not yet open, trap 72, fatal;
755 not readable, trap 97, fatal;
757 end of file, trap 98, fatal.
760 It shall be an error if a variable-access used as an operand
761 in an expression is undefined at the time of its use.
763 The compiler performs some limited checks to see if identifiers are
764 used before they are set. Since it can not always be sure (one could, for
765 instance, jump out of a loop), only a warning is generated. When an
766 expression contains a function-call, an error occur if the
767 function is not assigned at run-time.
769 A term of the form x/y shall be an error if y is zero.
771 It depends on the EM implementation whether this error is detected. On some
772 machines, a trap may occur.
774 It shall be an error if j is zero in 'i div j'.
776 It depends on the EM implementation whether this error is detected. On some
777 machines, a trap may occur.
780 It shall be an error if
781 j is zero or negative in i MOD j.
783 This error is detected (only positive j in 'i mod j', trap 71, non-fatal).
785 It shall be an error if the result of any operation on integer
786 operands is not performed according to the mathematical
787 rules for integer arithmetic.
789 The reaction depends on the EM implementation. Most implementations,
790 however, will not notice integer overflow.
792 It shall be an error if none of the case-constants is equal to the
793 value of the case-index upon entry to the case-statement.
795 This error is detected (case error, trap 20, fatal).
797 It shall be an error if the sequence of characters read looking for an
798 integer does not form a signed-integer as specified in 6.1.5.
800 This error is detected (digit expected, trap 105, non-fatal).
802 It shall be an error if the sequence of characters read looking for a
803 real does not form a signed-number as specified in 6.1.5.
805 This error is detected (digit expected, trap 105, non-fatal).
807 When read is applied to f, it shall be an error if the buffer-variable f^
808 is undefined or the pre-assertions for get do not hold.
810 This error is detected (see get(f)).
812 When write is applied to a textfile f, it shall be an error if f is
813 undefined or f is opened for reading.
815 This error is detected (see put(f)). Furthermore, this error is also
816 detected when f is not a textfile.
818 The values of TotalWidth or FracDigits shall be greater than or equal to
819 one; it shall be an error if either value is less then one.
821 When either value is less than zero, an error (illegal field width, trap
822 75, non-fatal) occurs. Zero values are allowed, in order to maintain some
823 compatibility with the old Ack-Pascal compiler.
825 It shall be an error if the pre-assertion required for writeln(f) doe not
826 hold prior to the invocation of page(f);
828 This error is detected (see put(f)).
829 .CH "Extensions to the standard"
835 Except for the required directive 'forward' the Ack-Pascal compiler recognizes
836 the directive 'extern'.
837 This directive tells the compiler that the procedure block of this
838 procedure will not be present in the current program.
839 The code for the body of this procedure must be included at a later
840 stage of the compilation process.
842 This feature allows one to build libraries containing often used routines.
843 These routines do not have to be included in all the programs using them.
844 Maintenance is much simpler if there is only one library module to be
845 changed instead of many Pascal programs.
847 Another advantage is that these library modules may be written in a different
848 language, for instance C or the EM assembly language.
849 This is useful for accessing some specific EM instructions not generated
850 by the Pascal compiler. Examples are the system call routines and some
851 floating point conversion routines.
852 Another motive could be the optimization of some time-critical program parts.
854 The use of external routines, however, is dangerous.
855 The compiler normally checks for the correct number and type of parameters
856 when a procedure is called and for the result type of functions.
857 If an external routine is called these checks are not sufficient,
858 because the compiler can not check whether the procedure heading of the
859 external routine as given in the Pascal program matches the actual routine
861 It should be the loader's task to check this.
862 However, the current loaders are not that smart.
863 Another solution is to check at run time, at least the number of words
864 for parameters. Some EM implementations check this.
866 For those who wish the use the interface between C and Pascal we
867 give an incomplete list of corresponding formal parameters in C and Pascal.
878 procedure a(pars) struct {
882 function a(pars):type struct {
887 The Pascal runtime system uses the following algorithm when calling
888 function/procedures passed as parameters.
891 if ( static_link ) (*a)(static_link,pars) ;
896 Separate compilation.
898 The compiler is able to (separately) compile a collection of declarations,
899 procedures and functions to form a library.
900 The library may be linked with the main program, compiled later.
901 The syntax of these modules is
903 module = [constant-definition-part]
904 [type-definition-part]
905 [var-declaration-part]
906 [procedure-and-function-declaration-part]
908 The compiler accepts a program or a module:
910 unit = program | module
912 All variables declared outside a module must be imported
913 by parameters, even the files input and output.
914 Access to a variable declared in a module is only possible
915 using the procedures and functions declared in that same module.
916 By giving the correct procedure/function heading followed by the
917 directive 'extern' procedures and functions declared in
918 other units may be used.
924 When the s-option is off, Ack-Pascal compiler recognizes an additional
925 statement, the assertion. Assertions can be used as an aid in debugging
926 and documentation. The syntax is:
928 assertion = 'assert' Boolean-expression
930 An assertion is a simple-statement, so
932 simple-statement = [assignment-statement |
933 procedure-statement |
938 An assertion causes an error if the Boolean-expression is false.
939 That is its only purpose.
940 It does not change any of the variables, at least it should not.
941 Therefore, do not use functions with side-effects in the Boolean-expression.
942 If the a-option is turned on, then assertions are skipped by the
943 compiler. 'assert' is not a word-symbol (keyword) and may be used as identifier.
944 However, assignment to a variable and calling of a procedure with that
945 name will be impossible.
946 If the s-option is turned on, the compiler will not know a thing about
947 assertions, so using assertions will then give a parse error.
951 Additional procedures.
953 Three additional standard procedures are available:
957 halt:~~~a call of this procedure is equivalent to jumping to the
958 end of the program. It is always the last statement executed.
959 The exit status of the program may be supplied
960 as optional argument. If not, it will be zero.
964 mark:~~~for most applications it is sufficient to use the heap as second stack.
965 Mark and release are suited for this type of use, more suited than dispose.
966 mark(p), with p of type pointer, stores the current value of the
967 heap pointer in p. release(p), with p initialized by a call
968 of mark(p), restores the heap pointer to its old value.
969 All the heap objects, created by calls of new between the call of
970 mark and the call of release, are removed and the space they used
972 Never use mark and release together with dispose!
979 If the c-option is turned on, then some special features are available
980 to simplify an interface with the UNIX environment.
981 First of all, the compiler allows for a different type
983 These string constants are delimited by double quotes ('"').
984 To put a double quote into these strings, the double quote must be repeated,
985 like the single quote in normal string constants.
986 These special string constants are terminated by a zero byte (chr(0)).
987 The type of these constants is a pointer to a packed array of characters,
988 with lower bound 1 and unknown upper bound.
990 Secondly, the compiler predefines a new type identifier 'string' denoting
991 this just described string type.
993 These features are only useful for declaration of
994 constants and variables of type 'string'.
995 String objects may not be allocated on the heap and string pointers
996 may not be de-referenced.
997 Still these strings are very useful in combination with external routines.
998 The procedure write is extended to print these zero-terminated
1003 Double length (32 bit) integers.
1005 If the d-option is turned on, then the additional type 'long' is known
1007 By default, long variables have integer values in the
1008 range -2147483647..+2147483647, but this can be changed with the -V option
1009 (if the backend can support this).
1010 Long constants can not be declared.
1011 Longs can not be used as control-variables.
1012 It is not allowed to form subranges of type long.
1013 All operations allowed on integers are also
1014 allowed on longs and are indicated by the same
1015 operators: '+', '-', '*', '/', 'div', 'mod'.
1016 The procedures read and write have been extended to handle long
1017 arguments correctly. It is possible to read longs from a file of integers
1018 and vice-versa, but only if longs and integers have the same size.
1019 The default width for longs is 11.
1020 The standard procedures 'abs' and 'sqr' have been extended to work
1022 Conversion from integer to long, long to real,
1023 real to long and long to integer are automatic, like the conversion
1024 from integer to real.
1025 These conversions may cause a
1027 conversion error, trap 10, non-fatal
1032 Underscore as letter.
1034 The character '_' may be used in forming identifiers, if the u- or U-option
1035 is turned on. It is forbidden to start identifiers with underscores, since
1036 this may cause name-clashes with run-time routines.
1040 Zero field width in write.
1042 Zero TotalWidth arguments are allowed. No characters are written for
1043 character, string or Boolean type arguments then. A zero FracDigits
1044 argument for fixed-point representation of reals causes the fraction and
1045 the character '.' to be suppressed.
1051 If the very first character of a file containing a Pascal
1052 program is the sharp ('#', ASCII 23(hex)) the file is preprocessed
1053 in the same way as C programs.
1054 Lines beginning with a '#' are taken as preprocessor command lines
1055 and not fed to the Pascal compiler proper.
1056 C style comments, /*......*/, are removed by the C preprocessor,
1057 thus C comments inside Pascal programs are also removed when they
1058 are fed through the preprocessor.
1059 .CH "Deviations from the standard"
1060 Ack-Pascal deviates from the standard proposal in the following ways:
1064 Standard procedures and functions are not allowed as parameters in Ack-Pascal.
1065 The same result can be obtained with negligible loss of performance
1066 by declaring some user routines like:
1068 function sine(x:real):real;
1076 The standard procedures read, readln, write and writeln are implemented as
1077 word-symbols, and can therefore not be redeclared.
1078 .CH "Compiler options"
1079 Some options of the compiler may be controlled by using "{$....}".
1080 Each option consists of a lower case letter followed by +, - or an unsigned
1082 Options are separated by commas.
1083 The following options exist:
1088 this option switches assertions on and off.
1089 If this option is on, then code is included to test these assertions
1090 at run time. Default +.
1094 this option, if on, allows the use of C-type string constants
1095 surrounded by double quotes.
1096 Moreover, a new type identifier 'string' is predefined.
1101 this option, if on, allows the use of variables of type 'long'.
1106 with this flag the setsize for a set of integers can be
1108 The number must be the number of bits per set.
1109 The default value is wordsize-1.
1113 if + then code is inserted to keep track of the source line number.
1114 When this flag is switched on and off, an incorrect line number may appear
1115 if the error occurs in a part of the program for which this flag is off.
1116 These same line numbers are used for the profile, flow and count options
1117 of the EM interpreter em [5].
1122 if + then code is inserted to check subrange variables against
1123 lower and upper subrange limits.
1128 if + then the compiler will hunt for places in the program
1129 where non-standard features are used, and for each place found
1130 it will generate a warning. Default -.
1134 if + then each time a procedure is entered, the routine 'procentry' is
1135 called, and each time a procedure exits, the procedure 'procexit' is
1136 called. Both 'procentry' and 'procexit' have a 'string' as parameter. This
1137 means that when a user specifies his or her own procedures, the c-option
1138 must be used. Default procedures are present in the run time library.
1143 if + then the character '_' is treated like a letter,
1144 so that it may be used in identifiers.
1145 Procedure and function identifiers are not allowed to start with an
1146 underscore because they may collide with library routine names.
1150 Some of these flags (c, d, i, s, u, C and U) are only effective when
1151 they appear before the 'program' symbol. The others may be switched
1154 A very powerful debugging tool is the knowledge that inaccessible statements
1155 and useless tests are removed by the EM optimizer. For instance, a
1160 writeln('initialization done');
1163 is completely removed by the optimizer if debug is a constant with
1165 The first line is removed if debug is a constant with value true.
1166 Of course, if debug is a variable nothing can be removed.
1168 A disadvantage of Pascal, the lack of preinitialized data, can be
1169 diminished by making use of the possibilities of the EM optimizer.
1170 For instance, initializing an array of reserved words is sometimes
1171 optimized into 3 EM instructions. To maximize this effect
1172 variables must be initialized as much as possible in order of declaration and array entries
1173 in order of decreasing index.
1178 BSI standard BS 6192: 1982 (ISO 7185).
1182 A.S.Tanenbaum, J.W.Stevenson, Hans van Staveren, E.G.Keizer,
1183 "Description of a machine architecture for use with block structured languages",
1184 Informatica rapport IR-81.
1200 UNIX manual libpc(VII)
1204 UNIX manual pc_prlib(VII)
public / Ack-5.5.git / blob