21 # ###### ###### # ###### # #
\r
23 # # # # # # # # # #
\r
24 # # # # ## # ###### # # #
\r
25 # # # # # # # # # ##
\r
26 ###### ###### ###### ###### # # # #
\r
61 0. Preface ......................................... 3.
\r
63 1. Using Loglan-82 system .......................... 3.
\r
64 1.1. Compilation ................................ 3.
\r
65 1.2. Compiler switches .......................... 4.
\r
66 1.3. Code generation ............................ 4.
\r
67 1.4. Program interpretation ..................... 5.
\r
68 1.5. Compile time error ......................... 6.
\r
69 1.6. Run-time errors ............................ 6.
\r
71 2. Compiler options ................................ 6.
\r
72 2.1. Option format .............................. 7.
\r
73 2.2. Options list ............................... 7.
\r
75 3. Loglan implementation specification ............. 7.
\r
76 3.1. Implemented subset of Loglan ............... 7.
\r
77 3.2. Non-standard language elements ............. 8.
\r
78 3.3. File system ................................ 8.
\r
79 3.3.1. File variables ........................ 8.
\r
80 3.3.2. File generation ....................... 8.
\r
81 3.3.3. File deallocation ..................... 9.
\r
82 3.3.4. General file operations ............... 9.
\r
83 3.3.5. Text files ............................ 9.
\r
84 3.3.6. Binary sequential files ............... 10.
\r
85 3.3.7. Direct access binary files............. 10.
\r
86 3.4. Concurrency ................................ 11.
\r
87 3.4.1. Invoking the LOGLAN interpreter for
\r
88 concurrent programs ................... 11.
\r
89 3.4.2. Restrictions and differences from the
\r
90 report ................................ 12.
\r
91 3.4.3. Communication mechanism ............... 13.
\r
92 3.5. System signals ............................. 14.
\r
93 3.6. Implementation restrictions ................ 15.
\r
96 A. Standard constants .............................. 16.
\r
97 B. Standard classes ................................ 16.
\r
98 IIUWGRAPH ................................... 16.
\r
99 MOUSE ....................................... 17.
\r
100 C. Standard procedures and functions ............... 19.
\r
101 D. Error codes ..................................... 21.
\r
102 E. Loglan runtime errors ........................... 30.
\r
103 F. Character set ................................... 32.
\r
105 Bibliography ....................................... 33.
\r
114 This document provides information necessary to compile and execute
\r
115 Loglan programs on IBM/PC compatible computers.
\r
116 This manual assumes basic knowledge of Loglan-82 language,
\r
117 described in "Report on the Loglan Programming Language" (see
\r
123 1. USING LOGLAN-82 SYSTEM
\r
127 The following three steps are required to execute a Loglan
\r
129 - Compilation (to intermediate code),
\r
130 - Generation of the interpreted code (from intermediate code),
\r
131 - Interpretation (i.e. execution of program).
\r
134 Compilation is accomplished by invoking Loglan compiler. This step
\r
135 creates two destination files: the intermediate code file and the
\r
137 The intermediate code file is the input file for the second
\r
138 step: generation of the code accepted by interpreter.In this step two
\r
139 files containing object code are produced. They are the input files
\r
140 for the third step: interpretation. This step is equivalent to
\r
141 execution of a program.
\r
150 To invoke the Loglan compiler without specifying any command
\r
151 line parameters, type:
\r
153 Then the prompt appears on your terminal:
\r
155 and the compiler waits for file specification.The default extension
\r
157 The compiler will produce (optionally) listing file with the same
\r
158 file name and the extension LST and will produce, if no error occurs,
\r
159 the code file with the extension LCD. Destination files will be
\r
160 stored on the same drive and directory as the source file.
\r
161 If the compiler's symbol table overflows during compilation, use
\r
162 HLOGLAN.EXE instead of LOGLAN.EXE.
\r
168 File name: PROGRAM <RETURN>
\r
170 Loglan compiler compiles program from PROGRAM.LOG file and creates
\r
174 2. LOGLAN A:PROGRAM.DAT
\r
177 In this case the source file is PROGRAM.DAT from drive A. The
\r
178 file PROGRAM.LCD will be created on drive A.
\r
182 If any error occurs, the code file is not produced.
\r
183 At the end of compiltation the following message is printed:
\r
184 <number of errors> error(s) detected
\r
187 1.2. COMPILER SWITCHES
\r
191 There are two possibilities to specify compiler's options: by
\r
192 compiler switches (i.e. external options) or by comments in the source
\r
193 program (see chapter 2.).
\r
194 You may enter the compiler switches in command line after file
\r
195 name in the followng format:
\r
196 sw1 sw2... swk <return>
\r
197 where swi consists of character that designates the name of the option
\r
198 and either '+' or '-'.
\r
204 1. LOGLAN PROGRAM L- T+
\r
208 In this case the default switches values are assumed.
\r
211 Scope of the switch is the entire program. All switches ,except H,
\r
212 correspond to options. A switch has greater priority then options:
\r
213 when you specify switch, all corresponding options inside source
\r
214 program will be ignored. Full description of each option is given
\r
215 in chapter 2.2. Switch L has additional significance. When this
\r
216 switch is set off no listing file is produced.
\r
220 1.3. CODE GENERATION
\r
223 In this step information from the intermediate code file is read
\r
224 and two destination files containing the code are produced. No
\r
225 switch is permitted for this step. To generate code files, type:
\r
228 HGEN <file name>, if the switch H+ was specified for the
\r
230 You type file name without extension (extension is ignored).
\r
237 FILE_NAME: PROGRAM
\r
238 Information is read from file PROGRAM.LCD from default drive and
\r
239 directory. Two destination files are produced: PROGRAM.CCD and
\r
240 PROGRAM.PCD and stored in the same directory as the input file.
\r
245 Files PROGRAM.CCD and PROGRAM.PCD are stored on drive A.
\r
249 1.4. PROGRAM INTERPRETATION
\r
252 To interprete (execute) the Loglan program you must invoke the
\r
253 interpreter INT or HINT (if the switch H+ was specified). File name
\r
254 must be specified in command line. The file extension is ignored. The
\r
255 interpreter reads input files with the given name and extensions CCD
\r
256 and PCD and executes the Loglan program.
\r
257 The syntax for calling the onterpreter is
\r
259 INT <options> <file name>
\r
261 HINT <options> <file name>
\r
263 The following options are supported:
\r
265 /m < n > - set memory size for Loglan program (in 16 bit words
\r
266 for small and 32 bit words for huge memory). For
\r
267 concurrent programs it means memory size for every
\r
269 /i - information about compactification is printed.
\r
270 /r < n > - used to invoke interpreter on nodes different from
\r
271 console (see 3.4.). Option parameter is console node
\r
272 number (as defined by D-Link Network).
\r
275 At the end of interpretation the following message is printed:
\r
278 End of LOGLAN-82 program execution
\r
284 LOGLAN \DAT\EXAMP.SRC, L+
\r
287 The file \DAT\EXAMP.LCD and \DAT\EXAMP.LST are generated.
\r
291 The files \DAT\EXAMP.CCD and \DAT\EXAMP.PCD are created. Then the
\r
292 program can be interpreted by:
\r
296 1.5. COMPILE TIME ERRORS
\r
300 The errors detected during the compilation are printed on the
\r
301 listing file, if this file is created. In the scope of option L- or
\r
302 if the switch L is set off only the incorrect lines and errors
\r
303 messages are printed . When the switch ( not option !) L is set off
\r
304 then listing file is not produced and incorrect lines and error
\r
305 messages are printed on the user's terminal.
\r
306 Error message has the following format:
\r
307 *** ln ERROR en txt id
\r
310 ln - index of incorrect line,
\r
311 en - error code (see Appendix B),
\r
312 txt- text that explain type of the error,
\r
313 id - identifier helpful to situate the error.
\r
315 Error messages are printed in the source listing after incorrect
\r
316 lines. For syntax errors (numbered 101-147, 201-212), sign '?'
\r
317 indicates the error position in the line.
\r
318 Error may be detected beyond the line containing it.
\r
319 Identifier helpful to find an error is printed as soon as possible.
\r
321 For codes 331-338 error message is printed after first line of
\r
322 virtual module declaration.
\r
323 Errors like "undeclared identifier" are printed in each module
\r
324 once, after first reference to this identifier. Further references are
\r
326 The errors related to case instruction may appear before the
\r
332 1.6. RUN-TIME ERRORS
\r
336 Loglan run-time errors are detected by Loglan run-time system. When
\r
337 any of these errors occurs, the appropriate system signal is raised
\r
338 and error message is printed if handler is not found. All of
\r
339 these error messages are described in Appendix C. Moreover
\r
340 the line number of the last executed statement is printed on the
\r
346 2. COMPILER OPTIONS
\r
350 Options, like switches are used to pass some information to
\r
351 the compiler. Options are placed in source program in comments.
\r
352 Scope of options in source program is textual. Option may appear in
\r
353 any place of source program, but it is active from the beginning of
\r
354 the nearest instruction. Listing option L is active from the next line
\r
355 after line containing setting this option on up to the line containing
\r
356 setting this option off.
\r
357 Options overwrite defaults, but are overwritten by switches
\r
358 (external options).
\r
359 Option definition is not allowed before the keyword program.
\r
362 2.1. OPTION FORMAT
\r
366 Options may be placed in source program in comments in the
\r
369 where opti consists of character that designates the option and
\r
370 either '+' or '-' e.g.: (*$L-,T+*). Options in one comment should
\r
371 be separated by commas. Spaces in such comment are not allowed.
\r
383 D+ - causes the line numbers of the executed instruction to
\r
387 L- - default, only incorrect lines are printed on the
\r
389 L+ - all lines are printed on the listing file
\r
391 O+ - optimization of some arithmetical and logical
\r
392 expressions are included to generated code (default),
\r
393 O- - generate code without optimization,
\r
394 T - type conflict checking
\r
395 T+ - default, dynamic checking of type conflict in
\r
396 assignment instructions and in parameter transmissions,
\r
397 T- - no dynamic checking
\r
398 H - memory model (switch only)
\r
399 H- - default, small memory
\r
401 When H- is specified all code and data must fit into 64K
\r
402 bytes. When H+ is specified all memory available on IBM PC
\r
403 may be utilized, with the cost of increased execution time.
\r
408 3. IBM PC LOGLAN-82 IMPLEMENTATION SPECIFICATION
\r
411 3.1. IMPLEMENTED SUBSET OF LOGLAN
\r
415 The following constructions described in the report of Loglan-82
\r
416 have not been implemented:
\r
417 - local attributes,
\r
418 - separate compilation,
\r
419 File system is described in 3.3.
\r
422 3.2. NON-STANDARD LANGUAGE ELEMENTS
\r
426 Standard constants, procedures and functions are added to the
\r
427 language (see Appendix A). Moreover keywords char (short form of
\r
428 character) and bool (short form of boolean) are added.
\r
429 The character set, defined in the report of Loglan-82, is
\r
430 extended by lower - case letters and the tabulation character (decimal
\r
431 code 9). It is possible to use operator '<>' which stands for 'not
\r
440 Loglan contains the predefined reference type file and a set of
\r
441 statements and standard procedures to manipulate files. Both
\r
442 sequential and direct access files are implemented.
\r
445 3.3.1. FILE VARIABLES
\r
448 Variables of the type file can be declared in the Loglan program
\r
449 and can be used as any variables of a reference type.
\r
456 unit p:procedure(f:file); ... end;
\r
465 3.3.2. FILE GENERATION
\r
468 A file object is generated by open statement of the form:
\r
470 open(f,T) for internal files or
\r
471 open(f,T,A) for external files
\r
473 f is a file variable
\r
475 T = text for text files
\r
476 char --- for binary sequential files of character,
\r
477 integer or real values
\r
480 direct for direct access binary files
\r
482 A is an expression of the type arrayof char designating
\r
483 external file name.
\r
484 After execution of open statement the new file object is created
\r
485 and it becomes a value of the file variable f. If the file is opened
\r
486 as an external one, then it references to the file A.
\r
491 open(data,text) - new internal text file data is
\r
493 open(num ,integer) - new internal binary file num is
\r
494 opened (the file components are
\r
496 open(f,text,unpack("my.dat")) - external text file f is opened; it
\r
497 references to the file my.dat
\r
498 stored on the default drive and
\r
500 open(f,direct,A) - external direct access file with
\r
501 name contained in array A is opened.
\r
504 3.3.3. FILE DEALLOCATION
\r
507 The file can be closed and deallocated by execution of the
\r
512 3.3.4. GENERAL FILE OPERATIONS
\r
515 There are three standard procedures associated with files: RESET,
\r
516 REWRITE and UNLINK.
\r
518 call RESET(f) rewinds the file f. After execution of RESET on
\r
519 sequential files only read/get operations are
\r
522 call REWRITE(f) creates a new empty file. After execution of
\r
523 REWRITE on sequential files only write/put operations
\r
526 call UNLINK(f) closes and deletes file f. File object is deallocated
\r
527 and f is set to none.
\r
529 RESET or REWRITE must be performed on the file opening
\r
530 before the first I/O operation on it.
\r
538 The following operations are available to text files: read, readln,
\r
539 eoln, write, writeln, eof.
\r
540 The first parameter of the operation is a file variable. If it is
\r
541 omitted, then a standard input/output file assigned to user's
\r
552 writeln(g," .... ");
\r
553 if eof(f) then ....
\r
556 For more information see (1).
\r
560 3.3.6. BINARY SEQUENTIAL FILES
\r
563 Any file created with the parameter T = integer, real or char is a
\r
564 binary one.It is a sequence of components of the type T. Only objects
\r
565 of type T can be read from or written to this file.
\r
566 The following operations are avaliable to binary files:
\r
569 get(f, x1, ..., xn)
\r
572 where f is a file opened with the type T, wi is an expression of the
\r
573 type T and xi is a variable of the type T.
\r
574 The statement put(f, w1, ..., wn) writes the components w1, ...,
\r
575 wn to the file f. The statement get(f, x1, ..., xn) reads the next n
\r
576 components from the file f and assigns them to the variables x1,
\r
577 ..., xn. The statement eof is the same as for text files.
\r
581 3.3.7 DIRECT ACCESS BINARY FILES
\r
584 Direct access files are treated as a sequence of bytes without any
\r
585 interpretation. Operations RESET and REWRITE prepare a file for both
\r
586 reading and writing. RESET is used for existing files, REWRITE for the
\r
587 new ones. The following additional operations are available:
\r
589 call SEEK(f, offset, base) - moves the file pointer to the position
\r
590 designated by offset relative to base.
\r
591 Offset is a signed integer specifying the
\r
592 number of bytes. Possible values for base
\r
594 0 - begining of file
\r
595 1 - current position of file pointer
\r
596 2 - end of the file
\r
600 call SEEK(f, 0, 0) - rewinds file f
\r
601 call SEEK(f, -3, 1) - backspaces file f by 3 bytes
\r
602 call SEEK(f, 0, 2) - moves the file pointer to the first byte
\r
605 POSITION(f) - returns current position of the file
\r
606 pointer associated with f.
\r
610 PUTREC(f, A, n) - where A is an array of any primitive
\r
611 type and n is an integer variable. Let k
\r
612 be the number of bytes occupied by
\r
613 elements of array A. This operation
\r
614 writes min(k, n) bytes from A to the file
\r
615 f and advances file pointer by the number
\r
616 of written bytes. The number of bytes
\r
617 written to the file is returned in the
\r
621 GETREC(f, A, n) - where A is an existing array of any
\r
622 primitive type and n is an integer
\r
623 variable. Let k be the number of bytes
\r
624 occupied by elements of array A This
\r
625 operation reads min(k,n) bytes (or less,
\r
626 if end of file is encountered) from the
\r
627 file and advances the file pointer by the
\r
628 number of read bytes. The number of bytes
\r
629 read from the file is returned in the
\r
639 Implemented concurrency mechanisms differ much from those described
\r
640 in the LOGLAN-82 report. In particular, only distributed processes are
\r
641 implemented, so they cannot communicate through shared variables. For
\r
642 this reason semaphores had to be replaced by an entirely new
\r
643 communication mechanism. Such a mechanism has been designed and it is
\r
644 based on the rendez-vous schema.
\r
647 3.4.1. INVOKING THE LOGLAN INTERPRETER FOR CONCURRENT PROGRAMS
\r
650 A concurrent LOGLAN program may run on a single computer with
\r
651 concurrency simulated by time slicing. In this case LOGLAN interpreter
\r
652 is invoked as usual. One must only remember that /m optional parameter
\r
653 (see 1.4.) denotes memory size for each process rather than for the
\r
656 To achieve true parallel (multiprocessor) execution, a network of
\r
657 IBM PC computers may be used. For the time being, only D-Link Network
\r
658 Version 3.21 is supported. In order to run a LOGLAN program in the
\r
659 network environment take the following steps:
\r
661 1) make sure that every node is logged on,
\r
662 2) select arbitrarily one node as a console,
\r
663 3) invoke the LOGLAN interpreter on every node except the console,
\r
664 giving it /r option with the console node number (see 1.4.). You
\r
665 must give the same program file to all interpreters. Most
\r
666 conveniently it may be achieved by accessing a file on a disk
\r
667 connected through the network to each node.
\r
668 4) invoke the interpreter on the console without the /r option (in
\r
669 the usual way). Give it the same program file as above.
\r
671 After the last step the main program process begins its execution
\r
672 on the console node. Other processes may be created dynamically on any
\r
673 node on which an interpreter is running.
\r
675 Regardless of the fact whether the network is used or not, more
\r
676 than one process may be executed on the same computer.
\r
679 3.4.2. RESTRICTIONS AND DIFFERENCES FROM THE REPORT
\r
682 All processes (even those executed on the same computer) are
\r
683 implemented as distributed, i.e. without any shared memory. This fact
\r
684 implies some restrictions on how processes may be used. Not all
\r
685 restrictions are enforced by the present compiler, so it is the
\r
686 programmer's responsibility to respect them. This is the list of
\r
689 1) all process units must be declared as global, i.e. directly
\r
690 inside the main program block
\r
691 2) a process cannot access global variables (except for the main
\r
693 3) any remote access to a process object other than a procedure (or
\r
694 function) call is inhibited
\r
695 4) each parameter of
\r
697 - a procedure called by remote access to a process object
\r
698 - a procedure parameter of a process
\r
699 must be one of the following:
\r
700 - a value of the primitive type (INTEGER, REAL, CHAR, BOOLEAN,
\r
702 - a procedure declared directly inside a process
\r
703 - a procedure which is a formal parameter of a process
\r
704 - any reference to a process object.
\r
705 This restriction implies that references to objects other than
\r
706 processes have only local meaning (in a single process) and
\r
707 cannot be passed among the processes.
\r
708 5) comparisons, IS, IN and QUA operations are not allowed for the
\r
709 references to processes.
\r
710 6) operations which require dynamic type checking on the references
\r
711 to processes are not allowed
\r
712 7) a process may be attached only by a proper coroutine (not by a
\r
713 process) generated by it
\r
714 8) the variable MAIN is accesible only in the main program process.
\r
716 The following concurrent constructs described in the report are not
\r
717 implemented at all:
\r
719 - semaphores and all operations on them
\r
720 - the WAIT expression.
\r
722 Semantics of the NEW generator is slightly modified when applied to
\r
723 the processes. The first parameter of the first process unit in the
\r
724 prefix sequence must be of type INTEGER. This parameter denotes the
\r
725 node number of the computer on which this process will be created. For
\r
726 a single computer operation this parameter must be equal to 0.
\r
730 unit A:class(msg:string);
\r
733 unit P:A process(node:integer, pi:real);
\r
741 (* Create process on node 4. The first parameter is the *)
\r
742 (* string required by the prefix A, the second is the node number *)
\r
743 x := new P("Hello", 4, 3.141592653);
\r
748 The following parallel constructs are implemented as defined in the
\r
751 - KILL operation for a process
\r
753 - STOP statement without parameter.
\r
756 3.4.3. COMMUNICATION MECHANISM
\r
759 Processes may communicate and synchronize by a mechanism based on
\r
760 rendez-vous. It will be referred to as "alien call" in the following
\r
763 An alien call is either:
\r
764 - a procedure (or function) call performed by a remote access to a
\r
766 - a call of a procedure which is a formal parameter of a process,
\r
768 - a call of a procedure which is a formal parameter of an
\r
769 alien-called procedure (this is a recursive definition).
\r
771 Every process object has an enable mask. It is defined as a subset
\r
772 of all procedures declared directly inside a process unit or any unit
\r
773 from its prefix sequence (i.e. subset of all procedures that may be
\r
775 A procedure is enabled in a process if it belongs to that process'
\r
776 enable mask. A procedure is disabled if it does not belong to the
\r
778 Immediately after generation of a process object its enable mask is
\r
779 empty (all procedures are disabled).
\r
781 Semantics of the alien call is different from the remote call
\r
782 described in the report. Both the calling process and the process in
\r
783 which the procedure is declared (i.e. the called process) are involved
\r
784 in the alien call. This way the alien call may be used as a
\r
785 synchronization mechanism.
\r
786 The calling process passes the input parameters and waits for the
\r
787 call to be completed.
\r
788 The alien-called procedure is executed by the called process.
\r
789 Execution of the procedure will not begin before certain conditions
\r
790 are satisfied. First, the called process must not be suspended in any
\r
791 way. The only exception is that it may be waiting during the ACCEPT
\r
792 statement (see below). Second, the procedure must be enabled in the
\r
794 When the above two conditions are met the called process is
\r
795 interrupted and forced to execute the alien-called procedure (with
\r
796 parameters passed by the calling process).
\r
797 Upon entry to the alien-called procedure all procedures become
\r
798 disabled in the called process.
\r
799 Upon exit the enable mask of the called process is restored to that
\r
800 from before the call (regardless of how it has been changed during the
\r
801 execution of the procedure). The called process is resumed at the
\r
802 point of the interruption. The execution of the ACCEPT statement is
\r
803 ended if the called process was waiting during the ACCEPT (see below).
\r
804 At last the calling process reads back the output parameters and
\r
805 resumes its execution after the call statement.
\r
807 The process executing an alien-called procedure can easily be
\r
808 interrupted by another alien call if the enable mask is changed.
\r
810 There are some new language constructs associated with the alien
\r
811 call mechanism. The following statements change the enable mask of a
\r
814 enables the procedures with identifiers p1, ..., pn. If there are any
\r
815 processes waiting for an alien call of one of these procedures, one of
\r
816 them is chosen and its request is processed. The scheduling is done on
\r
817 a FIFO basis, so it is strongly fair. The statement:
\r
818 DISABLE p1, ..., pn
\r
819 disables the procedures with identifiers p1, ..., pn.
\r
820 In addition a special form of the RETURN statement:
\r
821 RETURN ENABLE p1, ..., pn DISABLE q1, ..., qn
\r
822 allows to enable the procedures p1, ..., pn and disable the procedures
\r
823 q1,...,qn after the enable mask is restored on exit from the
\r
824 alien-called procedure. It is legal only in the alien-called
\r
825 procedures (the legality is not enforced by the compiler).
\r
826 A called process may avoid busy waiting for an alien call by means
\r
827 of the ACCEPT statement:
\r
829 adds the procedures p1, ..., pn to the current mask, and waits for an
\r
830 alien call of one of the currently enabled procedures. After the
\r
831 procedure return the enable mask is restored to that from before the
\r
834 Note that the ACCEPT statement alone (i.e. without any
\r
835 ENABLE/DISABLE statements or options) provides a sufficient
\r
836 communication mechanism. In this case the called process may execute
\r
837 the alien-called procedure only during the ACCEPT statement (because
\r
838 otherwise all procedures are disabled). It means that the enable mask
\r
839 may be forgotten altogether and the alien call may be used as a pure
\r
840 totally synchronous rendez-vous. Other constructs are introduced to
\r
841 make partially asynchronous communication patterns possible.
\r
846 3.5. SYSTEM SIGNALS
\r
850 System signals are connected to runtime errors (see APPENDIX C).
\r
851 These signals are the following:
\r
853 ACCERROR - reference to non existing object,
\r
854 CONERROR - array index outside the range or lower bound is
\r
855 greater than upper bound during array object
\r
857 LOGERROR - errors related to control transfer,
\r
858 MEMERROR - memory overflow,
\r
859 NUMERROR - errors related to arithmentic operations like division
\r
860 by zero, floating point overflow,
\r
861 TYPERROR - type conflict in assignment statement, during
\r
862 parameter transmission or headline conflict for actual
\r
863 parameter function and procedure.
\r
864 SYSERROR - errors related to file system, like reading after
\r
865 writing, too many files etc.
\r
870 3.6. IMPLEMENTATION RESTRICTIONS
\r
874 - Text line in source program can't be longer than 80
\r
876 - Maximal length of identifier is 20 characters, but entire
\r
877 length of all identifiers and keywords should be less
\r
878 than 3000 characters.
\r
879 - String constant can't be longer than 260 characters.
\r
880 - For case instructions:
\r
881 - up to 6 levels of nested case instructions are
\r
883 - range of labels can't be greater than 160.
\r
884 - Number of formal parameters can't be greater than 40,
\r
885 whereas up to 35 output or input parameters are allowed.
\r
886 Total number of formal parameters and variables declared
\r
887 in one module can't be greater than 130.
\r
888 - Number of array indices (i.e. arrayof) can't be greater
\r
890 - Standard type integer has the range (-32767,+32767) for
\r
891 small memory (16 - bit word ). For huge memory (32-bit
\r
892 word) the range is (-2147483647,+2147483647), but values
\r
893 of constant expressions in a program must lie within the
\r
894 range (-32767,32767).
\r
895 - Real numbers have the range (-8.43E-37, 3.37E+38)
\r
896 with 24-bit mantissa and 8-bit exponenet for small
\r
897 memory , giving about 7 digits of precision. For huge
\r
898 memory the range is (4.19E-307, 1.67E+308) with 53-bit
\r
899 mantissa and 11-bit exponent, giving about 15 digits of
\r
900 precision.Values of constant expression in a program must
\r
901 lie in the range (-8.43E-37, 3.37E+38).
\r
907 Compiler computes values of expressions built from
\r
908 constants without range checking. It means, that integer
\r
909 overflow, floating point overflow or underflow cause
\r
910 incorrect result without any message.
\r
913 APPENDIX A : STANDARD CONSTANTS
\r
917 The size in bytes of integer variables (2 for small
\r
918 memory, 4 for huge memory)
\r
921 The size in bytes of real variables (4 for small
\r
922 memory, 8 for huge memory)
\r
928 APPENDIX B : STANDARD CLASSES
\r
933 Class IIUWGRAPH defines the set of graphics procedures. The full
\r
934 description of these procedures is contained in the description
\r
935 of the library IIUWGRAF (Institue of Informatics, University of
\r
936 Warsaw). The following procedures are available in Loglan (heads
\r
937 are specified if they are different from these in IIUWGRAF
\r
956 nocard : function: integer;
\r
959 inxpos : function: integer;
\r
960 inypos : function: integer;
\r
962 getmap : function(input x,y:integer): arrayof integer;
\r
967 inkey : function : integer;
\r
979 Standard class MOUSE provides basic support for mouse. An external
\r
980 resident Microsoft compatible mouse driver (such as MOUSE.SYS) must be
\r
981 installed to use this class. MOUSE contains following procedures and
\r
984 init:function(output b:integer):boolean
\r
985 Initializes mouse driver. Number of mouse buttons is returned
\r
986 in b. Returns true iff mouse hardware and software are
\r
989 showcursor:procedure
\r
990 This procedure increments the internal cursor counter. If the
\r
991 counter is 0 it displays the cursor on the screen. The cursor
\r
992 tracks the motion of the mouse, changing position as the mouse
\r
995 hidecursor:procedure
\r
996 This procedure removes the cursor from the screen and
\r
997 decrements the internal cursor counter. Although the cursor is
\r
998 hidden it still tracks the motion of the mouse, changing
\r
999 position as the mouse changes position.
\r
1001 status:procedure(output h, v:integer, l, r, c:boolean)
\r
1002 This procedure reports the status of the buttons and cursor.
\r
1003 l, r, c are true iff respectively left, right and center (if
\r
1004 it exists) buttons are down when the procedure is called. Also
\r
1005 position of cursor is returned in h and v. Position is
\r
1006 expressed in Color Graphics Adapter pixels (with resolution
\r
1009 setposition:procedure(h, v:integer)
\r
1010 This procedure sets the cursor to the specified horizontal and
\r
1011 vertical positions on the screen. The new values must be
\r
1012 within the specified ranges of the virtual screen. The values
\r
1013 are rounded to the nearest values permitted by the screen for
\r
1014 horizontal and vertical positions.
\r
1016 getpress:procedure(b:integer; output h, v, p:integer, l, r, c:boolean)
\r
1017 This procedure gives a count of selected button presses (on p)
\r
1018 since the last call to it and the position of the cursor (on h
\r
1019 and v) the last time the button was pressed. Parameter b
\r
1020 selects button to be checked: 0 - left, 1 - right, 2 - center.
\r
1021 In addition current button status is returned in l, r and c
\r
1022 (see procedure status).
\r
1024 getrelease:procedure(b:integer; output h, v, p:integer, l, r, c:boolean)
\r
1025 This procedure gives a count of selected button releases (on
\r
1026 p) since the last call to it and the position of the cursor
\r
1027 (on h and v) the last time the button was released. Parameter
\r
1028 b selects button to be checked: 0 - left, 1 - right, 2 -
\r
1029 center. In addition current button status is returned in l, r
\r
1030 and c (see procedure status).
\r
1032 setwindow:procedure(l, r, t, b:integer)
\r
1033 Restricts the cursor movement to window described by l, r, t,
\r
1034 b. L and r are minimum and maximum horizontal cursor position,
\r
1035 t and b are minimum and maximum vertical cursor position (in
\r
1039 defcursor:procedure(s, x, y:integer)
\r
1040 Selects text mode cursor characteristics. When s is 0,
\r
1041 software cursor is selected and x, y define masks to be used
\r
1042 when modifying character-attribute word in screen memory
\r
1043 associated with position under cursor. This word is logicaly
\r
1044 ANDed with x and the result is XORed with y. When s is 1, a
\r
1045 hardware cursor is selected and x, y define first and last
\r
1046 scan lines of the cursor box within character box. X must be
\r
1047 not greater than y and both must be in range 0-7 for Color
\r
1048 Graphics Adapter or 0-13 for Monochrome Display Adapter,
\r
1049 Hercules Graphics Card and Enhanced Graphics Adapter.
\r
1051 call defcursor(0, -1, 30464)
\r
1052 - selects standard (reverse video) software cursor
\r
1053 call defcursor(1, 11, 12)
\r
1054 - selects standard hardware cursor for HGC
\r
1056 getmovement:procedure(output h, v:integer)
\r
1057 Returns relative mouse movement since last call (in 1/200
\r
1060 setspeed:procedure(h, v:integer)
\r
1061 H and v specify horizontal and vertical cursor speed relative
\r
1062 to mouse speed. It is expressed in mouse steps (1/200 inch)
\r
1063 corresponding to 8 CGA pixels on screen. Default is 8
\r
1064 horizontaly and 16 verticaly.
\r
1066 call setspeed(1, 1)
\r
1067 - set maximum cursor speed
\r
1068 call setspeed(16, 32)
\r
1069 - set cursor speed two times slower than default
\r
1071 setthreshold:procedure(s:integer)
\r
1072 sets threshold speed for double speed feature. If the mouse
\r
1073 moves faster than the threshold, the cursor speed on the
\r
1074 screen is doubled. Default threshold is 64 mouse steps/second.
\r
1076 call setthreshold(10000)
\r
1077 - efectively disable double speed feature.
\r
1082 APPENDIX C : STANDARD PROCEDURES AND FUNCTIONS
\r
1085 ENDRUN:procedure;
\r
1086 Terminates program execution (ABORT).
\r
1088 RANSET:procedure(x:real);
\r
1089 Initializes random generator (for RANDOM function)
\r
1091 RANDOM:function:real;
\r
1092 Generates uniformly distributed pseudo-random numbers
\r
1093 in the interval (0,1).
\r
1095 SQRT:function(x:real):real;
\r
1096 Computes square root of parameter x.
\r
1098 SIN:function(x:real):real;
\r
1099 Computes sinus of parameter x.
\r
1101 COS:function(x:real):real;
\r
1102 Computes cosinus of parameter x.
\r
1104 TAN:function(x:real):real;
\r
1105 Computes tangens of parameter x.
\r
1107 EXP:function(x:real):real;
\r
1110 LN:function(x:real):real;
\r
1111 Computes natural logarithmus of parameter x.
\r
1113 ATAN:function(x:real):real;
\r
1114 Computes arcus tangens of parameter x.
\r
1116 ENTIER:function(x:real):integer;
\r
1117 Computes entier part of parameter x.
\r
1119 ROUND:function(x:real):integer;
\r
1120 Computes rounded value of parameter x:
\r
1121 ROUND(x)=ENTIER(x+0.5).
\r
1123 IMIN:function(x, y:integer):integer;
\r
1124 Computes minimum of two parameters.
\r
1126 IMAX:function(x, y:integer):integer;
\r
1127 Computes maximum of two parameters.
\r
1129 IMIN3:function(x, y, z:integer):integer;
\r
1130 Returns the minimum of three parameters.
\r
1132 IMAX3:function(x, y, z:integer):integer;
\r
1133 Returns maximum of three parameters.
\r
1135 ISHFT:function(x, k:integer):integer;
\r
1136 Logically shifts x by k bits: left, when k is
\r
1137 positive, right otherwise.
\r
1139 IAND:function(n, k:integer):integer;
\r
1140 Returns logical product of parameters (on all bits).
\r
1142 IOR:function(n, k:integer):integer;
\r
1143 Returns logical sum of parameters (on all bits).
\r
1145 XOR:function(n, k:integer):integer;
\r
1146 Returns exlusive sum of parameters (on all bits).
\r
1148 INOT:function(n:integer):integer;
\r
1149 Returns logical complement of parameters (on all
\r
1152 ORD:function(c:char):integer;
\r
1153 Returns number that represents character c (see
\r
1154 APPENDIX D). The following equations are satisfied:
\r
1158 CHR:function(n:integer):char;
\r
1159 Returns character represented by parameter n (see
\r
1162 UNPACK:function(s:string):arrayof char;
\r
1163 Returns address of new array object containing
\r
1164 characters of the string s.
\r
1166 MEMAVAIL:function:integer;
\r
1167 Returns the size of available memory in the current
\r
1168 process (in words).
\r
1170 EXEC:function(cmd:arrayof char):integer;
\r
1171 Calls secondary command processor with cmd as a
\r
1172 command string. Exit code is returned as a value of
\r
1175 TIME:function: integer;
\r
1176 Returns an integer value indicating the amount of
\r
1177 central processor time in seconds used by current
\r
1180 RESET:procedure(f:file);
\r
1181 Positionnes file f at the first component and readies
\r
1184 REWRITE:procedure(f:file);
\r
1185 Positionnes file f at the first component and readies
\r
1186 it for output. The file f becomes empty (eof(f) =
\r
1189 UNLINK:procedure(f:file);
\r
1190 Closes and deletes file f (see 3.3.4)
\r
1192 SEEK:procedure(f:file; offset, base:integer);
\r
1193 Positiones file pointer (see 3.3.7)
\r
1195 POSITION:function(f:file):real;
\r
1196 Reads position of file pointer (see 3.3.7)
\r
1202 APPENDIX D : ERROPOR CODES
\r
1206 0 - ***declaration part overloaded
\r
1207 Overflow of compiler data structure of declaration
\r
1208 part. Possible reasons: too complicated program
\r
1209 structure (too many classes, protection lists,
\r
1210 parameter lists,...), too complicated function
\r
1211 expressions e.g. f(g(h(...))). It is possible that
\r
1212 removing some errors e.g. "unvisible identifier"
\r
1213 causes shortening of the program.
\r
1214 10 - ***too many errors
\r
1215 Overflow of error diagnostic table. 1024 first
\r
1216 detected errors are printed, but global number of
\r
1217 error is equal to number of all detected errors.
\r
1218 41 - ***declaration part overloaded
\r
1219 Comments as for 0.
\r
1220 101 - ':=' expected
\r
1221 102 - ';' expected
\r
1222 103 - 'then' expected
\r
1223 104 - 'fi'/'else' expected
\r
1224 105 - 'od' expected
\r
1225 106 - '(' expected
\r
1226 107 - ')' expected
\r
1227 108 - 'do' expected
\r
1228 109 - identifier expected
\r
1229 110 - too many exits found
\r
1230 Length of sequence exit exit ...exit exceeds level
\r
1231 of loop nesting +1.
\r
1232 111 - illegal character
\r
1233 112 - wrong structure of 'if'-statement
\r
1234 113 - 'end' missing
\r
1235 114 - '.' expected
\r
1236 115 - illegal constant in expression
\r
1237 Character constant or text appears in logical or
\r
1238 arithmetical expression.
\r
1239 116 - '=' expected
\r
1240 117 - constant expected
\r
1241 118 - ':' expected
\r
1242 119 - unit kind specification expected
\r
1243 Keywords: class, procedure, function, coroutine or
\r
1244 process missing in module headline.
\r
1245 120 - 'hidden' or 'close' occurred twice
\r
1246 121 - 'hidden' or 'close' out of a class
\r
1247 122 - 'block' expected
\r
1248 123 - object expression is not a generator
\r
1249 Object expression appearing as instruction is not
\r
1250 a generator e.g. new (a).b
\r
1251 124 - 'dim' expected
\r
1252 125 - 'to'/'downto' expected
\r
1253 126 - illegal arithmetic operator
\r
1254 127 - declaration part expected
\r
1255 128 - incorrect identifier at 'end'
\r
1256 Module name after end does not correspond to name
\r
1257 in module headline.
\r
1258 129 - wrong structure of 'case'-statement
\r
1259 130 - wrong structure of 'do'-statement
\r
1260 131 - illegal use of 'main'
\r
1261 Name main may be used only as an argument of
\r
1262 attach operator: in other cases it is illegal.
\r
1263 132 - 'when' expected
\r
1264 133 - too many branches in 'case'-statement
\r
1265 Number of branches in case instruction is greater
\r
1267 134 - 'begin' missed
\r
1269 136 - is it really a loglan program???
\r
1270 There is no Loglan keyword found in source program
\r
1271 like: begin, block, unit, class,...
\r
1272 137 - 'block' missed - parsing began
\r
1273 There is no keyword block or program at the
\r
1274 beginning of the Loglan program. This message
\r
1275 indicates the source line, that is the first
\r
1277 138 - 'repeat' out of a loop
\r
1278 The length of sequence: (exit)*repeat exceeds
\r
1279 nested depth of the loop.
\r
1280 139 - there is no path to this statement
\r
1281 140 - 'andif'/'orif' mixed
\r
1282 141 - array of 'semaphore' is illegal
\r
1283 142 - wrong handler end
\r
1284 Handler declaration is not ended by instruction
\r
1285 end or end handlers.
\r
1286 143 - lastwill inside a structured statement
\r
1287 144 - repeated lastwill
\r
1288 Label LASTWILL appears more than once in the same
\r
1290 145 - no parameter specification
\r
1291 146 - wrong register specification
\r
1292 147 - "," expected
\r
1293 191 - ***null program
\r
1294 There is no source program on the input file or
\r
1295 there is no module declaration. Causes termination
\r
1296 of program compilation.
\r
1297 196 - ***too many identifiers
\r
1298 Entire length of all identifiers and keywords is
\r
1299 greater than 3000 characters. This overflow
\r
1300 terminates program compilation.
\r
1301 197 - ***too many formal parameters
\r
1302 The length of formal parameter list and declared
\r
1303 local variables (in actual module) is greater than
\r
1304 130. This error terminates program compilation.
\r
1305 198 - ***parsing stack overloaded
\r
1306 Too complicated (nested) program structure. This
\r
1307 error terminates program compilation.
\r
1308 199 - ***too many prototypes
\r
1309 Too many declarations in program caused overflow
\r
1310 of the compiler data structure. This error
\r
1311 terminates program compilation.
\r
1312 201 - wrong real constant
\r
1313 202 - wrong comment
\r
1314 203 - wrong character constant
\r
1315 204 - wrong integer constant
\r
1316 205 - integer overflow
\r
1317 Integer constant out of range.
\r
1318 206 - real overflow
\r
1319 Real constant out of range.
\r
1320 211 - identifier too long
\r
1321 Length of identifier is greater than 20
\r
1323 212 - string too long
\r
1324 Length of string constant is greater than 260
\r
1326 301 - prefix is not a class id
\r
1327 Prefix name ID is not a class name. It may appear
\r
1328 when identifier ID is used earlier (declarated
\r
1330 303 - coroutine/process illegal here as prefix id
\r
1331 Procedure, function or block can't be prefixed by
\r
1332 coroutine or process.
\r
1333 304 - hidden identifier cannot be taken id
\r
1334 Identifier ID placed on taken list is on hidden
\r
1335 list in the prefixing module.
\r
1336 305 - undeclared identifier id
\r
1337 306 - undeclared type identifier id
\r
1338 307 - type identifier expected id
\r
1339 Identifier ID used in variable or function
\r
1340 declaration as a type name, is not declared
\r
1341 earlier as a type (but name has been used
\r
1343 308 - undeclared prefix identifier id
\r
1344 309 - declared more than once id
\r
1345 310 - taken list in unprefixed unit
\r
1346 316 - formal type specification after use id
\r
1347 Formal type ID appears in the parameter list after
\r
1348 using this identifier as a parameter type e.g.
\r
1349 (... x: ID; type ID, ...).
\r
1350 317 - hidden type identifier id
\r
1351 Type name ID is on hidden list in a prefix of one
\r
1352 of the modules from SL chain of actual module and
\r
1353 it is a nearest declaration of this identifier.
\r
1354 318 - type identifier not taken id
\r
1355 Type name ID is not on taken list in a prefix of
\r
1356 one of the modules from SL chain of actual module.
\r
1357 319 - hidden identifier in the list id
\r
1358 Identifier ID from hidden or close list is on
\r
1359 hidden list in one of the prefixing modules.
\r
1360 320 - identifier in the list not taken id
\r
1361 Identifer ID from hidden or close list is not
\r
1362 placed on taken list in none of the prefixing
\r
1364 321 - identifier cannot be taken id
\r
1365 Identifer ID from taken list is placed on taken
\r
1366 list in none of the prefixes.
\r
1367 322 - hidden prefix identifier id
\r
1368 Analogical to 317 error.
\r
1369 323 - prefix identifier not taken id
\r
1370 Analogical to 318 error.
\r
1371 329 - only procedure and function may be virtual
\r
1372 virtual specification appears with class
\r
1374 330 - virtual in unprefixed block/procedure/function
\r
1375 331 - incompatible kinds of virtuals id
\r
1376 Kind of virtual module ID is different from kind
\r
1377 of replaced module (e.g. one of them is a
\r
1378 function, the other one is a procedure).
\r
1379 332 - incompatible types of virtuals id
\r
1380 Type of virtual function ID is different from type
\r
1381 of replaced function.
\r
1382 333 - different lengths of form.param.lists in virtuals id
\r
1383 Virtual module ID and replaced module have
\r
1384 different number of formal parameters.
\r
1385 334 - conflict kinds of the 1st level parameters id
\r
1386 In the headline of virtual module ID kind of
\r
1387 formal parameter differs from corresponding formal
\r
1388 parameter in the headline of replaced module (e.g.
\r
1389 type and variable, input and output
\r
1391 335 - incompatible types of the 1st level parameters id
\r
1392 There are formal parameters of different types
\r
1393 (function, procedure) in the headline of virtual
\r
1394 module ID and in the headline of replaced module
\r
1395 on the same position.
\r
1396 336 - different lengths of the 2nd level params lists id
\r
1397 There are formal procedures/functions with
\r
1398 different numbers of parameters in the headline of
\r
1399 virtual module ID and in the headline of replaced
\r
1400 module on the same position.
\r
1401 337 - incompatible kinds of the 2nd level parameters id
\r
1402 There are parameters of different kinds on the
\r
1403 same position in the corresponding procedure or
\r
1404 function parameters in the headline of virtual
\r
1405 module ID and in the headline of replaced module.
\r
1406 338 - incompatible types of the 2nd level parameters id
\r
1407 There are parameters of different types on the
\r
1408 same position in the corresponding procedure or
\r
1409 function in the headline of virtual module ID and
\r
1410 in the headline of replaced module.
\r
1411 341 - ***declaration part overloaded
\r
1412 Analogical to error 0.
\r
1413 342 - ***too many classes declared
\r
1414 343 - ***too many prototypes
\r
1415 Too many modules declared on the same level.
\r
1416 350 - undeclared signal identifier id
\r
1417 351 - hidden signal identifier id
\r
1418 Analogical to error 317.
\r
1419 352 - signal identifier not taken id
\r
1420 Analogical to error 318.
\r
1421 353 - signal identifier expected id
\r
1422 Identifier ID placed in handler declaration as a
\r
1423 signal name has not been declared as a signal.
\r
1424 354 - different types of parameters id
\r
1425 In the headlines of signals, that have common
\r
1426 handler, parameters of the different types appear
\r
1427 on the same position. ID is one of these
\r
1429 355 - incompatible kinds of parameters id
\r
1430 In the headlines of signals that have common
\r
1431 handler, parameters of different kinds appear on
\r
1432 the same position. ID is one of these parameters.
\r
1433 356 - different identifiers of parameters id
\r
1434 In the headlines of signals that have common
\r
1435 handler parameters of different names appear on
\r
1436 the same position. ID is one of these parameters.
\r
1437 357 - incompatible kinds of the 2nd level parameters id
\r
1438 Analogous to error 355 for 2-nd level parameters.
\r
1439 358 - different types of the 2nd level parameters id
\r
1440 Analogous to error 354 for the 2-nd level parameters.
\r
1441 359 - different lengths of the 2nd level params lists id
\r
1442 There are formal procedures or formal functions
\r
1443 with different number of parameters on the same
\r
1444 position in the headlines of signals this have
\r
1445 common handler. ID is one of these formal
\r
1446 parameters/functions.
\r
1447 360 - different lengths of form. param. lists in signals id
\r
1448 There are different number of formal parameters in
\r
1449 the signals that have common handler. ID is one of
\r
1451 361 - non-local formal type cannot be used id
\r
1452 Formal parameter ID of signal is of non local
\r
1454 362 - repeated handler for signal id
\r
1455 There are more than one handler for signal ID in
\r
1457 370 - only 'input' is legal here
\r
1458 Formal parameter output or inout is illegal in
\r
1460 398 - class prefixed by itself id
\r
1461 Construction unit ID: ID class is not allowed.
\r
1462 399 - cycle in prefix sequence id
\r
1463 ID is a class identifier used in cyclic prefixing
\r
1464 i.e. ID prefixes a, a prefixes b, ... , z prefixes
\r
1465 ID. This construction is not allowed.
\r
1466 401 - wrong label in 'case' id
\r
1467 Label in case instruction is not a constant.
\r
1468 402 - 'case' statement nested too deeply
\r
1469 Nesting level in case instruction is greater than
\r
1471 403 - too long span of 'case' labels
\r
1472 Range of branches in case instruction is greater
\r
1474 404 - repeated label in 'case'-statement id
\r
1475 Label ID appears more than once in case
\r
1477 405 - illegal type of 'case' expression id
\r
1478 Control expression in case statement is not of
\r
1479 integer or char type.
\r
1480 406 - different types of labels and 'case' expression
\r
1481 407 - non-logical expression after 'if'/'while' id
\r
1482 408 - real constant out of integer range
\r
1483 Error during conversion of real constant to
\r
1484 integer constant.
\r
1485 410 - simple variable expected id
\r
1486 Control variable in for loop is not a simple
\r
1488 411 - non-integer control variable id
\r
1489 Control variable ID in for loop is not of integer
\r
1491 412 - non-integer expression id
\r
1492 Expression placed as array index or bound limit in
\r
1493 array generation or as step in for loop or as
\r
1494 format in write statement should be reducable to
\r
1496 413 - file expression expected id
\r
1497 414 - string expression expected id
\r
1498 415 - reference expression expected id
\r
1499 Expression placed before dot (remote access),
\r
1500 before qua or as a argument of kill or copy
\r
1501 statement is not of class type.
\r
1502 416 - array expression expected id
\r
1503 417 - boolean expression expected id
\r
1504 418 - semaphore variable expected
\r
1505 419 - illegal type in 'open'
\r
1506 The type name placed in open is different than
\r
1507 TEXT, REAL, INTEGER, CHAR and DIRECT.
\r
1508 420 - variable expected id
\r
1509 Expression placed on the left side of assignment
\r
1510 statement or as an argument of read instruction or
\r
1511 in array instruction is not a variable.
\r
1512 421 - class identifier after 'new' expected id
\r
1513 Identifier ID placed after new is not a class
\r
1515 422 - procedure identifier after 'call' expected id
\r
1516 423 - 'new' missing id
\r
1517 Keyword new doesn't appear before class identifier
\r
1518 for object generation.
\r
1519 424 - 'call' missing id
\r
1520 Keyword call doesn't appear before procedure
\r
1521 identifier for procedure call.
\r
1522 425 - 'inner' out of a class
\r
1523 426 - 'inner' occurred more than once
\r
1524 427 - 'wind'/'terminate' out of a handler
\r
1525 428 - 'inner' inside lastwill
\r
1526 429 - definition cannot be reduced to constant id
\r
1527 Identifier ID placed in constant definition is not
\r
1529 430 - undefined constant in the definition id
\r
1530 431 - wrong number of indices id
\r
1531 Number of indices in referencing to array element
\r
1532 is different from declared number of indices.
\r
1533 432 - index out of range id
\r
1534 433 - upper bound less than lower bound id
\r
1535 434 - too many subscripts id
\r
1536 Dimension of static array ID is greater than 7.
\r
1537 435 - variable is not array id
\r
1538 440 - type identifier expected after 'arrayof' id
\r
1539 Identifier ID placed after arrayof in actual
\r
1540 parameter list, corresponding to type parameter is
\r
1542 441 - incorrect format in 'write'
\r
1543 There is format for expression of char type or
\r
1544 there is double format for expression of type
\r
1545 integer or string.
\r
1546 442 - illegal expression in 'write'
\r
1547 Argument of write statement is not of type char,
\r
1548 string, integer or real.
\r
1549 443 - illegal type of variable in 'read' id
\r
1550 Argument of read statement is not of type char,
\r
1552 444 - no data for i/o transfer
\r
1553 There is only file identifier in I/O instruction.
\r
1554 445 - illegal expression in 'put'
\r
1555 446 - illegal expression in 'get'
\r
1556 448 - 'raise' missing id
\r
1557 There is signal identifier without keyword raise
\r
1558 in the context of signal raising.
\r
1559 449 - signal identifier expected id
\r
1560 Identifer ID after keyword raise is not a signal
\r
1562 450 - illegal procedure occurrence id
\r
1563 Procedure name ID appears in illegal context.
\r
1564 451 - illegal class occurrence id
\r
1565 Class name ID appears in illegal context.
\r
1566 452 - illegal type occurrence id
\r
1567 Type name ID appears in illegal context.
\r
1568 453 - illegal signal occurrence id
\r
1569 Signal name ID appears in illegal context.
\r
1570 454 - illegal operator occurence
\r
1571 455 - wrong number of operands
\r
1572 460 - divided by zero
\r
1573 470 - illegal input parameter id
\r
1574 Actual parameter associated with input parameter
\r
1575 is not expression that may have any value: it is
\r
1576 e.g. procedure name
\r
1577 471 - illegal output parameter id
\r
1578 Actual parameter corredponded to output parameter
\r
1579 is not a variable.
\r
1580 472 - illegal type parameter id
\r
1581 Actual parameter ID associated with type parameter
\r
1582 is not a type name.
\r
1583 473 - illegal procedure parameter id
\r
1584 Actual parameter ID associated with procedure
\r
1585 parameter is not a procedure name.
\r
1586 474 - illegal function parameter id
\r
1587 Actual parameter ID associated with function
\r
1588 parameter is not a function name.
\r
1589 475 - illegal left side of 'is'/'in' id
\r
1590 Left side argument ID of is/in is not a reference
\r
1592 476 - illegal right side od 'is'/'in' id
\r
1593 Right side argument ID of is / in is not a class
\r
1595 477 - illegal parameter of 'attach' id
\r
1596 Parameter ID of attach statement is not a
\r
1597 reference variable of class object.
\r
1598 478 - illegal type of expression
\r
1599 479 - negative step value
\r
1600 550 - ***stack overloaded
\r
1601 This error may be removed by dividing expressions
\r
1602 into subexpressions, making simpler nested
\r
1603 callings of arrays, functions, classes and for
\r
1604 loops. This error terminates compilation of
\r
1605 current module, but other modules will be
\r
1607 551 - ***too many auxiliary variables needed
\r
1608 Too complicated expressions. This error may be
\r
1609 removed by declaration of additional variables and
\r
1610 using them as auxiliary variables in expressions.
\r
1611 552 - ***too many auxiliary reference variable needed
\r
1612 Analogical to error 551.
\r
1613 553 - ***statement sequence too long or too complicated
\r
1614 This error may be removed by adding 'goto'
\r
1615 statement into sequence of instructions e.g. if
\r
1616 false then exit fi, inner, ... or by dividing
\r
1617 complicated expression into subexpressions.
\r
1618 554 - ***real constants dictionary overflow
\r
1619 Too many real constant, maybe because of
\r
1620 evaluation of expressions built from real
\r
1622 600 - undeclared identifier id
\r
1623 601 - illegal type before '.' id
\r
1624 Expression placed before dot (remote access) is
\r
1625 not of class type.
\r
1626 602 - close identifier after '.' id
\r
1627 Identifier ID placed after dot is on close list in
\r
1628 the class or its prefix that construct expression
\r
1630 603 - undeclared identifier after '.' id
\r
1631 Identifier ID placed after dot is not attribute of
\r
1632 expression placed before dot. It may be caused by
\r
1633 missing declaration or using bad prefix for class
\r
1634 constructing expression before dot.
\r
1635 604 - illegal operand type id
\r
1636 One of the arguments in arithmetical expression or
\r
1637 in relation is not of arithmetical type.
\r
1638 605 - illegal type in 'div/'mod' term id
\r
1639 Expression identified by ID used as argument of
\r
1640 div or mode operation is not of integer type.
\r
1641 606 - incompatible types in comparison id
\r
1642 ID is an identifier of left argument of relation.
\r
1643 607 - unrelated class types in comparison id
\r
1644 ID is an identifier of left argument of relation.
\r
1645 Both arguments are of class type and none of these
\r
1646 classes prefixes the other one.
\r
1647 608 - string cannot be compared id
\r
1648 ID identifies a string.
\r
1649 609 - incompatible types in assignment/transmission id
\r
1650 ID is an identifier of left side of assignment
\r
1651 statement or an identifier of actual parameter in
\r
1652 object generation. Types of both sides of
\r
1653 instruction or type of formal parameter and type
\r
1654 of actual parameter are incompatible.
\r
1655 610 - unrelated class types in assignment/transmission id
\r
1656 Analogical to errors 609 and 607.
\r
1657 611 - constant after '.' id
\r
1658 An attempt to remote access to constant.
\r
1659 612 - this class does not occur in sl-chain id
\r
1660 Class ID appeared in expression this ID, but ID
\r
1661 dosn't prefix any module in SL chain of actual
\r
1662 module. It may be a cycle.
\r
1663 613,614 - class identifier expected id
\r
1664 For error 613: identifier ID used in expression
\r
1665 this ID is not of class type.
\r
1666 For error 614: identifier ID used in expression
\r
1667 this ID is not name of any type.
\r
1668 615 - illegal type before 'qua' id
\r
1669 Object expression before qua should be of one of
\r
1670 the types: class, coroutine, process or simple
\r
1671 (not array) formal type.
\r
1672 616,617 - illegal type after 'qua' id
\r
1673 For error 616: identifier ID used after qua is not
\r
1675 For error 617: identifier ID used after qua is not
\r
1677 618 - unrelated types in 'qua'-expression id
\r
1678 Identifier ID is a name of class type used after
\r
1679 qua. This class type and class type used before
\r
1680 qua doesn't prefix each other.
\r
1681 619 - hidden identifier id
\r
1682 Identifier ID used in construction qua ID or this
\r
1683 ID is on hidden list in the prefix of one of the
\r
1684 module from SL chain of actual module.
\r
1685 620 - not taken identifier id
\r
1686 Identifier ID used in construction qua ID or this
\r
1687 ID is not on taken list in any prefix of any
\r
1688 module of actual module.
\r
1689 621 - invisible identifier after '.' id
\r
1690 Identifier ID placed after dot is on hidden list
\r
1691 or is not on taken list in prefix.
\r
1692 622 - formal parameter list is shorter id
\r
1693 Identifier ID identifies generated object: class,
\r
1694 procedure or function. Formal parameters list of
\r
1695 this object is shorter than actual parameters
\r
1697 623 - formal parameter list is longer id
\r
1698 Analogical to error 622.
\r
1699 624 - actual parameter is not a reference type id
\r
1700 Actual parameter identified by ID in generated
\r
1701 object can't be of primitive type: integer, real,
\r
1702 boolean or string.
\r
1703 625 - actual parameter is not a type id
\r
1704 Actual parameter identified by ID is not a type,
\r
1705 so it can't replace formal type parameter.
\r
1706 626 - procedure-function conflict between parameters id
\r
1707 Actual parameter, identified by ID, that replaced
\r
1708 formal parameter in generated object is function
\r
1709 whereas formal parameter is a procedure or vice
\r
1711 627 - unmatched heads-wrong kinds of parameters id
\r
1712 ID identifies actual module that replaced formal
\r
1713 module. There are parameters of different kinds on
\r
1714 the same position in the headlines of these
\r
1715 modules. For input - output conflict the agreement
\r
1716 of parameter types is checked also.
\r
1717 628 - unmatched heads-incompatible types in lists id
\r
1718 ID identifies actual module that replaced formal
\r
1719 module. There are input /output parameters of
\r
1720 different types on the same position in the
\r
1721 headlines of actual and formal module.
\r
1722 629 - unmatched heads-unrelated class types in lists id
\r
1723 ID identifies actual module that replaced formal
\r
1724 module. There are input/output parameters
\r
1725 specifying classes of disjointed prefix sequences
\r
1726 in the headlines of actual and formal module.
\r
1727 630 - unmatched heads-different numbers of parameters id
\r
1728 There are different lengths of headlines in actual
\r
1729 module identified by ID and formal module.
\r
1730 631 - incompatible types of function parameters id
\r
1731 There are different types of actual function
\r
1732 specified by identifier ID and formal function in
\r
1733 generated object.
\r
1734 632 - function/procedure expected id
\r
1735 Actual parameter identified by identifier ID is
\r
1736 not function/procedure, whereas corresponding
\r
1737 formal parameter is function/procedure.
\r
1738 633 - actual function type defined weaker than formal id
\r
1739 Type of actual function identified by ID is weaker
\r
1740 defined than formal function type e.g. formal
\r
1741 function type is statically defined, whereas
\r
1742 actual function type is formal (external) or
\r
1743 formal function is class, whereas actual function
\r
1744 type is coroutine or process.
\r
1745 634 - unmatched heads-too weak type in actual list id
\r
1746 There are input/output parameters on the same
\r
1747 position in the headlines of actual module
\r
1748 identified by identifier ID and formal module, but
\r
1749 ID is weaker defined than corresponding formal
\r
1750 module parameter (see error 633).
\r
1751 635 - standard function/procedure cannot be actual par. id
\r
1752 ID identifies standard procedure/function used as
\r
1753 actual parameter.
\r
1754 636 - illegal use of semaphore id
\r
1755 637 - 'semaphore' cannot be used id
\r
1758 APPENDIX E : LOGLAN RUNTIME ERRORS
\r
1760 In the following list system signal name, raised after detection of
\r
1761 runtime error, is placed in brackets.
\r
1763 ARRAY INDEX ERROR (CONERROR)
\r
1764 Index outside range during reference to array variable.
\r
1765 NEGATIVE STEP VALUE (CONERROR)
\r
1766 SL CHAIN CUT OFF (LOGERROR)
\r
1767 Control transfer to object that has SL link cut off earlier in
\r
1768 the consequence of kill operation.
\r
1769 ILLEGAL ATTACH (LOGERROR)
\r
1770 The value of parameter of attach instruction is none or object
\r
1771 differs from coroutine.
\r
1772 ILLEGAL DETACH (LOGERROR)
\r
1773 An attempt to return by detach to coroutine that has been
\r
1774 dealocated (by kill).
\r
1775 ILLEGAL RESUME (LOGERROR)
\r
1776 An attempt to resume an object which is not a process or a
\r
1777 process which is running.
\r
1778 TOO MANY PROCESSES ON ONE MACHINE (SYSERROR)
\r
1779 Number of processes existing on one computer is greater than 64.
\r
1780 INVALID NODE NUMBER (SYSERROR)
\r
1781 An attempt to create a process on a computer which is not
\r
1782 connected to network.
\r
1783 IMPROPER QUA (LOGERROR)
\r
1784 Error during computing expression of the form: ...x qua a, when
\r
1785 'x' references to none or 'a' doesn't prefix dynamic type object,
\r
1786 which is value of 'x'.
\r
1787 ILLEGAL ASSIGNMENT (TYPERROR)
\r
1788 Type conflict between left and right side of assignment
\r
1790 FORMAL TYPE MISSING (LOGERROR)
\r
1791 Formal type is not accessible because of SL cut off.
\r
1792 ILLEGAL KILL (LOGERROR)
\r
1793 An attempt to deallocate object in SL chain of active object.
\r
1794 ILLEGAL COPY (LOGERROR)
\r
1795 An attempt to copy non terminated object (i.e. class before
\r
1796 execution of return statement, coroutine before execution of end
\r
1798 REFERENCE TO NONE (ACCERROR)
\r
1799 An attempt to remote access (by dot) to attributes of non
\r
1800 existing object: dealocated or not generated.
\r
1801 MEMORY OVERFLOW (MEMERROR)
\r
1802 INCOMPATIBLE HEADERS (TYPERROR)
\r
1803 Actual parameter list of generated object (procedure, function
\r
1804 or class) is incompatible with formal parameter list from module
\r
1805 declaration or formal function type is incompatible with actual
\r
1807 INCORRECT ARRAY BOUNDS (CONERROR)
\r
1808 An attempt to generate dynamic array object, when lower bound of
\r
1809 index range is greater than upper bound.
\r
1810 DIVISION BY ZERO (NUMERROR)
\r
1811 COROUTINE TERMINATED (LOGERROR)
\r
1812 An attempt to transfer control to a terminated coroutine.
\r
1813 COROUTINE ACTIVE (LOGERROR)
\r
1814 An attempt to transfer control to an active coroutine.
\r
1815 HANDLER NOT FOUND (LOGERROR)
\r
1816 There is no handler for signal declared by user.
\r
1817 ILLEGAL RETURN (LOGERROR)
\r
1818 An attempt to execute return instruction in handler serving
\r
1820 UNIMPLEMENTED STANDARD PRC. (LOGERROR)
\r
1821 Standard procedure or function is not implemented.
\r
1822 FORMAL LIST TOO LONG (MEMERROR)
\r
1823 Formal parameter list is greater than 40.
\r
1824 ILLEGAL I/O OPERATION (SYSERROR)
\r
1825 Reading after writing, the type of the read/write parameter does
\r
1826 not match the type of the file etc.
\r
1827 I/O ERROR (SYSERROR)
\r
1828 System error during I/O.
\r
1829 CANNOT OPEN FILE (SYSERROR)
\r
1830 INPUT DATA FORMAT BAD (SYSERROR)
\r
1831 SYSTEM ERROR (SYSERROR)
\r
1833 UNRECOGNIZED ERROR
\r
1835 APPENDIX F : CHARACTER SET
\r
1838 At the top of the table are hexadecimal digits (0 to 7), and to the
\r
1839 left of the table are hexadecimal digits (0 to F). Hexadecimal code of
\r
1840 ASCII character is constructed by contatenation of column label and
\r
1841 row label. For example, the value of character representing the plus
\r
1846 _________________________________________________
\r
1847 ! ! ! ! ! ! ! ! !
\r
1848 0 ! NUL ! DLE ! SP ! 0 ! @ ! P ! ! p !
\r
1849 _________________________________________________
\r
1850 ! ! ! ! ! ! ! ! !
\r
1851 1 ! SOH ! DC1 ! ! ! 1 ! A ! Q ! a ! q !
\r
1852 _________________________________________________
\r
1853 ! ! ! ! ! ! ! ! !
\r
1854 2 ! STX ! DC2 ! " ! 2 ! B ! R ! b ! r !
\r
1855 _________________________________________________
\r
1856 ! ! ! ! ! ! ! ! !
\r
1857 3 ! ETX ! DC3 ! # ! 3 ! C ! S ! c ! s !
\r
1858 _________________________________________________
\r
1859 ! ! ! ! ! ! ! ! !
\r
1860 4 ! EOT ! DC4 ! $ ! 4 ! D ! T ! d ! t !
\r
1861 _________________________________________________
\r
1862 ! ! ! ! ! ! ! ! !
\r
1863 5 ! ENQ ! NAK ! % ! 5 ! E ! U ! e ! u !
\r
1864 _________________________________________________
\r
1865 ! ! ! ! ! ! ! ! !
\r
1866 6 ! ACK ! SYN ! & ! 6 ! F ! V ! f ! v !
\r
1867 _________________________________________________
\r
1868 ! ! ! ! ! ! ! ! !
\r
1869 7 ! BEL ! ETB ! ' ! 7 ! G ! W ! g ! w !
\r
1870 _________________________________________________
\r
1871 ! ! ! ! ! ! ! ! !
\r
1872 8 ! BS ! CAN ! ( ! 8 ! H ! X ! h ! x !
\r
1873 _________________________________________________
\r
1874 ! ! ! ! ! ! ! ! !
\r
1875 9 ! HT ! EM ! ) ! 9 ! I ! Y ! i ! y !
\r
1876 _________________________________________________
\r
1877 ! ! ! ! ! ! ! ! !
\r
1878 A ! LF ! SUB ! * ! : ! J ! Z ! j ! z !
\r
1879 _________________________________________________
\r
1880 ! ! ! ! ! ! ! ! !
\r
1881 B ! VT ! ESC ! + ! ; ! K ! [ ! k ! { !
\r
1882 _________________________________________________
\r
1883 ! ! ! ! ! ! ! ! !
\r
1884 C ! FF ! FS ! , ! < ! L ! \ ! l ! | !
\r
1885 _________________________________________________
\r
1886 ! ! ! ! ! ! ! ! !
\r
1887 D ! CR ! GS ! - ! = ! M ! ] ! m ! } !
\r
1888 _________________________________________________
\r
1889 ! ! ! ! ! ! ! ! !
\r
1890 E ! SO ! RS ! . ! > ! N ! ^ ! n ! ~ !
\r
1891 _________________________________________________
\r
1892 ! ! ! ! ! ! ! ! !
\r
1893 F ! SI ! US ! / ! ? ! O ! _ ! o ! DEL !
\r
1894 _________________________________________________
\r
1898 NUL Null DLE Data Link Escape
\r
1899 SOH Start of Heading DC1 Device Control 1
\r
1900 STX Start of Text DC2 Device Control 2
\r
1901 ETX End of Text DC3 Device Control 3
\r
1902 EOT End of Transmission DC4 Device Control 4
\r
1903 ENQ Enquiry NAK Negative Acknowledge
\r
1904 ACK Acknowledge SYN Synchronous Idle
\r
1905 BEL Bell ETB End of Transmission Block
\r
1906 BS Backspace CAN Cancel
\r
1907 HT Horizontal Tabulation EM End of Medium
\r
1908 LF Line Feed SUB Substitute
\r
1909 VF Vertical Tab ESC Escape
\r
1910 FF Form Feed FS File Separator
\r
1911 CR Carriage Return GS Group Separator
\r
1912 SO Shift Out RS Record Separator
\r
1913 SI Shift In US Unit Separator
\r
1914 SP Space DEL Delete
\r
1921 1. Report on the Loglan-82 Programming Language.
\r
1922 2. IIUWGRAF biblioteka podstawowych procedur graficznych.
\r
1923 3. Microsoft (R) Mouse User's Guide.
\r
projects / loglan.git / blob