43 Institute of Informatics
\r
44 University of Warsaw
\r
47 revised October 1993
\r
55 {TOC \o|0. PREFACE 3
\r
56 1. USING LOGLAN-82 SYSTEM 3
\r
58 1.2. COMPILER SWITCHES 4
\r
59 1.3. CODE GENERATION 4
\r
60 1.4. PROGRAM INTERPRETATION 5
\r
61 1.5. COMPILE TIME ERRORS 6
\r
62 1.6. RUN-TIME ERRORS 6
\r
63 2. COMPILER OPTIONS 6
\r
64 2.1. OPTION FORMAT 7
\r
66 3. CURRENT LOGLAN-82 IMPLEMENTATION SPECIFICATION 8
\r
67 3.1. IMPLEMENTED SUBSET OF LOGLAN 8
\r
68 3.2. PREDEFINED LANGUAGE ELEMENTS 8
\r
70 3.3.1. FILE VARIABLES 8
\r
71 3.3.2. FILE GENERATION 9
\r
72 3.3.3. FILE DEALLOCATION 9
\r
73 3.3.4. GENERAL FILE OPERATIONS 9
\r
74 3.3.5. TEXT FILES 10
\r
75 3.3.6. BINARY SEQUENTIAL FILES 10
\r
76 3.3.7 DIRECT ACCESS BINARY FILES 10
\r
78 3.4.1. INVOKING THE LOGLAN INTERPRETER FOR CONCURRENT PROGRAMS 11
\r
79 3.4.2. RESTRICTIONS AND DIFFERENCES FROM THE REPORT 12
\r
80 3.4.3. COMMUNICATION MECHANISM 13
\r
81 3.5. SYSTEM SIGNALS 15
\r
82 3.6. IMPLEMENTATION RESTRICTIONS 15
\r
85 A : PREDEFINED CONSTANTS 16
\r
86 B : PREDEFINED CLASSES 16
\r
87 C : PREDEFINED PROCEDURES AND FUNCTIONS 20
\r
89 E : LOGLAN RUNTIME ERRORS 34
\r
90 F : CHARACTER SET 36
\r
94 II. Algorithmic Logic 39
\r
95 III. Related literature 40
\r
98 This document provides information necessary to compile and execute Loglan programs.
\r
99 This manual assumes basic knowledge of Loglan-82 language, described in "Report on the Loglan Programming Language" (see Bibliography).
\r
100 1. USING LOGLAN-82 SYSTEM
\r
101 The following three steps are required to execute a Loglan program:
\r
102 {SYMBOL 183 \f "Symbol" \s 10 \h} Compilation (to intermediate code),
\r
103 {SYMBOL 183 \f "Symbol" \s 10 \h} Generation of the interpreted code (from intermediate code),
\r
104 {SYMBOL 183 \f "Symbol" \s 10 \h} Interpretation (i.e. execution of program).
\r
107 Compilation is accomplished by invoking Loglan compiler. This step creates two destination files: the intermediate code file and the listing file. The intermediate code file is the input file for the second step: generation of the code accepted by interpreter.In this step two files containing object code are produced. They are the input files for the third step: interpretation. This step is equivalent to execution of a program.
\r
110 To invoke the Loglan compiler without specifying any command line parameters, type:
\r
112 Then the prompt appears on your terminal:
\r
114 and the compiler waits for file specification.The default extension is LOG.
\r
115 The compiler will produce (optionally) listing file with the same file name and the extension LST and will produce, if no error occurs, the code file with the extension LCD. Destination files will be stored on the same drive and directory as the source file.
\r
121 File name: PROGRAM <ENTER>
\r
123 Loglan compiler compiles program from PROGRAM.LOG file and creates PROGRAM.LCD.
\r
126 $ LOGLAN A:PROGRAM1 or
\r
129 In this case the source file is A:PROGRAM.DAT. The file PROGRAM.LCD will be created on drive A.
\r
131 $ LOGLAN /home/vous/PROGRAM2
\r
133 If any error occurs, the code file is not produced. At the end of compilation the following message is printed:
\r
134 <number of errors> error(s) detected {SYMBOL 168 \f "ZapfDingbats"}
\r
135 1.2. COMPILER SWITCHES
\r
136 There are two possibilities to specify compiler's options: by compiler switches (i.e. external options) or by comments in the source program (see chapter 2.). You may enter the compiler switches in command line after file name in the following format:
\r
137 sw1 sw2... swk <return>
\r
138 where swi consists of character that designates the name of the option and either '+' or '-'.
\r
144 $ LOGLAN PROGRAM L- T+
\r
148 In this case the default switches values are assumed. {SYMBOL 168 \f "ZapfDingbats"}
\r
151 Scope of the switch is the entire program. All switches ,except H, correspond to options. A switch has greater priority then options: when you specify switch, all corresponding options inside source program will be ignored. Full description of each option is given in chapter 2.2. Switch L has additional significance. When this switch is set off no listing file is produced.
\r
152 1.3. CODE GENERATION
\r
153 In this step information from the intermediate code file is read and two destination files containing the code are produced. No switch is permitted for this step. To generate code files, type:
\r
155 or HGEN <file name>, if the switch H+ was specified for the compiler.(DOS/AT only)
\r
157 You type file name without extension (extension is ignored).
\r
164 FILE_NAME: PROGRAM
\r
165 Information is read from file PROGRAM.LCD from default drive and directory. Two destination files are produced: PROGRAM.CCD and PROGRAM.PCD and stored in the same directory as the input file.
\r
168 $ GEN /home/vous/PROGRAM2
\r
170 Files PROGRAM.CCD and PROGRAM.PCD are stored on drive A. {SYMBOL 169 \f "Symbol"}
\r
171 1.4. PROGRAM INTERPRETATION
\r
172 To interprete (execute) the Loglan program you must invoke the interpreter INT or HINT (if the switch H+ was specified). File name must be specified in command line. The file extension is ignored. The interpreter reads input files with the given name and extensions CCD and PCD and executes the Loglan program.
\r
173 The syntax for calling the interpreter is
\r
175 INT <options> <file name>
\r
177 HINT <options> <file name> (DOS/AT only)
\r
179 The following options are supported:
\r
181 /m < n > set memory size for Loglan program (in 16 bit words for small and 32 bit words for huge memory). For concurrent programs it means memory size for every process.
\r
182 /i information about garbage collection-compactification is printed.
\r
183 /r < n > used to invoke interpreter on nodes different from console (see 3.4.). option parameter is console node number (as defined by D-Link Network).
\r
184 /d causes trace to be printed to the file with .TRD extension provided that the option or switch D+ was used during compiling.
\r
187 At the end of interpretation the following message is printed:
\r
189 End of LOGLAN-82 program execution
\r
194 $ LOGLAN \DAT\EXAMP.SRC, L+
\r
197 The file \DAT\EXAMP.LCD and \DAT\EXAMP.LST are generated.
\r
201 The files \DAT\EXAMP.CCD and \DAT\EXAMP.PCD are created. {SYMBOL 168 \f "ZapfDingbats"}
\r
203 Then the program can be interpreted by:
\r
206 1.5. COMPILE TIME ERRORS
\r
207 The errors detected during the compilation are printed on the listing file, if this file is created. In the scope of option L- or if the switch L is set off only the incorrect lines and errors messages are printed . When the switch ( not option !) L is set off then listing file is not produced and incorrect lines and error messages are printed on the user's terminal.
\r
208 Error message has the following format:
\r
210 *** ln ERROR en txt id
\r
213 ln - index of incorrect line,
\r
214 en - error code (see Appendix B),
\r
215 txt- text that explain type of the error,
\r
216 id - identifier helpful to situate the error.
\r
218 Error messages are printed in the source listing after incorrect lines.
\r
219 For syntax errors (numbered 101-147, 201-212), sign '?' indicates the error's position in the line.
\r
220 Error may be detected beyond the line containing it.
\r
221 Identifier helpful to find an error is printed as soon as possible.
\r
223 For codes 331-338 error message is printed after first line of virtual module declaration.
\r
224 Errors like "undeclared identifier" are printed in each module once, after first reference to this identifier. Further references are ignored.
\r
225 The errors related to case instruction may appear before the incorrect line.
\r
226 1.6. RUN-TIME ERRORS
\r
227 Loglan run-time errors are detected by Loglan run-time system. When any of these errors occurs, the appropriate system signal is raised and error message is printed if handler is not found. All of these error messages are described in Appendix C. moreover the line number of the last executed statement is printed on the user's terminal.
\r
228 2. COMPILER OPTIONS
\r
229 Options, like switches are used to pass some information to the compiler. Options are placed in source program in comments. Scope of options in source program is textual. Option may appear in any place of source program, but it is active from the beginning of the nearest instruction. Listing option L is active from the next line after line containing setting this option on up to the line containing setting this option off. Options overwrite defaults, but are overwritten by switches (external options). Option definition is not allowed before the keyword program.
\r
230 2.1. OPTION FORMAT
\r
231 Options may be placed in source program in comments in the following format:
\r
233 where opti consists of character that designates the option and either '+' or '-' e.g.: (*$L-,T+*). Options in one comment should be separated by commas. Spaces in such comment are not allowed.
\r
239 D+ - causes the line numbers of the executed instruction to be printed,
\r
242 L- - default, only incorrect lines are printed on the terminal
\r
243 L+ - all lines are printed on the listing file
\r
245 O+ - optimization of some arithmetical and logical expressions are included to generated code (default),
\r
246 O- - generate code without optimization,
\r
247 T - type conflict checking
\r
248 T+ - default, dynamic checking of type conflict in assignment instructions and in parameter transmissions,
\r
249 T- - no dynamic checking
\r
250 H - memory model (switch only) APPLIES ONLY to PC/AT/XT !!
\r
251 H- - default, small memory
\r
254 PC/AT/XT When H- is specified all code and data must fit into 64K
\r
255 bytes. When H+ is specified all memory available on IBM PC
\r
256 may be utilized, with the cost of increased execution time.
\r
257 3. CURRENT LOGLAN-82 IMPLEMENTATION SPECIFICATION
\r
258 3.1. IMPLEMENTED SUBSET OF LOGLAN
\r
259 The following constructions described in the report of Loglan-82 have not been implemented:
\r
260 - local attributes,
\r
261 - separate compilation,
\r
262 File system is described in 3.3.
\r
263 3.2. PREDEFINED LANGUAGE ELEMENTS
\r
264 Predefined constants, procedures and functions are added to the language (see Appendix A). Moreover keywords char (short form of character) and bool (short form of boolean) are added.
\r
265 The character set, defined in the report of Loglan-82, is extended by lower-case letters and the tabulation character (decimal code 9). It is possible to use operator '<>' which stands for 'not equal'.
\r
267 Loglan contains the predefined reference type file and a set of statements and standard procedures to manipulate files.
\r
268 Both sequential and direct access files are implemented.
\r
269 3.3.1. FILE VARIABLES
\r
270 Variables of the type file can be declared in the Loglan program and can be used as any variables of a reference type.
\r
277 unit p:procedure(f:file); ... end p;
\r
283 3.3.2. FILE GENERATION
\r
284 A file object is generated by open statement of the form:
\r
286 open(f,T) for internal files or
\r
288 open(f,T,A) for external files
\r
291 f is a file variable,
\r
293 T = text for text files,
\r
294 char for binary sequential files of character,
\r
297 direct for direct access binary files.
\r
299 A is an expression of the type arrayof char designating external file name. After execution of open statement the new file object is created and it becomes a value of the file variable f. If the file is opened as an external one, then it references to the file A.
\r
304 open(data,text) - new internal text file data is opened
\r
305 open(num ,integer) - new internal binary file num is opened
\r
306 (the file components are integer numbers)
\r
307 open(f,text,unpack("my.dat")) - external text file f is opened;
\r
308 it references to the file my.dat stored on the default drive and directory.
\r
309 open(f,direct,A) - an external direct access file with name in array A is opened.
\r
310 3.3.3. FILE DEALLOCATION
\r
311 The file can be closed and deallocated by execution of the statement kill.
\r
312 3.3.4. GENERAL FILE OPERATIONS
\r
313 There are three standard procedures associated with files: RESET, REWRITE and UNLINK.
\r
315 call RESET(f) rewinds the file f. After execution of RESET on sequential files only read/get operations are available.
\r
317 call REWRITE(f) creates a new empty file. After execution of REWRITE on sequential files only write/put operations are available.
\r
319 call UNLINK(f) closes and deletes file f. File object is deallocated and f is set to one.
\r
321 RESET or REWRITE must be performed on the file opening before the first I/O operation on it.
\r
323 The following operations are available to text files: read, readln, eoln, write, writeln, eof. The first parameter of the operation is a file variable. If it is omitted, then a standard input/output file assigned to user's terminal is used.
\r
333 writeln(g," .... ");
\r
334 if eof(f) then ....
\r
337 For more information see [1].
\r
338 3.3.6. BINARY SEQUENTIAL FILES
\r
339 Any file created with the parameter T = integer, real or char is a binary one. It is a sequence of components of the type T. Only objects of type T can be read from or written to this file.
\r
340 The following operations are available to binary files:
\r
341 put(f, w1, ..., wn)
\r
342 get(f, x1, ..., xn)
\r
345 where f is a file opened with the type T, wi is an expression of the type T and xi is a variable of the type T.
\r
346 The statement put(f, w1, ..., wn) writes the components w1, ...,wn to the file f. The statement get(f, x1, ..., xn) reads the next n components from the file f and assigns them to the variables x1, ..., xn. The statement eof is the same as for text files.
\r
347 3.3.7 DIRECT ACCESS BINARY FILES
\r
348 Direct access files are treated as a sequence of bytes without any interpretation. Operations RESET and REWRITE prepare a file for both reading and writing. RESET is used for existing files,
\r
349 REWRITE for the new ones.
\r
350 The following additional operations are available:
\r
352 call SEEK(f, offset, base) - moves the file pointer to the position designated by offset relative to base.
\r
353 Offset is a signed integer specifying the number of bytes.
\r
354 Possible values for base are:
\r
355 0 - begining of file,
\r
356 1 - current position of file pointer,
\r
357 2 - end of the file.
\r
361 call SEEK(f, 0, 0) - rewinds file f,
\r
362 call SEEK(f, -3, 1) - backspaces file f by 3 bytes,
\r
363 call SEEK(f, 0, 2) - moves the file pointer to the first byte after end of file
\r
365 POSITION(f) - returns current position of the file pointer associated with f.
\r
367 PUTREC(f, A, n) - where A is an array of any primitive type and n is an integer variable. Let k be the number of bytes occupied by elements of array A. This operation writes min(k, n) bytes from A to the file f and advances file pointer by the number of written bytes. The number of bytes written to the file is returned in the variable n.
\r
370 GETREC(f, A, n) - where A is an existing array of any primitive type and n is an integer variable. Let k be the number of bytes occupied by elements of array A This operation reads min(k,n) bytes (or less, if end of file is encountered) from the file and advances the file pointer by the number of read bytes. The number of bytes read from the file is returned in the variable n.
\r
372 Implemented concurrency mechanisms differ much from those described in the LOGLAN-82 report []. In particular, only distributed processes are implemented, so they cannot communicate through shared variables. For this reason semaphores had to be replaced by an entirely new communication mechanism. Such a mechanism has been designed and it is based on the rendez-vous schema.
\r
373 3.4.1. INVOKING THE LOGLAN INTERPRETER FOR CONCURRENT ROGRAMS
\r
374 A concurrent LOGLAN program may run on a single computer with concurrency simulated by time slicing. In this case LOGLAN interpreter is invoked as usual. One must only remember that /m optional parameter (see 1.4.) denotes memory size for each process rather than for the whole program.
\r
375 To achieve true parallel (multiprocessor) execution, a network of IBM PC computers may be used. For the time being, only D-Link Network Version 3.21 is supported. In order to run a LOGLAN program in the network environment take the following steps:
\r
376 1) make sure that every node is logged on,
\r
377 2) select arbitrarily one node as a console,
\r
378 3) invoke the LOGLAN interpreter on every node except the console, giving it /r option with the console node number (see 1.4.). You must give the same program file to all interpreters. Most conveniently it may be achieved by accessing a file on a disk connected through the network to each node.
\r
379 4) invoke the interpreter on the console without the /r option (in the usual way). Give it the same program file as above.
\r
381 After the last step the main program process begins its execution on the console node. Other processes may be created dynamically on any node on which an interpreter is running.
\r
383 Regardless of the fact whether the network is used or not, more than one process may be executed on the same computer.
\r
385 3.4.2. RESTRICTIONS AND DIFFERENCES FROM THE REPORT
\r
386 All processes (even those executed on the same computer) are implemented as distributed, i.e. without any shared memory. This fact implies some restrictions on how processes may be used. Not all restrictions are enforced by the present compiler, so it is the programmer's responsibility to respect them. This is the list of restrictions:
\r
388 1) all process units must be declared as global, i.e. directly inside the main program,
\r
389 2) a process cannot access global variables (except for the main program process),
\r
390 3) any remote access to a process object other than a procedure call is inhibited
\r
391 4) each parameter of
\r
392 {SYMBOL 183 \f "Symbol" \s 10 \h} a process,
\r
393 {SYMBOL 183 \f "Symbol" \s 10 \h} a procedure called by remote access to a process object,
\r
394 {SYMBOL 183 \f "Symbol" \s 10 \h} a procedure parameter of a process,
\r
395 must be one of the following:
\r
396 {SYMBOL 183 \f "Symbol"} a value of the primitive type (Integer, Real, Char, Boolean, String)
\r
397 {SYMBOL 183 \f "Symbol"} a procedure declared directly inside a process
\r
398 {SYMBOL 183 \f "Symbol"} a procedure which is a formal parameter of a process
\r
399 {SYMBOL 183 \f "Symbol"} any reference to a process object.
\r
400 This restriction implies that references to objects other than processes have only local meaning (in a single process) and cannot be passed among the processes.
\r
401 5) comparisons, IS, IN and QUA operations are not allowed for the references to processes.
\r
402 6) operations which require dynamic type checking on the references to processes are not allowed.
\r
403 7) a process may be attached only by a proper coroutine generated by it.
\r
404 8) the variable MAIN is accesible only in the main program process.
\r
406 The following concurrent constructs described in the report are not implemented at all:
\r
408 - semaphores and all operations on them
\r
409 - the WAIT expression.
\r
411 Semantics of the NEW generator is slightly modified when applied to the processes. The first parameter of the first process unit in the prefix sequence must be of type INTEGER. This parameter denotes the node number of the computer on which this process will be created. For a single computer operation this parameter must be equal to 0.
\r
415 unit A:class(msg:string);
\r
418 unit P:A process(node:integer, pi:real);
\r
426 (* Create process on node 4. The first parameter is the *)
\r
427 (* string required by the prefix A, the second is the node number *)
\r
428 x := new P("Hello", 4, 3.141592653);
\r
433 The following parallel constructs are implemented as defined in the report:
\r
435 - KILL operation for a process
\r
437 - STOP statement without parameter.
\r
438 3.4.3. COMMUNICATION MECHANISM
\r
439 Processes may communicate and synchronize by a mechanism based on rendez-vous. It will be referred to as "alien call" in the following description.
\r
441 An alien call is either:
\r
442 - a procedure (or function) call performed by a remote access to a process object, or
\r
443 - a call of a procedure which is a formal parameter of a process, or
\r
444 - a call of a procedure which is a formal parameter of an alien-called procedure (this is a recursive definition).
\r
446 Every process object has an enable mask. It is defined as a subset of all procedures declared directly inside a process unit or any unit from its prefix sequence (i.e. subset of all procedures that may be alien-called).
\r
447 A procedure is enabled in a process if it belongs to that process' enable mask. A procedure is disabled if it does not belong to the enable mask.
\r
448 Immediately after generation of a process object its enable mask is empty (all procedures are disabled).
\r
449 Semantics of the alien call is different from the remote call described in the report. Both the calling process and the process in which the procedure is declared (i.e. the called process) are involved in the alien call. This way the alien call may be used as a synchronization mechanism.
\r
450 The calling process passes the input parameters and waits for the call to be completed.
\r
451 The alien-called procedure is executed by the called process. Execution of the procedure will not begin before certain conditions are satisfied. First, the called process must not be suspended in any way. The only exception is that it may be waiting during the ACCEPT statement (see below). Second, the procedure must be enabled in the called process.
\r
452 When the above two conditions are met the called process is interrupted and forced to execute the alien-called procedure (with parameters passed by the calling process).
\r
453 Upon entry to the alien-called procedure all procedures become disabled in the called process.
\r
454 Upon exit the enable mask of the called process is restored to that from before the call (regardless of how it has been changed during the execution of the procedure). The called process is resumed at the point of the interruption. The execution of the ACCEPT statement is ended if the called process was waiting during the ACCEPT (see below).
\r
455 At last the calling process reads back the output parameters and resumes its execution after the call statement.
\r
457 The process executing an alien-called procedure can easily be interrupted by another alien call if the enable mask is changed.
\r
459 There are some new language constructs associated with the alien call mechanism. The following statements change the enable mask of a process:
\r
461 enables the procedures with identifiers p1, ..., pn. If there are any processes waiting for an alien call of one of these procedures, one of them is chosen and its request is processed. The scheduling is done on a FIFO basis, so it is strongly fair. The statement:
\r
462 DISABLE p1, ..., pn
\r
463 disables the procedures with identifiers p1, ..., pn.
\r
464 In addition a special form of the RETURN statement:
\r
465 RETURN ENABLE p1, ..., pn DISABLE q1, ..., qn
\r
466 allows to enable the procedures p1, ..., pn and disable the procedures q1,...,qn after the enable mask is restored on exit from the alien-called procedure. It is legal only in the alien-called procedures (the legality is not enforced by the compiler).
\r
467 A called process may avoid busy waiting for an alien call by means of the ACCEPT statement:
\r
469 adds the procedures p1, ..., pn to the current mask, and waits for an alien call of one of the currently enabled procedures. After the procedure return the enable mask is restored to that from before the ACCEPT statement.
\r
471 Note that the ACCEPT statement alone (i.e. without any ENABLE/DISABLE statements or options) provides a sufficient communication mechanism. In this case the called process may execute the alien-called procedure only during the ACCEPT statement (because otherwise all procedures are disabled). It means that the enable mask may be forgotten altogether and the alien call may be used as a pure totally synchronous rendez-vous. Other constructs are introduced to make partially asynchronous communication patterns possible.
\r
474 3.5. SYSTEM SIGNALS
\r
475 System signals are connected to runtime errors (see APPENDIX C).
\r
477 These signals are the following:
\r
479 ACCERROR - reference to non existing object,
\r
480 CONERROR - array index outside the range or lower bound is greater than upper bound during array object generation,
\r
481 LOGERROR - errors related to control transfer,
\r
482 MEMERROR - memory overflow,
\r
483 NUMERROR - errors related to arithmentic operations like division by zero, floating point overflow,
\r
484 TYPERROR - type conflict in assignment statement, during parameter transmission or headline conflict for actual parameter function and procedure.
\r
485 SYSERROR - errors related to file system, like reading after writing, too many files etc.
\r
486 3.6. IMPLEMENTATION RESTRICTIONS
\r
487 - Text line in source program can't be longer than 80 characters.
\r
488 - Maximal length of identifier is 20 characters, but entire length of all identifiers and keywords should be less than 3000 characters.
\r
489 - String constant can't be longer than 260 characters.
\r
490 - For case instructions:
\r
491 - up to 6 levels of nested case instructions are allowed,
\r
492 - range of labels can't be greater than 160.
\r
493 - Number of formal parameters can't be greater than 40, whereas up to 35 output or input parameters are allowed. Total number of formal parameters and variables declared in one module can't be greater than 130.
\r
494 - Number of array indices (i.e. arrayof) can't be greater than 63,
\r
495 - Standard type integer has the range (-32767,+32767) for small memory (16 - bit word). For huge memory (32-bit word) the range is (-2147483647,+2147483647), but values of constant expressions in a program must lie within the range (-2767, 32767).
\r
496 - Real numbers have the range (-8.43E-37, 3.37E+38) with 24-bit mantissa and 8-bit exponenet for small memory , giving about 7 digits of precision. For huge memory the range is (4.19E-307, 1.67E+308) with 53-bit mantissa and 11-bit exponent, giving about 15 digits of precision.Values of constant expression in a program must lie in the range (-8.43E-37, 3.37E+38).
\r
502 Compiler computes values of expressions built from constants without range checking. It means, that integer overflow, floating point overflow or underflow cause incorrect result without any message.
\r
506 APPENDIX A : PREDEFINED CONSTANTS
\r
510 The size in bytes of integer variables (2 for small memory, 4 for huge memory)
\r
513 The size in bytes of real variables (4 for small memory, 8 for huge memory)
\r
515 APPENDIX B : PREDEFINED CLASSES
\r
518 {Applies for DOS/AT versions, see a separate document IIUWGRAPH for details}
\r
520 {For Unix, see the separate document XIIUWGRAF}
\r
522 Class IIUWGRAPH defines the set of graphics procedures. The full description of these procedures is contained in the description of the library IIUWGRAF (Institute of Informatics, University of Warsaw). The following procedures are available in Loglan (heads are specified if they are different from these in IIUWGRAF description):
\r
524 gron - graphics on 1 parameter to be ignored integer
\r
525 groff - GRAPHICS OFF, no parameters
\r
526 cls - Clear screen, no pamrameters
\r
527 point - set current position to (x,y) and give it current colour
\r
528 move - set current position to (x,y)
\r
540 nocard : function: integer;
\r
543 inxpos : function: integer;
\r
544 inypos : function: integer;
\r
546 getmap : function(input x,y:integer): arrayof integer;
\r
551 inkey : function : integer;
\r
563 {Applies only to DOS/AT versions}
\r
564 {For UNIX and 386 versions see the corresponding documents}
\r
566 A predefined class MOUSE provides basic support for mouse. An external resident Microsoft compatible mouse driver (such as MOUSE.SYS) must be installed to use this class. MOUSE contains following procedures and functions:
\r
570 init:function(output b:integer):boolean
\r
571 {Initializes mouse driver. Number of mouse buttons is returned in b. Returns true iff mouse hardware and software are installed.}
\r
573 showcursor:procedure
\r
574 {This procedure increments the internal cursor counter. If the counter is 0 it displays the cursor on the screen. The cursor tracks the motion of the mouse, changing position as the mouse changes position.}
\r
576 hidecursor:procedure
\r
577 {This procedure removes the cursor from the screen and decrements the internal cursor counter. Although the cursor is hidden it still tracks the motion of the mouse, changing position as the mouse changes position.}
\r
579 status:procedure(output h, v:integer, l, r, c:boolean)
\r
580 {This procedure reports the status of the buttons and cursor. l, r, c are true iff respectively left, right and center (if it exists) buttons are down when the procedure is called. Also position of cursor is returned in h and v. Position is expressed in Color Graphics Adapter pixels (with resolution 640x200).}
\r
582 setposition:procedure(h, v:integer)
\r
583 {This procedure sets the cursor to the specified horizontal and vertical positions on the screen. The new values must be within the specified ranges of the virtual screen. The values are rounded to the nearest values permitted by the screen for horizontal and vertical positions.}
\r
585 getpress:procedure(b:integer; output h, v, p:integer, l, r, c:boolean)
\r
586 {This procedure gives a count of selected button presses (on p) since the last call to it and the position of the cursor (on h and v) the last time the button was pressed. Parameter b selects button to be checked: 0 - left, 1 - right, 2 - center. In addition current button status is returned in l, r and c (see procedure status).}
\r
588 getrelease:procedure(b:integer; output h, v, p:integer, l, r, c:boolean)
\r
589 {This procedure gives a count of selected button releases (on p) since the last call to it and the position of the cursor (on h and v) the last time the button was released. Parameter b selects button to be checked: 0 - left, 1 - right, 2 - center. In addition current button status is returned in l, r and c (see procedure status).}
\r
591 setwindow:procedure(l, r, t, b:integer)
\r
592 {Restricts the cursor movement to window described by l, r, t, b. L and r are minimum and maximum horizontal cursor position, t and b are minimum and maximum vertical cursor position (in pixels)}
\r
594 defcursor:procedure(s, x, y:integer)
\r
595 {Selects text mode cursor characteristics. When s is 0, software cursor is selected and x, y define masks to be used when modifying character-attribute word in screen memory associated with position under cursor. This word is logicaly ANDed with x and the result is XORed with y. When s is 1, a hardware cursor is selected and x, y define first and last scan lines of the cursor box within character box. X must be not greater than y and both must be in range 0-7 for Color Graphics Adapter or 0-13 for Monochrome Display Adapter, Hercules Graphics Card and Enhanced Graphics Adapter.
\r
597 call defcursor(0, -1, 30464)
\r
598 - selects standard (reverse video) software cursor
\r
599 call defcursor(1, 11, 12)
\r
600 - selects standard hardware cursor for HGC}
\r
602 getmovement:procedure(output h, v:integer)
\r
603 {Returns relative mouse movement since last call (in 1/200 inches).}
\r
605 setspeed:procedure(h, v:integer)
\r
606 {H and v specify horizontal and vertical cursor speed relative to mouse speed. It is expressed in mouse steps (1/200 inch) corresponding to 8 pixels on screen. Default is 8 horizontaly and 16 verticaly.
\r
608 call setspeed(1, 1)
\r
609 - set maximum cursor speed
\r
610 call setspeed(16, 32)
\r
611 - set cursor speed two times slower than default}
\r
613 setthreshold:procedure(s:integer)
\r
614 {sets threshold speed for double speed feature. If the mouse moves faster than the threshold, the cursor speed on the screen is doubled. Default threshold is 64 mouse steps/second.
\r
617 call setthreshold(10000)
\r
618 - efectively disable double speed feature.}
\r
623 APPENDIX C : PREDEFINED PROCEDURES AND FUNCTIONS
\r
625 Terminates program execution (ABORT).
\r
627 RANSET:procedure(x:real);
\r
628 Initializes random generator (for RANDOM function)
\r
630 RANDOM:function:real;
\r
631 Generates uniformly distributed pseudo-random numbers in the interval (0,1).
\r
633 SQRT:function(x:real):real;
\r
634 Computes square root of parameter x.
\r
636 SIN:function(x:real):real;
\r
637 Computes sinus of parameter x.
\r
639 COS:function(x:real):real;
\r
640 Computes cosinus of parameter x.
\r
642 TAN:function(x:real):real;
\r
643 Computes tangens of parameter x.
\r
645 EXP:function(x:real):real;
\r
648 LN:function(x:real):real;
\r
649 Computes natural logarithmus of parameter x.
\r
651 ATAN:function(x:real):real;
\r
652 Computes arcus tangens of parameter x.
\r
654 ENTIER:function(x:real):integer;
\r
655 Computes entier part of parameter x.
\r
657 ROUND:function(x:real):integer;
\r
658 Computes rounded value of parameter x: ROUND(x)=ENTIER(x+0.5).
\r
660 IMIN:function(x, y:integer):integer;
\r
661 Computes minimum of two parameters.
\r
663 IMAX:function(x, y:integer):integer;
\r
664 Computes maximum of two parameters.
\r
666 IMIN3:function(x, y, z:integer):integer;
\r
667 Returns the minimum of three parameters.
\r
669 IMAX3:function(x, y, z:integer):integer;
\r
670 Returns maximum of three parameters.
\r
672 ISHFT:function(x, k:integer):integer;
\r
673 Logically shifts x by k bits: left, when k is positive, right otherwise.
\r
675 IAND:function(n, k:integer):integer;
\r
676 Returns logical product of parameters (on all bits).
\r
678 IOR:function(n, k:integer):integer;
\r
679 Returns logical sum of parameters (on all bits).
\r
681 XOR:function(n, k:integer):integer;
\r
682 Returns exlusive sum of parameters (on all bits).
\r
684 INOT:function(n:integer):integer;
\r
685 Returns logical complement of parameters (on all bits).
\r
687 ORD:function(c:char):integer;
\r
688 Returns number that represents character c (see APPENDIX F).
\r
689 The following equations are satisfied: CHR(ORD(c)) = c &ORD(CHR(n)) = n
\r
691 CHR:function(n:integer):char;
\r
692 Returns character represented by parameter n (see APPENDIX F).
\r
694 UNPACK:function(s:string):arrayof char;
\r
695 Returns address of new array object containing characters of the string s.
\r
697 MEMAVAIL:function:integer;
\r
698 Returns the size of available memory in the current process (in words).
\r
700 EXEC:function(cmd:arrayof char):integer;
\r
701 Calls secondary command processor with cmd as a command string. Exit code is returned as a value of EXEC.
\r
703 TIME:function: integer;
\r
704 Returns an integer value indicating the amount of central processor time in seconds used by current process.
\r
706 RESET:procedure(f:file);
\r
707 Positionnes file f at the first component and readies it to reading.
\r
709 REWRITE:procedure(f:file);
\r
710 Positionnes file f at the first component and readies it for output.
\r
711 The file f becomes empty (eof(f) = true).
\r
713 UNLINK:procedure(f:file);
\r
714 Closes and deletes file f (see 3.3.4)
\r
716 SEEK:procedure(f:file; offset, base:integer);
\r
717 Positiones file pointer (see 3.3.7)
\r
719 POSITION:function(f:file):real;
\r
720 Reads position of file pointer (see 3.3.7)
\r
723 APPENDIX D : ERROR CODES
\r
724 0 - ***declaration part overloaded
\r
725 Overflow of compiler data structure of declaration part. Possible reasons: too complicated program structure (too many classes, protection lists, parameter lists,...), too complicated function expressions e.g. f(g(h(...))). It is possible that removing some errors e.g. "unvisible identifier" causes shortening of the program.
\r
726 10 - ***too many errors
\r
727 Overflow of error diagnostic table. 1024 first detected errors are printed, but global number of error is equal to number of all detected errors.
\r
728 41 - ***declaration part overloaded
\r
729 Comments as for 0.
\r
730 101 - ':=' expected
\r
731 102 - ';' expected
\r
732 103 - 'then' expected
\r
733 104 - 'fi'/'else' expected
\r
734 105 - 'od' expected
\r
735 106 - '(' expected
\r
736 107 - ')' expected
\r
737 108 - 'do' expected
\r
738 109 - identifier expected
\r
739 110 - too many exits found
\r
740 Length of sequence exit exit ...exit exceeds level of loop nesting +1.
\r
741 111 - illegal character
\r
742 112 - wrong structure of 'if'-statement
\r
743 113 - 'end' missing
\r
744 114 - '.' expected
\r
745 115 - illegal constant in expression
\r
746 Character constant or text appears in logical or arithmetical expression.
\r
747 116 - '=' expected
\r
748 117 - constant expected
\r
749 118 - ':' expected
\r
750 119 - unit kind specification expected
\r
751 Keywords: class, procedure, function, coroutine or process missing in module headline.
\r
752 120 - 'hidden' or 'close' occurred twice
\r
753 121 - 'hidden' or 'close' out of a class
\r
754 122 - 'block' expected
\r
755 123 - object expression is not a generator
\r
756 Object expression appearing as instruction is not a generator e.g. new (a).b
\r
757 124 - 'dim' expected
\r
758 125 - 'to'/'downto' expected
\r
759 126 - illegal arithmetic operator
\r
760 127 - declaration part expected
\r
761 128 - incorrect identifier at 'end'
\r
762 Module name after end does not correspond to name in module headline.
\r
763 129 - wrong structure of 'case'-statement
\r
764 130 - wrong structure of 'do'-statement
\r
765 131 - illegal use of 'main'
\r
766 Name main may be used only as an argument of attach operator; in other cases it is illegal.
\r
767 132 - 'when' expected
\r
768 133 - too many branches in 'case'-statement
\r
769 Number of branches in case instruction is greater than 160.
\r
770 134 - 'begin' missed
\r
772 136 - is it really a loglan program???
\r
773 There is no Loglan keyword found in source program like: begin, block, unit, class,...
\r
774 137 - 'block' missed - parsing began
\r
775 There is no keyword block or program at the beginning of the Loglan program. This message indicates the source line, that is the first compiled line.
\r
776 138 - 'repeat' out of a loop
\r
777 The length of sequence: (exit)*repeat exceeds nested depth of the loop.
\r
778 139 - there is no path to this statement
\r
779 140 - 'andif'/'orif' mixed
\r
780 141 - array of 'semaphore' is illegal
\r
781 142 - wrong handler end
\r
782 Handler declaration is not ended by instruction end or end handlers.
\r
783 143 - lastwill inside a structured statement
\r
784 144 - repeated lastwill
\r
785 Label LASTWILL appears more than once in the same module.
\r
786 145 - no parameter specification
\r
787 146 - wrong register specification
\r
789 191 - ***null program
\r
790 There is no source program on the input file or there is no module declaration. Causes termination of program compilation.
\r
791 196 - ***too many identifiers
\r
792 Entire length of all identifiers and keywords is greater than 3000 characters. This overflow terminates program compilation.
\r
793 197 - ***too many formal parameters
\r
794 The length of formal parameter list and declared local variables (in actual module) is greater than 130. This error terminates program compilation.
\r
795 198 - ***parsing stack overloaded
\r
796 Too complicated (nested) program structure. This error terminates program compilation.
\r
797 199 - ***too many prototypes
\r
798 Too many declarations in program caused overflow of the compiler data structure. This error terminates program compilation.
\r
799 201 - wrong real constant
\r
800 202 - wrong comment
\r
801 203 - wrong character constant
\r
802 204 - wrong integer constant
\r
803 205 - integer overflow
\r
804 Integer constant out of range.
\r
805 206 - real overflow
\r
806 Real constant out of range.
\r
807 211 - identifier too long
\r
808 Length of identifier is greater than 20 characters.
\r
809 212 - string too long
\r
810 Length of string constant is greater than 260 characters.
\r
811 301 - prefix is not a class id
\r
812 Prefix name ID is not a class name. It may appear when identifier ID is used earlier (declared more than once).
\r
813 303 - coroutine/process illegal here as prefix id
\r
814 Procedure, function or block can't be prefixed by coroutine or process.
\r
815 304 - hidden identifier cannot be taken id
\r
816 Identifier ID placed on taken list is on hidden list in the prefixing module.
\r
817 305 - undeclared identifier id
\r
818 306 - undeclared type identifier id
\r
819 307 - type identifier expected id
\r
820 Identifier ID used in variable or function declaration as a type name, is not declared earlier as a type (but name has been used earlier).
\r
821 308 - undeclared prefix identifier id
\r
822 309 - declared more than once id
\r
823 310 - taken list in unprefixed unit
\r
824 316 - formal type specification after use id
\r
825 Formal type ID appears in the parameter list after using this identifier as parameter type e.g. (... x: ID; type ID, ...).
\r
826 317 - hidden type identifier id
\r
827 Type name ID is on hidden list in a prefix of one of the modules from SL chain of actual module and it is a nearest declaration of this identifier.
\r
828 318 - type identifier not taken id
\r
829 Type name ID is not on taken list in a prefix of one of the modules from SL chain of actual module.
\r
830 319 - hidden identifier in the list id
\r
831 Identifier ID from hidden or close list is on hidden list in one of the prefixing modules.
\r
832 320 - identifier in the list not taken id
\r
833 Identifer ID from hidden or close list is not placed on taken list in none of the prefixing modules.
\r
834 321 - identifier cannot be taken id
\r
835 Identifer ID from taken list is placed on taken list in none of the prefixes.
\r
836 322 - hidden prefix identifier id
\r
837 Analogical to 317 error.
\r
838 323 - prefix identifier not taken id
\r
839 Analogical to 318 error.
\r
840 329 - only procedure and function may be virtual
\r
841 virtual specification appears with class specification.
\r
842 330 - virtual in unprefixed block/procedure/function
\r
843 331 - incompatible kinds of virtuals id
\r
844 Kind of virtual module ID is different from kind of replaced module (e.g. one of them is a function, the other one is a procedure).
\r
845 332 - incompatible types of virtuals id
\r
846 Type of virtual function ID is different from type of replaced function.
\r
847 333 - different lengths of form.param.lists in virtuals id
\r
848 Virtual module ID and replaced module have different number of formal parameters.
\r
849 334 - conflict kinds of the 1st level parameters id
\r
850 In the headline of virtual module ID kind of formal parameter differs from corresponding formal parameter in the headline of replaced module (e.g. type and variable, input and output parameters,.).
\r
851 335 - incompatible types of the 1st level parameters id
\r
852 There are formal parameters of different types (function, procedure) in the headline of virtual module ID and in the headline of replaced module on the same position.
\r
853 336 - different lengths of the 2nd level params lists id
\r
854 There are formal procedures/functions with different numbers of parameters in the headline of virtual module ID and in the headline of replaced module on the same position.
\r
855 337 - incompatible kinds of the 2nd level parameters id
\r
856 There are parameters of different kinds on the same position in the corresponding procedure or function parameters in the headline of virtual module ID and in the headline of replaced module.
\r
857 338 - incompatible types of the 2nd level parameters id
\r
858 There are parameters of different types on the same position in the corresponding procedure or function in the headline of virtual module ID and in the headline of replaced module.
\r
859 341 - ***declaration part overloaded
\r
860 Analogical to error 0.
\r
861 342 - ***too many classes declared
\r
862 343 - ***too many prototypes
\r
863 Too many modules declared on the same level.
\r
864 350 - undeclared signal identifier id
\r
865 351 - hidden signal identifier id
\r
866 Analogical to error 317.
\r
867 352 - signal identifier not taken id
\r
868 Analogical to error 318.
\r
869 353 - signal identifier expected id
\r
870 Identifier ID placed in handler declaration as a signal name has not been declared as a signal.
\r
871 354 - different types of parameters id
\r
872 In the headlines of signals, that have common handler, parameters of the different types appear on the same position. ID is one of these parameters.
\r
873 355 - incompatible kinds of parameters id
\r
874 In the headlines of signals that have common handler, parameters of different kinds appear on the same position. ID is one of these parameters.
\r
875 356 - different identifiers of parameters id
\r
876 In the headlines of signals that have common handler parameters of different names appear on the same position. ID is one of these parameters.
\r
877 357 - incompatible kinds of the 2nd level parameters id
\r
878 Analogous to error 355 for 2-nd level parameters.
\r
879 358 - different types of the 2nd level parameters id
\r
880 Analogous to error 354 for the 2-nd level parameters.
\r
881 359 - different lengths of the 2nd level params lists id
\r
882 There are formal procedures or formal functions with different number of parameters on the same position in the headlines of signals this have common handler. ID is one of these formal parameters/functions.
\r
883 360 - different lengths of form. param. lists in signals id
\r
884 There are different number of formal parameters in the signals that have common handler. ID is one of these signals.
\r
885 361 - non-local formal type cannot be used id
\r
886 Formal parameter ID of signal is of non local formal type.
\r
887 362 - repeated handler for signal id
\r
888 There are more than one handler for signal ID in the same module.
\r
889 370 - only 'input' is legal here
\r
890 Formal parameter output or inout is illegal in process.
\r
891 398 - class prefixed by itself id
\r
892 Construction unit ID: ID class is not allowed.
\r
893 399 - cycle in prefix sequence id
\r
894 ID is a class identifier used in cyclic prefixing i.e. ID prefixes a, a prefixes b, ... , z prefixes ID. This construction is not allowed.
\r
895 401 - wrong label in 'case' id
\r
896 Label in case instruction is not a constant.
\r
897 402 - 'case' statement nested too deeply
\r
898 Nesting level in case instruction is greater than 6.
\r
899 403 - too long span of 'case' labels
\r
900 Range of branches in case instruction is greater than 160.
\r
901 404 - repeated label in 'case'-statement id
\r
902 Label ID appears more than once in case instruction.
\r
903 405 - illegal type of 'case' expression id
\r
904 Control expression in case statement is not of
\r
905 integer or char type.
\r
906 406 - different types of labels and 'case' expression
\r
907 407 - non-logical expression after 'if'/'while' id
\r
908 408 - real constant out of integer range
\r
909 Error during conversion of real constant to integer constant.
\r
910 410 - simple variable expected id
\r
911 Control variable in for loop is not a simple variable.
\r
912 411 - non-integer control variable id
\r
913 Control variable ID in for loop is not of integer type.
\r
914 412 - non-integer expression id
\r
915 Expression placed as array index or bound limit in array generation or as step in for loop or as format in write statement should be reducable to integer type.
\r
916 413 - file expression expected id
\r
917 414 - string expression expected id
\r
918 415 - reference expression expected id
\r
919 Expression placed before dot (remote access), before qua or as a argument of kill or copy statement is not of class type.
\r
920 416 - array expression expected id
\r
921 417 - boolean expression expected id
\r
922 418 - semaphore variable expected
\r
923 419 - illegal type in 'open'
\r
924 The type name placed in open is different than TEXT, REAL, INTEGER, CHAR and DIRECT.
\r
925 420 - variable expected id
\r
926 Expression placed on the left side of assignment statement or as an argument of read instruction or in array instruction is not a variable.
\r
927 421 - class identifier after 'new' expected id
\r
928 Identifier ID placed after new is not a class identifier.
\r
929 422 - procedure identifier after 'call' expected id
\r
930 423 - 'new' missing id
\r
931 Keyword new doesn't appear before class identifier for object generation.
\r
932 424 - 'call' missing id
\r
933 Keyword call doesn't appear before procedure identifier for procedure call.
\r
934 425 - 'inner' out of a class
\r
935 426 - 'inner' occurred more than once
\r
936 427 - 'wind'/'terminate' out of a handler
\r
937 428 - 'inner' inside lastwill
\r
938 429 - definition cannot be reduced to constant id
\r
939 Identifier ID placed in constant definition is not a constant.
\r
940 430 - undefined constant in the definition id
\r
941 431 - wrong number of indices id
\r
942 Number of indices in referencing to array element is different from declared number of indices.
\r
943 432 - index out of range id
\r
944 433 - upper bound less than lower bound id
\r
945 434 - too many subscripts id
\r
946 Dimension of static array ID is greater than 7.
\r
947 435 - variable is not array id
\r
948 440 - type identifier expected after 'arrayof' id
\r
949 Identifier ID placed after arrayof in actual parameter list, corresponding to type parameter is not a type name.
\r
950 441 - incorrect format in 'write'
\r
951 There is format for expression of char type or there is double format for expression of type integer or string.
\r
952 442 - illegal expression in 'write'
\r
953 Argument of write statement is not of type char, string, integer or real.
\r
954 443 - illegal type of variable in 'read' id
\r
955 Argument of read statement is not of type char, integer or real.
\r
956 444 - no data for i/o transfer
\r
957 There is only file identifier in I/O instruction.
\r
958 445 - illegal expression in 'put'
\r
959 446 - illegal expression in 'get'
\r
960 448 - 'raise' missing id
\r
961 There is signal identifier without keyword raise in the context of signal raising.
\r
962 449 - signal identifier expected id
\r
963 Identifer ID after keyword raise is not a signal identifier.
\r
964 450 - illegal procedure occurrence id
\r
965 Procedure name ID appears in illegal context.
\r
966 451 - illegal class occurrence id
\r
967 Class name ID appears in illegal context.
\r
968 452 - illegal type occurrence id
\r
969 Type name ID appears in illegal context.
\r
970 453 - illegal signal occurrence id
\r
971 Signal name ID appears in illegal context.
\r
972 454 - illegal operator occurence
\r
973 455 - wrong number of operands
\r
974 460 - divided by zero
\r
975 470 - illegal input parameter id
\r
976 Actual parameter associated with input parameter is not expression that may have any value: it is e.g. procedure name
\r
977 471 - illegal output parameter id
\r
978 Actual parameter corredponded to output parameter is not a variable.
\r
979 472 - illegal type parameter id
\r
980 Actual parameter ID associated with type parameter is not a type name.
\r
981 473 - illegal procedure parameter id
\r
982 Actual parameter ID associated with procedure parameter is not a procedure name.
\r
983 474 - illegal function parameter id
\r
984 Actual parameter ID associated with function parameter is not a function name.
\r
985 475 - illegal left side of 'is'/'in' id
\r
986 Left side argument ID of is/in is not a reference expression.
\r
987 476 - illegal right side od 'is'/'in' id
\r
988 Right side argument ID of is / in is not a class name.
\r
989 477 - illegal parameter of 'attach' id
\r
990 Parameter ID of attach statement is not a reference variable of class object.
\r
991 478 - illegal type of expression
\r
992 479 - negative step value
\r
993 550 - ***stack overloaded
\r
994 This error may be removed by dividing expressions into subexpressions, making simpler nested callings of arrays, functions, classes and for loops. This error terminates compilation of current module, but other modules will be compiled.
\r
995 551 - ***too many auxiliary variables needed
\r
996 Too complicated expressions. This error may be removed by declaration of additional variables and using them as auxiliary variables in expressions.
\r
997 552 - ***too many auxiliary reference variable needed
\r
998 Analogical to error 551.
\r
999 553 - ***statement sequence too long or too complicated
\r
1000 This error may be removed by adding 'goto' statement into sequence of instructions e.g. if false then exit fi, inner, ... or by dividing complicated expression into subexpressions.
\r
1001 554 - ***real constants dictionary overflow
\r
1002 Too many real constant, maybe because of evaluation of expressions built from real constants.
\r
1003 600 - undeclared identifier id
\r
1004 601 - illegal type before '.' id
\r
1005 Expression placed before dot (remote access) is not of class type.
\r
1006 602 - close identifier after '.' id
\r
1007 Identifier ID placed after dot is on close list in the class or its prefix that construct expression before dot.
\r
1008 603 - undeclared identifier after '.' id
\r
1009 Identifier ID placed after dot is not attribute of expression placed before dot. It may be caused by missing declaration or using bad prefix for class constructing expression before dot.
\r
1010 604 - illegal operand type id
\r
1011 One of the arguments in arithmetical expression or in relation is not of arithmetical type.
\r
1012 605 - illegal type in 'div/'mod' term id
\r
1013 Expression identified by ID used as argument of div or mode operation is not of integer type.
\r
1014 606 - incompatible types in comparison id
\r
1015 ID is an identifier of left argument of relation.
\r
1016 607 - unrelated class types in comparison id
\r
1017 ID is an identifier of left argument of relation. Both arguments are of class type and none of these classes prefixes the other one.
\r
1018 608 - string cannot be compared id
\r
1019 ID identifies a string.
\r
1020 609 - incompatible types in assignment/transmission id
\r
1021 ID is an identifier of left side of assignment statement or an identifier of actual parameter in object generation. Types of both sides of instruction or type of formal parameter and type of actual parameter are incompatible.
\r
1022 610 - unrelated class types in assignment/transmission id
\r
1023 Analogical to errors 609 and 607.
\r
1024 611 - constant after '.' id
\r
1025 An attempt to remote access to constant.
\r
1026 612 - this class does not occur in sl-chain id
\r
1027 Class ID appeared in expression this ID, but ID dosn't prefix any module in SL chain of actual module. It may be a cycle.
\r
1028 613,614 - class identifier expected id
\r
1029 For error 613: identifier ID used in expression this ID is not of class type. For error 614: identifier ID used in expression this ID is not name of any type.
\r
1030 615 - illegal type before 'qua' id
\r
1031 Object expression before qua should be of one of the types: class, coroutine, process or simple (not array) formal type.
\r
1032 616,617 - illegal type after 'qua' id
\r
1033 For error 616: identifier ID used after qua is not of any type.
\r
1034 For error 617: identifier ID used after qua is not of class type.
\r
1035 618 - unrelated types in 'qua'-expression id
\r
1036 Identifier ID is a name of class type used after qua. This class type and class type used before qua doesn't prefix each other.
\r
1037 619 - hidden identifier id
\r
1038 Identifier ID used in construction qua ID or this ID is on hidden list in the prefix of one of the module from SL chain of actual module.
\r
1039 620 - not taken identifier id
\r
1040 Identifier ID used in construction qua ID or this ID is not on taken list in any prefix of any module of actual module.
\r
1041 621 - invisible identifier after '.' id
\r
1042 Identifier ID placed after dot is on hidden list or is not on taken list in prefix.
\r
1043 622 - formal parameter list is shorter id
\r
1044 Identifier ID identifies generated object: class, procedure or function. Formal parameters list of this object is shorter than actual parameters list.
\r
1045 623 - formal parameter list is longer id
\r
1046 Analogical to error 622.
\r
1047 624 - actual parameter is not a reference type id
\r
1048 Actual parameter identified by ID in generated object can't be of primitive type: integer, real, boolean or string.
\r
1049 625 - actual parameter is not a type id
\r
1050 Actual parameter identified by ID is not a type, so it can't replace formal type parameter.
\r
1051 626 - procedure-function conflict between parameters id
\r
1052 Actual parameter, identified by ID, that replaced formal parameter in generated object is function whereas formal parameter is a procedure or vice versa.
\r
1053 627 - unmatched heads-wrong kinds of parameters id
\r
1054 ID identifies actual module that replaced formal module. There are parameters of different kinds on the same position in the headlines of these modules. For input - output conflict the agreement of parameter types is checked also.
\r
1055 628 - unmatched heads-incompatible types in lists id
\r
1056 ID identifies actual module that replaced formal module. There are input /output parameters of different types on the same position in the headlines of actual and formal module.
\r
1057 629 - unmatched heads-unrelated class types in lists id
\r
1058 ID identifies actual module that replaced formal module. There are input/output parameters specifying classes of disjointed prefix sequences
\r
1059 in the headlines of actual and formal module.
\r
1060 630 - unmatched heads-different numbers of parameters id
\r
1061 There are different lengths of headlines in actual module identified by ID and formal module.
\r
1062 631 - incompatible types of function parameters id
\r
1063 There are different types of actual function specified by identifier ID and formal function in generated object.
\r
1064 632 - function/procedure expected id
\r
1065 Actual parameter identified by identifier ID is not function/procedure, whereas corresponding formal parameter is function/procedure.
\r
1066 633 - actual function type defined weaker than formal id
\r
1067 Type of actual function identified by ID is weaker defined than formal function type e.g. formal function type is statically defined, whereas actual function type is formal (external) or formal function is class, whereas actual function type is coroutine or process.
\r
1068 634 - unmatched heads-too weak type in actual list id
\r
1069 There are input/output parameters on the same position in the headlines of actual module identified by identifier ID and formal module, but ID is weaker defined than corresponding formal module parameter (see error 633).
\r
1070 635 - standard function/procedure cannot be actual par. id
\r
1071 ID identifies standard procedure/function used as actual parameter.
\r
1072 636 - illegal use of semaphore id
\r
1073 637 - 'semaphore' cannot be used id
\r
1076 APPENDIX E : LOGLAN RUNTIME ERRORS
\r
1077 In the following list system signal name, raised after detection of runtime error, is placed in brackets.
\r
1079 ARRAY INDEX ERROR (CONERROR)
\r
1080 Index outside range during reference to array variable.
\r
1081 NEGATIVE STEP VALUE (CONERROR)
\r
1083 SL CHAIN CUT OFF (LOGERROR)
\r
1084 Control transfer to object that has SL link cut off earlier in the consequence of kill operation.
\r
1085 ILLEGAL ATTACH (LOGERROR)
\r
1086 The value of parameter of attach instruction is none or object differs from coroutine.
\r
1087 ILLEGAL DETACH (LOGERROR)
\r
1088 An attempt to return by detach to coroutine that has been dealocated (by kill).
\r
1089 ILLEGAL RESUME (LOGERROR)
\r
1090 An attempt to resume an object which is not a process or a process which is running.
\r
1091 TOO MANY PROCESSES ON ONE MACHINE (SYSERROR)
\r
1092 Number of processes existing on one computer is greater than 64.
\r
1093 INVALID NODE NUMBER (SYSERROR)
\r
1094 An attempt to create a process on a computer which is not connected to network.
\r
1095 IMPROPER QUA (LOGERROR)
\r
1096 Error during computing expression of the form: ...x qua a, when 'x' references to none or 'a' doesn't prefix dynamic type object, which is value of 'x'.
\r
1097 ILLEGAL ASSIGNMENT (TYPERROR)
\r
1098 Type conflict between left and right side of assignment instruction.
\r
1099 FORMAL TYPE MISSING (LOGERROR)
\r
1100 Formal type is not accessible because of SL cut off.
\r
1101 ILLEGAL KILL (LOGERROR)
\r
1102 An attempt to deallocate object in SL chain of active object.
\r
1103 ILLEGAL COPY (LOGERROR)
\r
1104 An attempt to copy non terminated object (i.e. class before execution of return statement, coroutine before execution of end statement...).
\r
1105 REFERENCE TO NONE (ACCERROR)
\r
1106 An attempt to remote access (by dot) to attributes of non existing object: dealocated or not generated.
\r
1107 MEMORY OVERFLOW (MEMERROR)
\r
1109 INCOMPATIBLE HEADERS (TYPERROR)
\r
1110 Actual parameter list of generated object (procedure, function or class) is incompatible with formal parameter list from module declaration or formal function type is incompatible with actual function type.
\r
1112 INCORRECT ARRAY BOUNDS (CONERROR)
\r
1113 An attempt to generate dynamic array object, when lower bound of
\r
1114 index range is greater than upper bound.
\r
1115 DIVISION BY ZERO (NUMERROR)
\r
1117 COROUTINE TERMINATED (LOGERROR)
\r
1118 An attempt to transfer control to a terminated coroutine.
\r
1119 COROUTINE ACTIVE (LOGERROR)
\r
1120 An attempt to transfer control to an active coroutine.
\r
1121 HANDLER NOT FOUND (LOGERROR)
\r
1122 There is no handler for signal declared by user.
\r
1123 ILLEGAL RETURN (LOGERROR)
\r
1124 An attempt to execute return instruction in handler serving system signal.
\r
1125 UNIMPLEMENTED STANDARD PRC. (LOGERROR)
\r
1126 Standard procedure or function is not implemented.
\r
1127 FORMAL LIST TOO LONG (MEMERROR)
\r
1128 Formal parameter list is greater than 40.
\r
1129 ILLEGAL I/O OPERATION (SYSERROR)
\r
1130 Reading after writing, the type of the read/write parameter does not match the type of the file etc.
\r
1131 I/O ERROR (SYSERROR)
\r
1132 System error during I/O.
\r
1133 CANNOT OPEN FILE (SYSERROR)
\r
1135 INPUT DATA FORMAT BAD (SYSERROR)
\r
1137 SYSTEM ERROR (SYSERROR)
\r
1139 UNRECOGNIZED ERROR
\r
1141 APPENDIX F : CHARACTER SET
\r
1142 At the top of the table are hexadecimal digits (0 to 7), and to the left of the table are hexadecimal digits (0 to F). Hexadecimal code of ASCII character is constructed by contatenation of column label and row label. For example, the value of character representing the plus sign is 2B.
\r
1145 _________________________________________________
\r
1146 ! ! ! ! ! ! ! ! !
\r
1147 0 ! NUL ! DLE ! SP ! 0 ! @ ! P ! ! p !
\r
1148 _________________________________________________
\r
1149 ! ! ! ! ! ! ! ! !
\r
1150 1 ! SOH ! DC1 ! ! ! 1 ! A ! Q ! a ! q !
\r
1151 _________________________________________________
\r
1152 ! ! ! ! ! ! ! ! !
\r
1153 2 ! STX ! DC2 ! " ! 2 ! B ! R ! b ! r !
\r
1154 _________________________________________________
\r
1155 ! ! ! ! ! ! ! ! !
\r
1156 3 ! ETX ! DC3 ! # ! 3 ! C ! S ! c ! s !
\r
1157 _________________________________________________
\r
1158 ! ! ! ! ! ! ! ! !
\r
1159 4 ! EOT ! DC4 ! $ ! 4 ! D ! T ! d ! t !
\r
1160 _________________________________________________
\r
1161 ! ! ! ! ! ! ! ! !
\r
1162 5 ! ENQ ! NAK ! % ! 5 ! E ! U ! e ! u !
\r
1163 _________________________________________________
\r
1164 ! ! ! ! ! ! ! ! !
\r
1165 6 ! ACK ! SYN ! & ! 6 ! F ! V ! f ! v !
\r
1166 _________________________________________________
\r
1167 ! ! ! ! ! ! ! ! !
\r
1168 7 ! BEL ! ETB ! ' ! 7 ! G ! W ! g ! w !
\r
1169 _________________________________________________
\r
1170 ! ! ! ! ! ! ! ! !
\r
1171 8 ! BS ! CAN ! ( ! 8 ! H ! X ! h ! x !
\r
1172 _________________________________________________
\r
1173 ! ! ! ! ! ! ! ! !
\r
1174 9 ! HT ! EM ! ) ! 9 ! I ! Y ! i ! y !
\r
1175 _________________________________________________
\r
1176 ! ! ! ! ! ! ! ! !
\r
1177 A ! LF ! SUB ! * ! : ! J ! Z ! j ! z !
\r
1178 _________________________________________________
\r
1179 ! ! ! ! ! ! ! ! !
\r
1180 B ! VT ! ESC ! + ! ; ! K ! [ ! k ! { !
\r
1181 _________________________________________________
\r
1182 ! ! ! ! ! ! ! ! !
\r
1183 C ! FF ! FS ! , ! < ! L ! \ ! l ! | !
\r
1184 _________________________________________________
\r
1185 ! ! ! ! ! ! ! ! !
\r
1186 D ! CR ! GS ! - ! = ! M ! ] ! m ! } !
\r
1187 _________________________________________________
\r
1188 ! ! ! ! ! ! ! ! !
\r
1189 E ! SO ! RS ! . ! > ! N ! ^ ! n ! ~ !
\r
1190 _________________________________________________
\r
1191 ! ! ! ! ! ! ! ! !
\r
1192 F ! SI ! US ! / ! ? ! O ! _ ! o ! DEL !
\r
1193 _________________________________________________
\r
1197 NUL Null DLE Data Link Escape
\r
1198 SOH Start of Heading DC1 Device Control 1
\r
1199 STX Start of Text DC2 Device Control 2
\r
1200 ETX End of Text DC3 Device Control 3
\r
1201 EOT End of Transmission DC4 Device Control 4
\r
1202 ENQ Enquiry NAK Negative Acknowledge
\r
1203 ACK Acknowledge SYN Synchronous Idle
\r
1204 BEL Bell ETB End of Transmission Block
\r
1205 BS Backspace CAN Cancel
\r
1206 HT Horizontal Tabulation EM End of Medium
\r
1207 LF Line Feed SUB Substitute
\r
1208 VF Vertical Tab ESC Escape
\r
1209 FF Form Feed FS File Separator
\r
1210 CR Carriage Return GS Group Separator
\r
1211 SO Shift Out RS Record Separator
\r
1212 SI Shift In US Unit Separator
\r
1213 SP Space DEL Delete
\r
1215 Last update: {TIME \@ "MMMM d, yyyy"|March 21, 1994}
\r
1217 Should you like to read on Loglan and its companion Algorithmic Logic, here it is, a short list of more important papers.
\r
1219 Bartol,W.M., et al.
\r
1220 Report on the Loglan 82 programming Language,
\r
1221 Warszawa-Lodz, PWN, 1984
\r
1224 A micro-manual of the programming language LOGLAN-82,
\r
1225 Institute of Informatics, University of Warsaw, 1984
\r
1226 (there exists a french translation of the above manual)
\r
1227 (both texts are distributed together with this package)
\r
1229 A.Kreczmar, A.Salwicki, M. Warpechowski,
\r
1230 Loglan'88 - Report on the Programming Language,
\r
1231 Lecture Notes on Computer Science vol. 414, Springer Vlg, 1990,
\r
1232 ISBN 3-540-52325-1
\r
1234 /* do you know polish? istnieje dobry podrecznik Loglanu! */
\r
1235 A.Szalas, J.Warpechowska,
\r
1237 Wydawnictwa Naukowo-Techniczne, Warszawa, 1991 ISBN 82-204-1295-1
\r
1240 Some papers devoted to the problems and challenges of Loglan.
\r
1242 Bartol,W.M., Kreczmar, A., Litwiniuk, A., Oktaba, H.,
\r
1243 Semantic and Implementation of Prefixing at Many Levels,
\r
1244 in Lecture Notes in Computer Science vol.148, Springer Verlag, Berlin,
\r
1247 Krause,M., Kreczmar, A., Langmaack, H., Salwicki,A.,
\r
1248 Specification and Implementation Problems of Programming Languaages
\r
1249 Proper for Hierarchical Data Types,
\r
1250 Report 8410 of Institut fuer Informatik und Praktische Mathematik
\r
1251 Christian-Albrechts-Universitaet Kiel, 1984, pp.1-68
\r
1253 Kreczmar,A., Salwicki,A.,
\r
1254 Concatenable Type Declarations, Their Application and Implementation
\r
1255 in: Programming Languages and System Design, in Programming, Languages and System Design Proc. IFIP TC2 Conference (J.Bormann ed.) Dresden, 1983
\r
1256 North Holland, Amsterdam, 1983, pp.29-41
\r
1259 Cioni, G., Kreczmar, A.,
\r
1260 Modules in high level programming languages
\r
1261 in: Advanced Programming Methodologies (G.Cioni, A.Salwicki eds.)
\r
1262 Academic Press, London, 1989, 247-340
\r
1265 On inheritance Rule in Object Oriented Programming
\r
1266 in: Advanced Programming Methodologies
\r
1267 Academic Press, London, 1989, pp. 141-164
\r
1269 Cioni,G., Kreczmar,A., Vitale, R.,
\r
1270 Storage Management
\r
1271 in: Advanced Programming Methodologies
\r
1272 Academic Press, London, 1989, pp.341-366
\r
1275 Cioni, G., Kreczmar, A.,
\r
1276 Programmed deallocation without Dangling References,
\r
1277 IPL, vol. 18 1984, pp. 179-185
\r
1279 Krause, M., Kreczmar, A., Langmaack, H., Warpechowski, M.,
\r
1280 Concatenation of program modules, an Algebraic Approach to the Semantic and Implementation Problems,
\r
1281 in: Proc. Computation Theory, LNCS 208, Springer Vlg, Berlin, 1986, pp. 134-156
\r
1282 full text in: Report 8701 of Institut fuer Informatik und Praktische Mathematik
\r
1283 Christian-Albrechts-Universitaet Kiel, 1987, pp.1-48
\r
1286 Die Korrektheit einer Implementation der Modulpraefigerung mit reiner Static Scope Semantik,
\r
1287 Report 8616 of Institut fuer Informatik und Praktische Mathematik
\r
1288 Christian-Albrechts-Universitaet Kiel, 1986, pp.1-139
\r
1291 On static Semantic of Prefixing (=inheritance),
\r
1292 Talk delivered during the Summer School on Loglan'82, Zaborow, September 1983
\r
1295 Ph.D. thesis (in polish!) related somehow to Loglan project.
\r
1298 On parallel processes, 1984
\r
1301 GPR - theorem prover 1982
\r
1304 On file system and signalling exceptions between processes 1987
\r
1307 On Formalisation of the Notion of Reference and its Applications in Theory of Data Structures, 1982
\r
1310 Application of Static Structure of Type Declarations and the System of Dynamic Configurations in a Definition of Semantics of a Universal Programming Language 1981
\r
1312 Szczepanska-Wasersztrum, D.,
\r
1313 A logical system for reasoning about exceptions,1990
\r
1316 Several algorithms for optimisation of code in presence of nesting, 1988
\r
1318 Jankowska-Puchalka B.
\r
1319 A code genarator generator for an object oriented language, 1992
\r
1320 II. Algorithmic Logic
\r
1321 There is a monograph:
\r
1323 G.Mirkowska, A.Salwicki,
\r
1324 Algorithmic Logic,
\r
1325 D.Reidel & Polish Scientific Publ., Dordrecht & Warszawa, 1987, ISBN 83-01-06859-0
\r
1326 the book contains a chapter devoted to certain problems of Loglan.
\r
1328 A new book on AL appeared in polish
\r
1329 G.Mirkowska, A.Salwicki,
\r
1330 Logika algorytmiczna dla programistow,
\r
1331 Wydawnictwa Naukowo-Techniczne, Warszawa, 1993 (ISBN 83-204-1296-X).
\r
1332 An english version in preparation.
\r
1335 There are many papers discussing the applications of AL in programming.
\r
1338 Development of Software from Algorithmic Specifications
\r
1339 in: Advanced Programming Methodologies
\r
1340 Academic Press, London, 1989, pp.1-40
\r
1343 On algorithmic theory of Stacks,
\r
1344 in Proc. MFCS'78 (J.Winnkowski ed.), LNCS 63, Springer Berlin 1978, pp.
\r
1347 On algorithmic theory of dictionaries,
\r
1348 Proc. Logic of Programs (E.Engeler ed.), LNCS 125, Springer, Berlin 1981 pp.145-168
\r
1350 Müldner, T., Salwicki, A.,
\r
1351 On algorithmic Properties of Concurrent Programs,
\r
1352 in: Proc. Logic of Programs (E.Engeler ed.), LNCS 125, Springer, Berlin 1981 pp.170-193
\r
1354 Mirkowska,G., Salwicki, A.,
\r
1355 On applications of Algorithmic Logic,
\r
1356 in: Proc. CAAP'86 (P. Franchi-Zanetacci ed.) Springer, 1986 pp.288-306
\r
1358 Mirkowska,G., Salwicki, A.,
\r
1359 Axiomatic definability of programming language semantics,
\r
1360 in: Proc. IFIP Working Conf on Formal Description of Programming Concepts
\r
1361 Ebberup 1986 (M. Wirsing ed.)
\r
1362 Noth Holland, Amsterdam, 1986, pp1-15
\r
1364 Mirkowska,G., Salwicki, A.,
\r
1365 On Axiomatic Definition of Max-model of concurrency,
\r
1366 in Proc. Advanced School on Mathematical Models of Parallelism Rome 1986
\r
1367 (M. Venturini-Zilli ed.) LNCS Springer Berlin
\r
1370 Algorithmic Theories of Data Structures,
\r
1371 in Proc. ICALP'82 (M.Nilsen, E.Schmidt eds.) LNCS 140 Springer, Berlin, 1982, pp. 458-472
\r
1372 III. Related literature
\r
1373 on object programming is immense.
\r
1375 Let us quote a few books:
\r
1378 Fundamentals of Programming Languages,
\r
1379 Springer, New York, 1983
\r
1382 O.-J. Dahl, B. Myhrhaug, K. Nygaard,
\r
1383 Simula 67 Common Base Language,
\r
1384 Norwegian Computing Center, Oslo, 1970 the mother of object languages!!
\r
1387 Object-oriented software construction,
\r
1388 Prentice Hall, 1988
\r
1391 The C++ Programming Language,
\r
1392 Addison-Wesley, Reading, Mass., 1991
\r
1394 on logics of programs:
\r
1398 D. Kozen, J. Tiuryn
\r
1399 Logics of Programs,
\r
1400 in: Handbook of Theoretical Computer Science, vol.B, Formal Models and Semantics
\r
1401 Elsevier, Amsterdam, 1990, pp. 789-998
\r
1402 {PAGE|40} Loglan'82 user's manual
\r
1404 Loglan'82 users's manual {PAGE|39}
\r
projects / loglan.git / blob