1 <!doctype html public "-//IETF//DTD HTML//EN">
\r
6 <META NAME="GENERATOR" CONTENT="Internet Assistant for Word 1.0Z">
\r
7 <META NAME="AUTHOR" CONTENT="NOM">
\r
15 <H2>USER'S GUIDE</H2>
\r
17 <H3>Institute of Informatics University of Warsaw January 1988
\r
20 <H5>revised October 1994 24/11/94 08:33 LITA Université
\r
24 <H2><A NAME="toc">TABLE of CONTENTS</A></H2>
\r
27 <A HREF="#preface">PREFACE 3 1.</A>
\r
29 <A HREF="#usingl">USING LOGLAN-82 SYSTEM 3 1.1.</A>
\r
33 COMPILER SWITCHES 4 1.3.
\r
35 CODE GENERATION 4 1.4.
\r
37 PROGRAM execution 5 1.5.
\r
39 COMPILE TIME ERRORS 6 1.6.
\r
41 RUN-TIME ERRORS 6 2.
\r
43 COMPILER OPTIONS 7 2.1.
\r
45 OPTION FORMAT 7 2.2.
\r
51 CURRENT LOGLAN-82 IMPLEMENTATION SPECIFICATION 9 3.1. IMPLEMENTED
\r
52 SUBSET OF LOGLAN 9 3.2. PREDEFINED LANGUAGE ELEMENTS 9 3.3. FILE
\r
53 SYSTEM 9 3.4. FILE VARIABLES 9 3.4.1. FILE GENERATION 10 3.5.
\r
54 FILE DEALLOCATION 10 3.6. GENERAL FILE OPERATIONS 10 3.7. TEXT
\r
55 FILES 11 3.8. BINARY SEQUENTIAL FILES 11 3.9. DIRECT ACCESS BINARY
\r
56 FILES 11 3.10. CONCURRENCY 12 3.10.1 INVOKING THE LOGLAN INTERPRETER
\r
57 FOR CONCURRENT ROGRAMS 12 3.10.2 RESTRICTIONS AND DIFFERENCES
\r
58 FROM THE REPORT 13 3.10.3 COMMUNICATION MECHANISM 14 3.11 SYSTEM
\r
59 SIGNALS 16 3.12. IMPLEMENTATION RESTRICTIONS 16 4. APPENDIX A
\r
60 : PREDEFINED CONSTANTS 17 5. APPENDIX B : PREDEFINED CLASSES 17
\r
61 5.1. MOUSE 19 6. APPENDIX ) : PREDEFINED PROCEDURES AND FUNCTIONS
\r
62 21 7. APPENDIX D : ERROR CODES 23 8. APPENDIX E : LOGLAN RUNTIME
\r
63 ERRORS 35 9. APPENDIX F : CHARACTER SET 37 10. BIBLIOGRAPHY 38
\r
64 10.0.1. LOGLAN'82 38 10.0.2. Algorithmic Logic 41 10.0.3. Related
\r
66 <H1><A NAME="preface">PREFACE</A> </H1>
\r
69 This document provides information necessary to compile and execute
\r
72 This manual assumes basic knowledge of Loglan-82 language, described
\r
73 in "Report on the Loglan Programming Language" (see
\r
74 Bibliography). <A HREF="#toc">to ToC</A>
\r
75 <H1><A NAME="usingl">1. USING LOGLAN-82 SYSTEM </A></H1>
\r
78 The following three steps are required to execute a Loglan program:
\r
80 <LI>Compilation (to intermediate code),
\r
81 <LI>Generation of the interpreted code (from intermediate code),
\r
82 <LI>Interpretation (i.e. execution of program).
\r
86 Compilation is accomplished by invoking Loglan compiler. This
\r
87 step creates two destination files: the intermediate code file(.lcd)
\r
88 and the listing file(.lst). The intermediate code file is the
\r
89 input file for the second step: generation of the code accepted
\r
90 by interpreter. In this step two files containing object code(.pcd
\r
91 & .ccd) are produced. They are the input files for the third
\r
92 step: interpretation. This step is equivalent to execution of
\r
93 a program. <A HREF="#toc">to ToC</A>
\r
94 <H2>1.1. COMPILATION </H2>
\r
97 To invoke the Loglan compiler without specifying any command line
\r
100 <KBD>LOGLAN</KBD> <I> </I>
\r
102 Then the prompt appears on your terminal:
\r
104 <KBD>File name: </KBD>
\r
106 and the compiler waits for file specification.The default extension
\r
109 The compiler will produce (optionally) listing file with the same
\r
110 file name and the extension LST and will produce, if no error
\r
111 occurs, the code file with the extension LCD. Destination files
\r
112 will be stored on the same drive and directory as the source file.
\r
118 <SAMP>$ </SAMP><KBD>LOGLAN</KBD><SAMP> </SAMP>
\r
120 <KBD>File name: PROGRAM </KBD>< ENTER>
\r
124 Loglan compiler compiles program from PROGRAM.LOG file and creates
\r
127 <KBD>$ LOGLAN A:PROGRAM.DAT</KBD>
\r
131 In this case the source file is A:PROGRAM.DAT. The file PROGRAM.LCD
\r
132 will be created on drive A.
\r
134 <KBD>$ LOGLAN /home/vous/PROGRAM2</KBD>
\r
138 If any error occurs, the code file is not produced. At the end
\r
139 of compilation the following message is printed:
\r
141 < number of errors> error(s) detected
\r
142 <H2>1.2. COMPILER SWITCHES </H2>
\r
145 There are two possibilities to specify compiler's options: by
\r
146 compiler switches (i.e. external options) or by comments in the
\r
147 source program (see chapter 2.). You may enter the compiler switches
\r
148 in command line after file name in the following format:
\r
150 where swi consists of character that designates the name of the
\r
151 option and either '+' or '-'.
\r
155 <KBD>$ LOGLAN PROGRAM L- T+</KBD>
\r
157 <KBD>$ LOGLAN PROGRAM</KBD> <I> The KBD directive </I>
\r
159 In this case the default switches values are assumed.
\r
161 Scope of the switch is the entire program. All switches ,except
\r
162 H, correspond to options. A switch has greater priority then options:
\r
163 when you specify switch, all corresponding options inside source
\r
164 program will be ignored. Full description of each option is given
\r
165 in chapter 2.2. Switch L has additional significance. When this
\r
166 switch is set off no listing file is produced.
\r
167 <H2>1.3. CODE GENERATION </H2>
\r
170 In this step information from the intermediate code file is read
\r
171 and two destination files containing the code are produced. No
\r
172 switch is permitted for this step. To generate code files, type:
\r
174 <KBD>GEN </KBD>< <I>file name</I>>
\r
176 (or <KBD>HGEN</KBD> <I> The KBD directive </I>< <I>file
\r
177 name</I>> , if the switch H+ was specified for the compiler.(DOS/AT
\r
180 You type file name without extension (extension is ignored).
\r
188 Information is read from file PROGRAM.LCD from default drive and
\r
189 directory. Two destination files are produced: PROGRAM.CCD and
\r
190 PROGRAM.PCD and stored in the same directory as the input file.
\r
192 $ GEN /home/vous/PROGRAM2
\r
194 Files PROGRAM.CCD and PROGRAM.PCD are stored on drive A.
\r
195 <H2>1.4. PROGRAM execution </H2>
\r
198 To interprete (execute) the Loglan program you must invoke the
\r
199 interpreter INT or HINT (if tNe switch H+ was specified). File
\r
200 name must be specified in command line. The file extension is
\r
201 ignored. The interpreter reads input files with the given name
\r
202 and extensions CCD and PCD and executes the Loglan program.
\r
204 The syntax for calling the interpreter is
\r
206 INT < options> < file name>
\r
210 HINT < options> < file name> (DOS/AT only)
\r
212 The following options are supported:
\r
214 /m < n > set memory size for Loglan program (in 16 bit words
\r
215 for small and 32 bit words for huge memory). For concurrent programs
\r
216 it means memory size for every process.
\r
218 /i information about garbage collection-compactification is printed.
\r
220 /r < n > used to invoke interpreter on nodes different from
\r
221 console (see 3.4.). option parameter is console node number (as
\r
222 defined by D-Link Network).
\r
224 /d causes trace to be printed to the file with .TRD extension
\r
225 provided that the option or switch D+ was used during compiling.
\r
227 At the end of interpretation the following message is printed:
\r
229 End of LOGLAN-82 program execution
\r
233 $ LOGLAN \DAT\EXAMP.SRC, L+
\r
235 The file \DAT\EXAMP.LCD and \DAT\EXAMP.LST are generated.
\r
239 The files \DAT\EXAMP.CCD and \DAT\EXAMP.PCD are created.
\r
241 Then the program can be interpreted by: <BR>
\r
245 <H2>1.5. COMPILE TIME ERRORS</H2>
\r
248 The errors detected during the compilation are printed on the
\r
249 listing file, if this file is created. In the scope of option
\r
250 L- or if the switch L is set off only the incorrect lines and
\r
251 errors messages are printed . When the switch ( not option !)
\r
252 L is set off then listing file is not produced and incorrect lines
\r
253 and error messages are printed on the user's terminal.
\r
255 Error message has the following format:
\r
257 <SAMP>*** ln ERROR en txt id <BR>
\r
262 ln - index of incorrect line,
\r
264 en - error's number (see Appendix B),
\r
266 txt- text that explain type of the error,
\r
268 id - identifier helpful to situate the error.
\r
270 Error messages are printed in the source listing after incorrect
\r
273 For syntax errors (numbered 101-147, 201-212), sign '?' indicates
\r
274 the error's position in the line.
\r
276 Error may be detected beyond the line containing it.
\r
278 Identifier helpful to find an error is printed as soon as possible.
\r
280 For codes 331-338 error message is printed after first line of
\r
281 virtual module declaration.
\r
283 Errors like "undeclared identifier" are printed in each
\r
284 module once, after first reference to this identifier. Further
\r
285 references are ignored.
\r
287 The errors related to case instruction may appear before the incorrect
\r
289 <H2>1.6. RUN-TIME ERRORS </H2>
\r
292 Loglan run-time errors are detected by Loglan run-time system.
\r
293 When any of these errors occurs, the appropriate system signal
\r
294 is raised and error message is printed if handler is not found.
\r
295 All of these error messages are described in Appendix C. moreover
\r
296 the line number of the last executed statement is printed on the
\r
298 <H1>2. COMPILER OPTIONS </H1>
\r
301 Options, like switches are used to pass some information to the
\r
302 compiler. Options are placed in source program in comments. Scope
\r
303 of options in source program is textual. Option may appear in
\r
304 any place of source program, but it is active from the beginning
\r
305 of the nearest instruction. Listing option L is active from the
\r
306 next line after line containing setting this option on up to the
\r
307 line containing setting this option off. Options overwrite defaults,
\r
308 but are overwritten by switches (external options). Option definition
\r
309 is not allowed before the keyword program.
\r
310 <H2>2.1. OPTION FORMAT </H2>
\r
313 Options may be placed in source program in comments in the following
\r
318 where opti consists of character that designates the option and
\r
319 either '+' or '-' e.g.: (*$L-,T+*). Options in one comment should
\r
320 be separated by commas. Spaces in such comment are not allowed.
\r
321 <H2>2.2. OPTIONS LIST </H2>
\r
326 D+ - causes the line numbers of the executed instruction to be
\r
333 L- - default, only incorrect lines are printed on the terminal
\r
335 L+ - all lines are printed on the listing file
\r
339 O+ - optimization of some arithmetical and logical expressions
\r
340 are included to generated code (default),
\r
342 O- - generate code without optimization,
\r
344 T - type conflict checking
\r
346 T+ - default, dynamic checking of type conflict in assignment
\r
347 instructions and in parameter transmissions,
\r
349 T- - no dynamic checking
\r
351 H - memory model (switch only) APPLIES ONLY to PC/AT/XT !!
\r
353 H- - default, small memory
\r
357 PC/AT/XT When H- is specified all code and data must fit into
\r
361 bytes. When H+ is specified all memory available on IBM PC
\r
363 may be utilized, with the cost of increased execution time.
\r
364 <H2>2.3. Fragmentation</H2>
\r
367 It is possible to split one Loglan program into different files.
\r
368 The preprocessor puts together the fragments of a program coming
\r
369 from different files and enables in this way the a compilation
\r
370 and, later, an execution of the entire Loglan source.
\r
372 In any place of Loglan text where it is possible to put semicolon
\r
373 (;) you can put aside the following compiler directive
\r
375 #include < <I>file</I>>
\r
377 It means that any two declarations of instructions can be separated
\r
378 by the directive. Do not forget however to end the preceding declaration
\r
379 or instruction by the semicolon.
\r
383 #include "{path> }< file name> " < CR>
\r
384 CR stands for end of line Carriage Return
\r
388 1. It may be a white space between the word 'include' and the
\r
391 2. You need not to specify the path to the included file if it
\r
392 is stored in the current directory, i.e. the one from which you
\r
393 began the compilation.
\r
395 3. The ortography of path should correspond to the plateform used
\r
397 (i.e. in DOS you use \ characters, in Unix it will be / character)
\r
403 #include c:\loglan\examples\simulation.log
\r
414 The content of the file c:\loglan\examples\simulation.log replaces
\r
416 <H1>3. CURRENT LOGLAN-82 IMPLEMENTATION SPECIFICATION</H1>
\r
418 <H2>3.1. IMPLEMENTED SUBSET OF LOGLAN </H2>
\r
421 The following constructions described in the report of Loglan-82
\r
422 have not been implemented:
\r
424 - local attributes,
\r
426 - separate compilation,
\r
428 File system is described in 3.3.
\r
429 <H2>3.2. PREDEFINED LANGUAGE ELEMENTS </H2>
\r
432 Predefined constants, procedures and functions are added to the
\r
433 language (see Appendix A). Moreover keywords char (short form
\r
434 of character) and bool (short form of boolean) are added.
\r
436 The character set, defined in the report of Loglan-82, is extended
\r
437 by lower-case letters and the tabulation character (decimal code
\r
438 9). It is possible to use operator '< > ' which stands for
\r
440 <H2>3.3. FILE SYSTEM </H2>
\r
443 Loglan contains the predefined reference type file and a set of
\r
444 statements and standard procedures to manipulate files. Both sequential
\r
445 and direct access files are implemented.
\r
446 <H2>3.4. FILE VARIABLES </H2>
\r
449 Variables of the type file can be declared in the Loglan program
\r
450 and can be used as any variables of a reference type.
\r
454 <B>var</B> f:file,
\r
455 A:<B>arrayof</B> file;
\r
457 <B>unit</B> p:<B>procedure</B>(f:file); ... <B>end </B>p;
\r
465 <H3>3.4.1. FILE GENERATION </H3>
\r
468 A file object is generated by open statement of the form:
\r
470 open(f,T) for internal files or <BR>
\r
472 open(f,T,A) for external files <BR>
\r
477 f is a file variable,
\r
479 T = text for text files,
\r
481 char for binary sequential files of character,<BR>
\r
486 direct for direct access binary files.
\r
488 A is an expression of the type arrayof char designating external
\r
489 file name. After execution of open statement the new file object
\r
490 is created and it becomes a value of the file variable f. If the
\r
491 file is opened as an external one, then it references to the file
\r
496 open(data,text) - new internal text file data is opened
\r
498 open(num ,integer) - new internal binary file num is opened
\r
500 (the file components are integer numbers)
\r
502 open(f,text,unpack("my.dat")) - external text file f
\r
505 it references to the file my.dat stored on the default drive and
\r
508 open(f,direct,A) - an external direct access file with name in
\r
510 <H2>3.5. FILE DEALLOCATION </H2>
\r
513 The file can be closed and deallocated by execution of the statement
\r
515 <H2>3.6. GENERAL FILE OPERATIONS </H2>
\r
518 There are three standard procedures associated with files: RESET,
\r
519 REWRITE and UNLINK.
\r
521 call RESET(f) rewinds the file f. After execution of RESET on
\r
522 sequential files only read/get operations are available.
\r
524 call REWRITE(f) creates a new empty file. After execution of REWRITE
\r
525 on sequential files only write/put operations are available.
\r
527 call UNLINK(f) closes and deletes file f. File object is deallocated
\r
528 and f is set to one.
\r
530 RESET or REWRITE must be performed on the file opening before
\r
531 the first I/O operation on it.
\r
532 <H2>3.7. TEXT FILES </H2>
\r
535 The following operations are available to text files: read, readln,
\r
536 eoln, write, writeln, eof. The first parameter of the operation
\r
537 is a file variable. If it is omitted, then a standard input/output
\r
538 file assigned to user's terminal is used.
\r
544 writeln(g," .... ");
\r
545 if eof(f) then ....
\r
549 For more information see [1].
\r
550 <H2>3.8. BINARY SEQUENTIAL FILES</H2>
\r
553 Any file created with the parameter T = integer, real or char
\r
554 is a binary one. It is a sequence of components of the type T.
\r
555 Only objects of type T can be read from or written to this file.
\r
557 The following operations are available to binary files:
\r
559 put(f, w1, ..., wn)
\r
561 get(f, x1, ..., xn)
\r
565 where f is a file opened with the type T, wi is an expression
\r
566 of the type T and xi is a variable of the type T.
\r
568 The statement put(f, w1, ..., wn) writes the components w1, ...,wn
\r
569 to the file f. The statement get(f, x1, ..., xn) reads the next
\r
570 n components from the file f and assigns them to the variables
\r
571 x1, ..., xn. The statement eof is the same as for text files.
\r
572 <H2>3.9. DIRECT ACCESS BINARY FILES</H2>
\r
575 Direct access files are treated as a sequence of bytes without
\r
576 any interpretation. Operations RESET and REWRITE prepare a file
\r
577 for both reading and writing. RESET is used for existing files,
\r
579 REWRITE for the new ones.
\r
581 The following additional operations are available:
\r
583 call SEEK(f, offset, base) - moves the file pointer to the position
\r
584 designated by offset relative to base.
\r
586 Offset is a signed integer specifying the number of bytes.
\r
588 Possible values for base are:
\r
590 0 - begining of file,
\r
592 1 - current position of file pointer,
\r
594 2 - end of the file.
\r
598 call SEEK(f, 0, 0) - rewinds file f,
\r
600 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 pointer associated
\r
608 PUTREC(f, A, n) - where A is an array of any primitive type and
\r
609 n is an integer variable. Let k be the number of bytes occupied
\r
610 by elements of array A. This operation writes min(k, n) bytes
\r
611 from A to the file f and advances file pointer by the number of
\r
612 written bytes. The number of bytes written to the file is returned
\r
615 GETREC(f, A, n) - where A is an existing array of any primitive
\r
616 type and n is an integer variable. Let k be the number of bytes
\r
617 occupied by elements of array A This operation reads min(k,n)
\r
618 bytes (or less, if end of file is encountered) from the file and
\r
619 advances the file pointer by the number of read bytes. The number
\r
620 of bytes read from the file is returned in the variable n.
\r
621 <H2>3.10. CONCURRENCY</H2>
\r
624 Implemented concurrency mechanisms differ much from those described
\r
625 in the LOGLAN-82 report []. In particular, only distributed processes
\r
626 are implemented, so they cannot communicate through shared variables.
\r
627 For this reason semaphores had to be replaced by an entirely new
\r
628 communication mechanism. Such a mechanism has been designed and
\r
629 it is based on the rendez-vous schema.
\r
630 <H3>3.10.1. INVOKING THE LOGLAN INTERPRETER FOR CONCURRENT PROGRAMS
\r
634 A concurrent LOGLAN program may run on a single computer with
\r
635 concurrency simulated by time slicing. In this case LOGLAN interpreter
\r
636 is invoked as usual. One must only remember that /m optional parameter
\r
637 (see 1.4.) denotes memory size for each process rather than for
\r
640 To achieve true parallel (multiprocessor) execution, a network
\r
641 of IBM PC computers may be used. For the time being, only D-Link
\r
642 Network Version 3.21 is supported. In order to run a LOGLAN program
\r
643 in the network environment take the following steps:
\r
645 1) make sure that every node is logged on,
\r
647 2) select arbitrarily one node as a console,
\r
649 3) invoke the LOGLAN interpreter on every node except the console,
\r
650 giving it /r option with the console node number (see 1.4.). You
\r
651 must give the same program file to all interpreters. Most conveniently
\r
652 it may be achieved by accessing a file on a disk connected through
\r
653 the network to each node.
\r
655 4) invoke the interpreter on the console without the /r option
\r
656 (in the usual way). Give it the same program file as above.
\r
658 After the last step the main program process begins its execution
\r
659 on the console node. Other processes may be created dynamically
\r
660 on any node on which an interpreter is running.
\r
662 <B>Regardless of the fact whether the network is used or not,
\r
663 more than one process may be executed on the same computer.</B>
\r
665 <H3>3.10.2. RESTRICTIONS AND DIFFERENCES FROM THE REPORT</H3>
\r
668 All processes (even those executed on the same computer) are implemented
\r
669 as distributed, i.e. without any shared memory. This fact implies
\r
670 some restrictions on how processes may be used. Not all restrictions
\r
671 are enforced by the present compiler, so it is the programmer's
\r
672 responsibility to respect them. This is the list of restrictions:
\r
674 1) all process units must be declared as global, i.e. directly
\r
675 inside the main program,
\r
677 2) a process cannot access global variables (except for the main
\r
680 3) any remote access to a process object other than a procedure
\r
683 4) each parameter of
\r
687 a procedure called by remote access to a process object,
\r
689 a procedure parameter of a process,
\r
691 must be one of the following:
\r
693 a value of the primitive type (INTEGER, REAL, CHAR, BOOLEAN, STRING)
\r
695 a procedure declared directly inside a process
\r
697 a procedure which is a formal parameter of a process
\r
699 any reference to a process object.
\r
701 This restriction implies that references to objKcts other than
\r
702 processes have only local meaning (in a single process) and cannot
\r
703 be passed among the processes.
\r
705 5) comparisons, IS, IN and QUA operations are not allowed for
\r
706 the references to processes.
\r
708 6) operations which require dynamic type checking on the references
\r
709 to processes are not allowed.
\r
711 7) a process may be attached only by a proper coroutine generated
\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
\r
717 not implemented at all:
\r
719 - semaphores and all operations on them
\r
721 - the WAIT expression.
\r
723 Semantics of the NEW generator is slightly modified when applied
\r
724 to the processes. The first parameter of the first process unit
\r
725 in the prefix sequence <I><B>must</B></I> be of type INTEGER.
\r
726 This parameter denotes the node number of the computer on which
\r
727 this process will be created. For a single computer operation
\r
728 this parameter must be equal to 0.
\r
732 <B>unit</B> A:<B>class</B>(msg:string);
\r
735 <B>unit</B> P:A process(node:integer, pi:real);
\r
742 (* Create process on node 4. The first parameter is the *)
\r
743 (* string required by the prefix A, the second is the node number *)
\r
744 x := <B>new</B> P("Hello", 4, 3.141592653);
\r
752 The following parallel constructs are implemented as defined in
\r
755 - KILL operation for a process
\r
759 - STOP statement without parameter.
\r
760 <H3>3.10.3. COMMUNICATION MECHANISM</H3>
\r
763 Processes may communicate and synchronize by a mechanism based
\r
764 on rendez-vous. It will be referred to as "alien call"
\r
765 in the following description.
\r
767 An alien call is either:
\r
769 - a procedure (or function) call performed by a remote access
\r
770 to a process object, or
\r
772 - a call of a procedure which is a formal parameter of a process,
\r
775 - a call of a procedure which is a formal parameter of an alien-called
\r
776 procedure (this is a recursive definition). Every process object
\r
777 has an enable mask. It is defined as a subset of all procedures
\r
778 declared directly inside a process unit or any unit from its prefix
\r
779 sequence (i.e. subset of all procedures that may be alien-called).
\r
781 A procedure is enabled in a process if it belongs to that process'
\r
782 enable mask. A procedure is disabled if it does not belong to
\r
785 Immediately after generation of a process object its enable mask
\r
786 is empty (all procedures are disabled).
\r
788 Semantics of the alien call is different from the remote call
\r
789 described in the report. Both the calling process and the process
\r
790 in which the procedure is declared (i.e. the called process) are
\r
791 involved in the alien call. This way the alien call may be used
\r
792 as a synchronization mechanism.
\r
794 The calling process passes the input parameters and waits for
\r
795 the call to be completed.
\r
797 The alien-called procedure is executed by the called process.
\r
798 Execution of the procedure will not begin before certain conditions
\r
799 are satisfied. First, the called process must not be suspended
\r
800 in any way. The only exception is that it may be waiting during
\r
801 the ACCEPT statement (see below). Second, the procedure must be
\r
802 enabled in the called process.
\r
804 When the above two conditions are met the called process is interrupted
\r
805 and forced to execute the alien-called procedure (with parameters
\r
806 passed by the calling process).
\r
808 Upon entry to the alien-called procedure all procedures become
\r
809 disabled in the called process.
\r
811 Upon exit the enable mask of the called process is restored to
\r
812 that from before the call (regardless of how it has been changed
\r
813 during the execution of the procedure). The called process is
\r
814 resumed at the point of the interruption. The execution of the
\r
815 ACCEPT statement is ended if the called process was waiting during
\r
816 the ACCEPT (see below).
\r
818 At last the calling process reads back the output parameters and
\r
819 resumes its execution after the call statement.
\r
821 The process executing an alien-called procedure can easily be
\r
822 interrupted by another alien call if the enable mask is changed.
\r
824 There are some new language constructs associated with the alien
\r
825 call mechanism. The following statements change the enable mask
\r
830 enables the procedures with identifiers p1, ..., pn. If there
\r
831 are any processes waiting for an alien call of one of these procedures,
\r
832 one of them is chosen and its request is processed. The scheduling
\r
833 is done on a FIFO basis, so it is strongly fair. The statement:
\r
835 DISABLE p1, ..., pn
\r
837 disables the procedures with identifiers p1, ..., pn.
\r
839 In addition a special form of the RETURN statement:
\r
841 RETURN ENABLE p1, ..., pn DISABLE q1, ..., qn
\r
843 allows to enable the procedures p1, ..., pn and disable the procedures
\r
844 q1,...,qn after the enable mask is restored on exit from the alien-called
\r
845 procedure. It is legal only in the alien-called procedures (the
\r
846 legality is not enforced by the compiler).
\r
848 A called process may avoid busy waiting for an alien call by means
\r
849 of the ACCEPT statement:
\r
853 adds the procedures p1, ..., pn to the current mask, and waits
\r
854 for an alien call of one of the currently enabled procedures.
\r
855 After the procedure return the enable mask is restored to that
\r
856 from before the ACCEPT statement.
\r
858 Note that the ACCEPT statement alone (i.e. without any ENABLE/DISABLE
\r
859 statements or options) provides a sufficient communication mechanism.
\r
860 In this case the called process may execute the alien-called procedure
\r
861 only during the ACCEPT statement (because otherwise all procedures
\r
862 are disabled). It means that the enable mask may be forgotten
\r
863 altogether and the alien call may be used as a pure totally synchronous
\r
864 rendez-vous. Other constructs are introduced to make partially
\r
865 asynchronous communication patterns possible.
\r
866 <H2>3.11. SYSTEM SIGNALS </H2>
\r
869 System signals are connected to runtime errors (see APPENDIX C).
\r
871 These signals are the following:
\r
873 ACCERROR - reference to non existing object, CONERROR - array
\r
874 index outside the range or lower bound is greater than upper bound
\r
875 during array object generation, LOGERROR - errors related to control
\r
876 transfer, MEMERROR - memory overflow, NUMERROR - errors related
\r
877 to arithmentic operations like division by zero, floating point
\r
878 overflow, TYPERROR - type conflict in assignment statement, during
\r
879 parameter tran smission or headline conflict for actual parameter
\r
880 function and procedure. SYSERROR - errors related to file system,
\r
881 like reading after writing, too many files etc.
\r
882 <H2>3.12. IMPLEMENTATION RESTRICTIONS </H2>
\r
885 - Text line in source program can't be longer than 80 characters.
\r
886 - Maximal length of identifier is 20 characters, but entire length
\r
887 of all identifiers and keywords should be less than 3000 characters.
\r
888 - String constant can't be longer than 260 characters. - For case
\r
889 instructions: - up to 6 levels of nested case instructions are
\r
890 allowed, - range of labels can't be greater than 160. - Number
\r
891 of formal parameters can't be greater than 40, whereas up to 35
\r
892 output or input parameters are allowed. Total number of formal
\r
893 parameters and variables declared in one module can't be greater
\r
894 than 130. - Number of array indices (i.e. arrayof) can't be greater
\r
895 than 63, - Standard type integer has the range (-32767,+32767)
\r
896 for small memory (16 - bit word). For huge memory (32-bit word)
\r
897 the range is (-2147483647,+2147483647), but values of constant
\r
898 expressions in a program must lie within the range (-2767, 32767).
\r
899 - Real numbers have the range (-8.43E-37, 3.37E+38) with 24-bit
\r
900 mantissa and 8-bit exponenet for small memory , giving about 7
\r
901 digits of precision. For huge memory the range is (4.19E-307,
\r
902 1.67E+308) with 53-bit mantissa and 11-bit exponent, giving about
\r
903 15 digits of precision.Values of constant expression in a program
\r
904 must lie in the range (-8.43E-37, 3.37E+38). Warning
\r
906 Compiler computes values of expressions built from constants without
\r
907 range checking. It means, that integer overflow, floating point
\r
908 overflow or underflow cause incorrect result without any message.
\r
909 <H1>APPENDIX A : PREDEFINED CONSTANTS</H1>
\r
914 The size in bytes of integer variables
\r
918 The size in bytes of real variables
\r
919 <H1>APPENDIX B : PREDEFINED CLASSES</H1>
\r
922 of GRAPHICS & MOUSE
\r
924 for PC486 for Unix for PC286
\r
925 <H1>APPENDIX C : PREDEFINED PROCEDURES AND FUNCTIONS </H1>
\r
928 ENDRUN:procedure; <BR>
\r
929 Terminates program execution (ABORT). <BR>
\r
930 RANSET:procedure(x:real); <BR>
\r
931 Initializes random generator (for RANDOM function) <BR>
\r
932 RANDOM:function:real; <BR>
\r
933 Generates uniformly distributed pseudo-random numbers in the interval
\r
935 SQRT:function(x:real):real; <BR>
\r
936 Computes square root of parameter x. <BR>
\r
937 SIN:function(x:real):real; <BR>
\r
938 Computes sinus of parameter x. <BR>
\r
939 COS:function(x:real):real; <BR>
\r
940 Computes cosinus of parameter x. <BR>
\r
941 TAN:function(x:real):real; <BR>
\r
942 Computes tangens of parameter x. <BR>
\r
943 EXP:function(x:real):real; <BR>
\r
944 Computes e**x. <BR>
\r
945 LN:function(x:real):real; <BR>
\r
946 Computes natural logarithmus of parameter x. <BR>
\r
947 ATAN:function(x:real):real; <BR>
\r
948 Computes arcus tangens of parameter x. <BR>
\r
949 ENTIER:function(x:real):integer; <BR>
\r
950 Computes entier part of parameter x. <BR>
\r
951 ROUND:function(x:real):integer; <BR>
\r
952 Computes rounded value of parameter x: ROUND(x)=ENTIER(x+0.5).
\r
954 IMIN:function(x, y:integer):integer; <BR>
\r
955 Computes minimum of two parameters. <BR>
\r
956 IMAX:function(x, y:integer):integer; <BR>
\r
957 Computes maximum of two parameters. <BR>
\r
958 IMIN3:function(x, y, z:integer):integer; <BR>
\r
959 Returns the minimum of three parameters. <BR>
\r
960 IMAX3:function(x, y, z:integer):integer; <BR>
\r
961 Returns maximum of three parameters. <BR>
\r
962 ISHFT:function(x, k:integer):integer; <BR>
\r
963 Logically shifts x by k bits: left, when k is positive, right
\r
965 IAND:function(n, k:integer):integer; <BR>
\r
966 Returns logical product of parameters (on all bits). <BR>
\r
967 IOR:function(n, k:integer):integer; <BR>
\r
968 Returns logical sum of parameters (on all bits). <BR>
\r
969 XOR:function(n, k:integer):integer; <BR>
\r
970 Returns exlusive sum of parameters (on all bits). <BR>
\r
971 INOT:function(n:integer):integer; <BR>
\r
972 Returns logical complement of parameters (on all bits). <BR>
\r
973 ORD:function(c:char):integer; <BR>
\r
974 Returns number that represents character c (see APPENDIX F).
\r
976 The following equations are satisfied: CHR(ORD(c)) = c & ORD(CHR(n))
\r
978 CHR:function(n:integer):char; <BR>
\r
979 Returns character represented by parameter n (see APPENDIX F).
\r
981 UNPACK:function(s:string):arrayof char; <BR>
\r
982 Returns address of new array object containing characters of the
\r
984 MEMAVAIL:function:integer;<BR>
\r
985 Returns the size of available memory in the current process (in
\r
987 EXEC:function(cmd:arrayof char):integer; <BR>
\r
988 Calls secondary command processor with cmd as a command string.
\r
989 Exit code is returned as a value of EXEC. TIME:function: integer;
\r
991 Returns an integer value indicating the amount of central processor
\r
993 time in seconds used by current process. <BR>
\r
994 RESET:procedure(f:file); <BR>
\r
995 Positionnes file f at the first component and readies it to reading.
\r
997 REWRITE:procedure(f:file); <BR>
\r
998 Positionnes file f at the first component and readies it for output.
\r
1000 The file f becomes empty (eof(f) = true). <BR>
\r
1001 UNLINK:procedure(f:file);<BR>
\r
1002 Closes and deletes file f (see 3.3.4)<BR>
\r
1003 SEEK:procedure(f:file; offset, base:integer);<BR>
\r
1004 Positiones file pointer (see 3.3.7)<BR>
\r
1005 POSITION:function(f:file):real;<BR>
\r
1006 Reads position of file pointer (see 3.3.7)
\r
1007 <H1>appendix D: Error Codes APPENDIX E : LOGLAN RUNTIME ERRORS
\r
1011 In the following list system signal name, raised after detection
\r
1012 of runtime error, is placed in brackets.
\r
1014 ARRAY INDEX ERROR (CONERROR)
\r
1016 Index outside range during reference to array variable. NEGATIVE
\r
1017 STEP VALUE (CONERROR)
\r
1019 SL CHAIN CUT OFF (LOGERROR) <BR>
\r
1022 Control transfer to object that has SL link cut off earlier in
\r
1023 the consequence of kill operation. ILLEGAL ATTACH (LOGERROR)
\r
1025 The value of parameter of attach instruction is none or object
\r
1026 differs from coroutine. ILLEGAL DETACH (LOGERROR)
\r
1028 An attempt to return by detach to coroutine that has been dealocated
\r
1029 (by kill). ILLEGAL RESUME (LOGERROR)
\r
1031 An attempt to resume an object which is not a process or a process
\r
1032 which is running. TOO MANY PROCESSES ON ONE MACHINE (SYSERROR)
\r
1034 Number of processes existing on one computer is greater than 64.
\r
1035 INVALID NODE NUMBER (SYSERROR)
\r
1037 An attempt to create a process on a computer which is not connected
\r
1038 to network. IMPROPER QUA (LOGERROR)
\r
1040 Error during computing expression of the form: ...x qua a, when
\r
1041 'x' references to none or 'a' doesn't prefix dynamic type object,
\r
1042 which is value of 'x'. ILLEGAL ASSIGNMENT (TYPERROR)
\r
1044 Type conflict between left and right side of assignment instruction.
\r
1045 FORMAL TYPE MISSING (LOGERROR)
\r
1047 Formal type is not accessible because of SL cut off. ILLEGAL KILL
\r
1050 An attempt to deallocate object in SL chain of active object.
\r
1051 ILLEGAL COPY (LOGERROR)
\r
1053 An attempt to copy non terminated object (i.e. class before execution
\r
1054 of return statement, coroutine before execution of end statement...).
\r
1055 REFERENCE TO NONE (ACCERROR)
\r
1057 An attempt to remote access (by dot) to attributes of non existing
\r
1058 object: dealocated or not generated. MEMORY OVERFLOW (MEMERROR)
\r
1060 INCOMPATIBLE HEADERS (TYPERROR) <BR>
\r
1063 Actual parameter list of generated object (procedure, function
\r
1064 or class) is incompatible with formal parameter list from module
\r
1065 declaration or formal function type is incompatible with actual
\r
1066 function type. INCORRECT ARRAY BOUNDS (CONERROR) <BR>
\r
1069 An attempt to generate dynamic array object, when lower bound
\r
1070 of index range is greater than upper bound.
\r
1072 DIVISION BY ZERO (NUMERROR) <BR>
\r
1075 COROUTINE TERMINATED (LOGERROR)
\r
1077 An attempt to transfer control to a terminated coroutine. COROUTINE
\r
1080 An attempt to transfer control to an active coroutine. HANDLER
\r
1081 NOT FOUND (LOGERROR)
\r
1083 There is no handler for signal declared by user. ILLEGAL RETURN
\r
1086 An attempt to execute return instruction in handler serving system
\r
1087 signal. UNIMPLEMENTED STANDARD PRC. (LOGERROR)
\r
1089 Standard procedure or function is not implemented. FORMAL LIST
\r
1090 TOO LONG (MEMERROR)
\r
1092 Formal parameter list is greater than 40. ILLEGAL I/O OPERATION
\r
1095 Reading after writing, the type of the read/write parameter does
\r
1096 not match the type of the file etc. I/O ERROR (SYSERROR)
\r
1098 System error during I/O. CANNOT OPEN FILE (SYSERROR)
\r
1100 INPUT DATA FORMAT BAD (SYSERROR)<BR>
\r
1103 SYSTEM ERROR (SYSERROR)<BR>
\r
1104 Should not occur. UNRECOGNIZED ERROR
\r
1105 <H1>APPENDIX F : CHARACTER SET </H1>
\r
1108 At the top of the table are hexadecimal digits (0 to 7), and to
\r
1109 the left of the table are hexadecimal digits (0 to F). Hexadecimal
\r
1110 code of ASCII character is constructed by contatenation of column
\r
1111 label and row label. For example, the value of character representing
\r
1112 the plus sign is 2B.
\r
1115 _________________________________________________
\r
1116 ! ! ! ! ! ! ! ! !
\r
1117 0 ! NUL ! DLE ! SP ! 0 ! @ ! P ! ! p !
\r
1118 _________________________________________________
\r
1119 ! ! ! ! ! ! ! ! !
\r
1120 1 ! SOH ! DC1 ! ! ! 1 ! A ! Q ! a ! q !
\r
1121 _________________________________________________
\r
1122 ! ! ! ! ! ! ! ! !
\r
1123 2 ! STX ! DC2 ! " ! 2 ! B ! R ! b ! r !
\r
1124 _________________________________________________
\r
1125 ! ! ! ! ! ! ! ! !
\r
1126 3 ! ETX ! DC3 ! # ! 3 ! C ! S ! c ! s !
\r
1127 _________________________________________________
\r
1128 ! ! ! ! ! ! ! ! !
\r
1129 4 ! EOT ! DC4 ! $ ! 4 ! D ! T ! d ! t !
\r
1130 _________________________________________________
\r
1131 ! ! ! ! ! ! ! ! !
\r
1132 5 ! ENQ ! NAK ! % ! 5 ! E ! U ! e ! u !
\r
1133 _________________________________________________
\r
1134 ! ! ! ! ! ! ! ! !
\r
1135 6 ! ACK ! SYN ! & ! 6 ! F ! V ! f ! v !
\r
1136 _________________________________________________
\r
1137 ! ! ! ! ! ! ! ! !
\r
1138 7 ! BEL ! ETB ! ' ! 7 ! G ! W ! g ! w !
\r
1139 _________________________________________________
\r
1140 ! ! ! ! ! ! ! ! !
\r
1141 8 ! BS ! CAN ! ( ! 8 ! H ! X ! h ! x !
\r
1142 _________________________________________________
\r
1143 ! ! ! ! ! ! ! ! !
\r
1144 9 ! HT ! EM ! ) ! 9 ! I ! Y ! i ! y !
\r
1145 _________________________________________________
\r
1146 ! ! ! ! ! ! ! ! !
\r
1147 A ! LF ! SUB ! * ! : ! J ! Z ! j ! z !
\r
1148 _________________________________________________
\r
1149 ! ! ! ! ! ! ! ! !
\r
1150 B ! VT ! ESC ! + ! ; ! K ! [ ! k ! { !
\r
1151 _________________________________________________
\r
1152 ! ! ! ! ! ! ! ! !
\r
1153 C ! FF ! FS ! , ! < ! L ! \ ! l ! | !
\r
1154 _________________________________________________
\r
1155 ! ! ! ! ! ! ! ! !
\r
1156 D ! CR ! GS ! - ! = ! M ! ] ! m ! } !
\r
1157 _________________________________________________
\r
1158 ! ! ! ! ! ! ! ! !
\r
1159 E ! SO ! RS ! . ! > ! N ! ^ ! n ! ~ !
\r
1160 _________________________________________________
\r
1161 ! ! ! ! ! ! ! ! !
\r
1162 F ! SI ! US ! / ! ? ! O ! _ ! o ! DEL !
\r
1163 _________________________________________________
\r
1169 NUL Null DLE Data Link Escape
\r
1170 SOH Start of Heading DC1 Device Control 1
\r
1171 STX Start of Text DC2 Device Control 2
\r
1172 ETX End of Text DC3 Device Control 3
\r
1173 EOT End of Transmission DC4 Device Control 4
\r
1174 ENQ Enquiry NAK Negative Acknowledge
\r
1175 ACK Acknowledge SYN Synchronous Idle
\r
1176 BEL Bell ETB End of Transmission Block
\r
1177 BS Backspace CAN Cancel
\r
1178 HT Horizontal Tabulation EM End of Medium
\r
1179 LF Line Feed SUB Substitute
\r
1180 VF Vertical Tab ESC Escape
\r
1181 FF Form Feed FS File Separator
\r
1182 CR Carriage Return GS Group Separator
\r
1183 SO Shift Out RS Record Separator
\r
1184 SI Shift In US Unit Separator
\r
1185 SP Space DEL Delete
\r
1188 <H1>Bibliography</H1>
\r
1191 16 LITA, Pau Loglan'82 user's manual Loglan'82 users's manual
\r
1192 November 24, 1994 15
\r
projects / loglan.git / blob