This commit adds a new section to the GCC Internals Manual and also adds two new manuals.
ga68.texi is The GNU Algol 68 Compiler user manual. It describes how to use the compiler and all the GNU extensions implemented on top of the Algol 68 programming language. ga68-internals.texi is The GNU algol68 Compiler Internals manual. It describes the implementation of the front-end and it is of interest primarily for developers. Signed-off-by: Jose E. Marchesi <[email protected]> gcc/ChangeLog * algol68/ga68-internals.texi: New file. * algol68/ga68.texi: Likewise. * doc/tm.texi.in: New section ALGOL 68 language and ABI. * doc/tm.texi: Regenerate. --- gcc/algol68/ga68-internals.texi | 383 ++++ gcc/algol68/ga68.texi | 3121 +++++++++++++++++++++++++++++++ gcc/doc/tm.texi | 18 + gcc/doc/tm.texi.in | 9 + 4 files changed, 3531 insertions(+) create mode 100644 gcc/algol68/ga68-internals.texi create mode 100644 gcc/algol68/ga68.texi diff --git a/gcc/algol68/ga68-internals.texi b/gcc/algol68/ga68-internals.texi new file mode 100644 index 00000000000..1c0bad85f5e --- /dev/null +++ b/gcc/algol68/ga68-internals.texi @@ -0,0 +1,383 @@ +\input texinfo @c -*-texinfo-*- +@c %**start of header +@setfilename ga68-internals.info + +@include gcc-common.texi + +@synindex tp cp + +@settitle GNU Algol 68 Compiler Internals + +@c %**end of header + +@c %** start of document + +@copying +Copyright @copyright{} 2025 Jose E. Marchesi. + +Permission is granted to copy, distribute and/or modify this document +under the terms of the GNU Free Documentation License, Version 1.3 or +any later version published by the Free Software Foundation; with no +Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A +copy of the license is included in the section entitled ``GNU Free +Documentation License''. +@end copying + +@ifinfo +@dircategory Software development +@direntry +* ga68-internals: (ga68-internals). The GNU Algol 68 Compiler Internals. +@end direntry +This file documents the internals of the GNU Algol 68 +compiler, (@command{ga68}). + +@insertcopying +@end ifinfo + +@c Macro for bold-tags. In TeX and HTML they expand to proper bold words, +@c in other formats it resorts to upper stropping. +@iftex +@macro B{tag} +@strong{\tag\} +@end macro +@end iftex + +@ifhtml +@macro B{tag} +@strong{\tag\} +@end macro +@end ifhtml + +@ifnottex +@ifnothtml +@macro B{tag} +@sc{\tag\} +@end macro +@end ifnothtml +@end ifnottex + +@setchapternewpage odd +@titlepage +@title GNU Algol 68 Internals +@versionsubtitle +@author Jose E. Marchesi +@page +@vskip 0pt plus 1filll +@sp 1 +@insertcopying +@end titlepage + +@summarycontents +@contents + +@page + +@ifnottex +@node Top +@top Introduction +@cindex Introduction + +This manual documents (some of) the internals of @command{ga68}, the +GNU Algol 68 compiler. + +@menu +* Scope Checking:: Scope checking in assignation. +* Storage Management:: Management of run-time storage. +* Lowering Declarations:: Mapping external objects to internal objects. +* Lowering Assignations:: Superceding the value referred by a name. +* GNU Free Documentation License:: + How you can copy and share this manual. +* Index:: Index of this documentation. +@end menu +@end ifnottex + +@c --------------------------------------------------------------------- +@c Scope Checking +@c --------------------------------------------------------------------- + +@node Scope Checking +@chapter Scope Checking + +Static scope checking: pass. +Dynamic scope checking: run-time call. + +@c --------------------------------------------------------------------- +@c Storage Management +@c --------------------------------------------------------------------- + +@node Storage Management +@chapter Storage Management + +This chapter discusses the run-time management of internal objects in +Algol 68. + +First, a conceptual model is presented that describes the restrictions +as mandated by the Report. The storage implied by the lowered GENERIC +entities, as described in the previous chapter, shall match the +storage of the conceptual model. + +@menu +* Storage Structure of Objects:: +* Copying of Objects:: +* The Stack:: +* The Heap:: +@end menu + +@node Storage Structure of Objects +@section Storage Structure of Objects + +The internal objects which are the values in an Algol 68 program may +consist on a hierarchy of memory locations, which may not be +contiguous. This hierarchy of memory locations is the storage +structure of the object, and is not concerned by the particular +bit-patterns stored. + +Simple values. + +Names. + +Multiple values. + +Structured values. + +Values of united modes. + +@node Copying of Objects +@section Copying of Objects + +@node The Stack +@section The Stack + +XXX + +@node The Heap +@section The Heap + +@itemize @minus +@item +A value that has rows and gets returned by a procedure shall be +allocated on the stack. +@item +A copy of the right hand side is made before assigning it to the left +hand side. This copy is always allocated in the heap, because the +scope of the left hand side may be older than the scope of the right +hand side. This happens when assigning to a global variable. +@item +A trimmer of a name. This is because the trimmed multiple may be +allocated on the heap, and the trim shall have the same scope than the +trimmed multiple. +@end itemize + +@c --------------------------------------------------------------------- +@c Internal Objects +@c --------------------------------------------------------------------- + +@node Lowering Declarations +@chapter Lowering Declarations + +This chapter describes the mapping between external objects declared +in identity and variable declarations and the internal objects that +are the result of lowering the external objects in the parse tree into +GENERIC entities. + +@menu +* Identity Declarations:: @code{@B{amode} xxx = init value} +* Variable Declarations:: @code{@B{amode} xxx [:= init value]} +* Procedure Identity Declarations:: @code{@B{proc} xxx = routine text} +* Procedure Variable Declarations:: @code{@B{proc} xxx := routine text} +* Operator Brief Declarations:: @code{@B{op} @B{xxx} = routine text} +* Operator Declarations:: @code{@B{op}(...)@B{amode} @B{xxx} = routine text} +* Applied Identifiers:: +@end menu + +@node Identity Declarations +@section Identity Declarations + +An identity declaration with the form: + +@example +@B{c} part 1 @B{c} +@B{amode} defining_identifier = unit; +@B{c} part 2 @B{c} +@end example + +@noindent +Introduces the identifier @code{defining_identifier} in the current +range and ascribes a copy of the value yielded by @code{unit} to it. +Once established, the relationship between an identifier and the value +ascribed to it is constant and it cannot change during the reach of +the identifier. The ascribed unit can be any unitary clause, and its +elaboration can be arbitrarily complicated. In particular, it is not +required to be a compile-time constant. @code{@B{amode}} determines +the mode of the value yielded by the unit, and the unit is elaborated +in a strong context. + +An identity declaration like the above, where @code{@B{amode}} is not +a procedure mode (@xref{Procedure Identity Declarations}) is lowered +into: + +@itemize @bullet +@item +A @code{VAR_DECL} with name @code{defining_identifier}, type +@code{CTYPE (@B{amode})} and initial value @code{@B{amode}(@B{skip})} +that gets chained into the declarations list of the current block. +@item +A @code{DECL_EXPR} that gets prepended in the current statement's list. +@item +A @code{MODIFY_EXPR} setting the @code{VAR_DECL} to a copy of the +lowering of @code{unit}, @code{a68_low_dup (unit)}. +@end itemize + +@noindent +Schematically: + +@example + BIND_EXPR (BLOCK (DECLS: ... -> VAR_DECL (defining_identifier, INITIAL=SKIP))) + STMT_LIST + | + +-- DECL_EXPR (defining_identifier) + | + | @B{c} part 1 @B{c} + | + +-- MODIFY_EXPR (defining_identifier, unit) + | + | @B{c} part 2 @B{c} + | +@end example + +The reason why the @code{VAR_DECL} is initialized to @code{@B{skip}} +and then set to the initial @code{unit} specified in the source line +is that the Report specifies that Algol 68 identifiers can be used +before they are defined provided we are in the right range, but in +that case the value ascribed to the identifier is ``undefined''. +Accessing an ``undefined'' value in traditional Algol 68 +implementations would lead to a run-time error (these implementations +used a special value to denote undefined, such as @code{F00L}) but in +GNU Algol 68 the ``undefined'' value is always @code{@B{skip}} which, +if not terribly useful in most cases, is at least well defined in this +implementation and doesn't lead to an error. + +Identity declarations are the Algol 68 way of defining constants, and +one may wonder why we are not using @code{CONST_DECL} instead of +@code{VAR_DECL}. The reason is that @code{CONST_DECL} is really only +intended for integral values in C enums, and the @code{@B{amode}} in +the identity declaration can really be any mode, from simple integers +or characters to fairly complicated structured modes, which may +involve also rows and united modes. Whether the @code{VAR_DECL} will +lead to allocating storage on the stack depends on the nature of the +mode and the way the identifier is used in the program: whether its +address is taken, etc. + +@node Variable Declarations +@section Variable Declarations + +A variable declaration with the form: + +@example +[@B{loc}|@B{heap}] @B{amode} defining identifier [:= unit]; +@end example + +@noindent +Is in principle equivalent to the identity declaration: + +@example +@B{ref} @B{amode} defining identifier = [@B{loc}|@B{heap}] @B{amode}; +@end example + +@noindent +In both cases the object ascribed to the defining identifier is of +mode @code{@B{ref} @B{amode}}. The ascribed object is a name which is +created by a generator implied in the actual declarer in the variable +declaration case, and an explicit generator in the initialization +expression in the identity declaration case. + +However, in this compiler these two cases are handled differently in +order to reduce the amount of both indirect addressing and of storage: + +@itemize @bullet +@item +The variable declaration @code{[@B{loc}|@B{heap}] @B{amode} foo} +lowers into a @code{VAR_DECL} with type @code{CTYPE (amode)} provided +that the generator is @code{@B{loc}} and that the type contains no +rows. Accessing the variable will then involve direct addressing, and +when its address is required an @code{ADDR_EXPR} shall be used. +@item +The identity declaration @code{@B{ref} @B{amode} foo = @B{loc} +@B{amode}} lowers into a @code{VAR_DECL} with type @code{*CTYPE +(amode)}. Accessing the variable will then involve indirect +addressing: it is effectively a pointer. +@end itemize + +This optimization introduces the complication that an expression (the +@code{VAR_DECL}) whose type is TYPE can appear in a place where *TYPE +is expected, depending on the context and the r-value and l-value +interpretation of the @code{VAR_DECL}. The function +@code{a68_consolidate_ref} is used in several parts of the lowering +pass to guarantee a given name is an address regardless of how it was +initialized. + +@node Procedure Identity Declarations +@section Procedure Identity Declarations + +XXX + +@node Procedure Variable Declarations +@section Procedure Variable Declarations + +XXX + +@node Operator Brief Declarations +@section Operator Brief Declarations + +XXX + +@node Operator Declarations +@section Operator Declarations + +XXX + +@node Applied Identifiers +@section Applied Identifiers + +XXX + +@c --------------------------------------------------------------------- +@c Lowering Assignations +@c --------------------------------------------------------------------- + +@node Lowering Assignations +@chapter Lowering Assignations + +Scope checking: + +@itemize @bullet +@item +If static scope checking is relevant and OK, then just perform assignation. +@item +If static scope checking is relevant and not OK, a compile-time error +will have already being emitted. +@item +If static scope checking is not relevant, perform dynamic scope +checking: each time a name, a routine or a format of the data +structure is assigned, its dynamic scope (scope%_si) is compared with +the one of the destination (scope%_d). A run-time error message is +provided in case scope%_d < scope%_si. +@end itemize + +@c --------------------------------------------------------------------- +@c GNU Free Documentation License +@c --------------------------------------------------------------------- + +@include fdl.texi + + +@c --------------------------------------------------------------------- +@c Index +@c --------------------------------------------------------------------- + +@node Index +@unnumbered Index + +@printindex cp + +@bye diff --git a/gcc/algol68/ga68.texi b/gcc/algol68/ga68.texi new file mode 100644 index 00000000000..d000e791e6d --- /dev/null +++ b/gcc/algol68/ga68.texi @@ -0,0 +1,3121 @@ +\input texinfo @c -*-texinfo-*- +@setfilename ga68.info +@settitle The GNU Algol 68 Compiler + +@c Macro for bold-tags. In TeX and HTML they expand to proper bold words, +@c in other formats it resorts to upper stropping. +@iftex +@macro B{tag} +@strong{\tag\} +@end macro +@end iftex + +@ifhtml +@macro B{tag} +@strong{\tag\} +@end macro +@end ifhtml + +@ifnottex +@ifnothtml +@macro B{tag} +\tag\ +@end macro +@end ifnothtml +@end ifnottex + +@c Create a separate index for command line options +@defcodeindex op +@c Merge the standard indexes into a single one. +@syncodeindex fn cp +@syncodeindex vr cp +@syncodeindex ky cp +@syncodeindex pg cp +@syncodeindex tp cp + +@include gcc-common.texi + +@c Copyright years for this manual. +@set copyrights-ga68 2025 + +@copying +@c man begin COPYRIGHT +Copyright @copyright{} @value{copyrights-ga68} Free Software Foundation, Inc. + +Permission is granted to copy, distribute and/or modify this document +under the terms of the GNU Free Documentation License, Version 1.3 or +any later version published by the Free Software Foundation; with no +Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. +A copy of the license is included in the +@c man end +section entitled ``GNU Free Documentation License''. +@ignore +@c man begin COPYRIGHT +man page gfdl(7). +@c man end +@end ignore +@end copying + +@ifinfo +@format +@dircategory Software development +@direntry +* ga68: (ga68). A GCC-based compiler for Algol 68 +@end direntry +@end format + +@insertcopying +@end ifinfo + +@titlepage +@title The GNU Algol 68 Compiler +@versionsubtitle +@author Jose E. Marchesi + +@page +@vskip 0pt plus 1filll +@sp 1 +@insertcopying +@end titlepage +@summarycontents +@contents +@page + +@node Top +@top Introduction + +This manual describes how to use @command{ga68}, the GNU compiler for +Algol 68. This manual is specifically about how to invoke +@command{ga68}, as well as its features. For more information about +the Algol 68 language in general, the reader is referred to the +bibliography. + +Note that the particular way of representing Algol 68 code snippets in +this manual will depend on the media. If you are reading this manual +in a printed support or a PDF file rendered for publication then the +bold words in programs will be rendered in actual bold typography and +tags may have spaces within them. If you are reading this manual in a +terminal or other media not supporting rich typography the code +examples will follow the modern stropping regime with is the default +in ga68. + +Note also that we are making use of @dfn{pseudo-comments} in code +examples, as it is traditional in Algol 68 related documentation. +These appear surrounded by @code{@B{C}} marks and act as placeholders +of some Algol 68 code. For example, @code{@B{C} frob the input +variable @B{C}} is a pseudo-comment. + +@menu +* Invoking ga68:: How to run the compiler. +* Composing programs:: Packets, modules, holes, particular programs. +* Comments and pragmats:: Comments and pragmas. +* Hardware representation:: Representation of programs. +* Standard prelude:: Standard modes, operators, etc. +* Extended prelude:: GNU extensions to the standard prelude. +* POSIX prelude:: Simple I/O and system interaction facilities. +* Language extensions:: GNU extensions to the Algol 68 language. +* Copying:: The GNU General Public License. +* GNU Free Documentation License:: + How you can share and copy this manual. +* Option Index:: Index of command line options. +* General Index:: General index. +@end menu + +@node Invoking ga68 +@chapter Invoking ga68 + +@c man title ga68 A GCC-based compiler for Algol 68 + +@ignore +@c man begin SYNOPSIS ga68 +ga68 [@option{-c}|@option{-S}] [@option{-g}] [@option{-pg}] + [@option{-O}@var{level}] [@option{-W}@var{warn}@dots{}] + [@option{-I}@var{dir}@dots{}] [@option{-L}@var{dir}@dots{}] + [@option{-f}@var{option}@dots{}] [@option{-m}@var{machine-option}@dots{}] + [@option{-o} @var{outfile}] [@@@var{file}] @var{infile}@dots{} + +Only the most useful options are listed here; see below for the +remainder. +@c man end +@c man begin SEEALSO +gpl(7), gfdl(7), fsf-funding(7), gcc(1) +and the Info entries for @file{ga68} and @file{gcc}. +@c man end +@end ignore + +@c man begin DESCRIPTION ga68 + +The @command{ga68} command is the GNU compiler for the Algol 68 language and +supports many of the same options as @command{gcc}. @xref{Option Summary, , +Option Summary, gcc, Using the GNU Compiler Collection (GCC)}. +This manual only documents the options specific to @command{ga68}. + +@c man end + +@menu +* Dialect options:: Options controlling the accepted language. +* Directory options:: Options influencing where to find source files. +* Warnings options:: Options controlling warnings specific to ga68 +* Runtime options:: Options controlling runtime behavior +* Linking options:: Options influencing the linking step +* Developer options:: Options useful for developers of ga68 +@end menu + +@node Dialect options +@section Dialect options +@cindex options, dialect + +The following options control how the compiler handles certain dialect +variations of the language. + +@table @gcctabopt +@opindex std=@var{std} +@item -std=@var{std} +Specify the standard to which the program is expected to conform, +which may be one of @samp{algol68} or @samp{gnu68}. The default value +for @var{std} is @samp{gnu68}, which specifies a strict super language +of Algol 68 allowing GNU extensions. The @samp{algol68} value +specifies that the program strictly conform to the Revised Report. +@opindex fstropping=@var{stropping_regime} +@item -fstropping=@var{stropping_regime} +Specify the stropping regime to expect in the input programs. The +default value for @var{stropping_regime} is @samp{supper}, which +specifies the modern SUPPER stropping which is a GNU extension. The +@samp{upper} value specifies the classic UPPER stropping of Algol 68 +programs. @xref{Stropping regimes}. +@opindex fbrackets +@opindex fno-brackets +@item -fbrackets +This option controls whether @code{[ .. ]} and @code{@{ .. @}} are +considered equivalent to @code{( .. )}. This syntactic variation is +blessed by the Revised Report and is still strict Algol 68. + +This option is disabled by default. +@end table + +@node Directory options +@section Options for Directory Search +@cindex directory options +@cindex options, directory search +@cindex search path + +These options specify directories to search for files, libraries, and +other parts of the compiler: + +@table @gcctabopt + +@opindex I +@item -I@var{dir} +Add the directory @var{dir} to the list of directories to be searched +for files when processing the @ref{pragmat include}. Multiple +@option{-I} options can be used, and the directories specified are +scanned in left-to-right order, as with @command{gcc}. + +@end table + +@node Warnings options +@section Warnings options +@cindex options, warnings +@cindex options, errors +@cindex warnings, suppressing +@cindex messages, error +@cindex messages, warning +@cindex suppressing warnings + +Warnings are diagnostic messages that report constructions that +are not inherently erroneous but that are risky or suggest there +is likely to be a bug in the program. Unless @option{-Werror} is +specified, they do not prevent compilation of the program. + +@table @gcctabopt +@opindex Wvoiding +@opindex Wno-voiding +@item -Wvoiding +Warn on non-void units being voided due to a strong context. +@opindex Wscope +@opindex Wno-scope +@item -Wscope +Warn when a potential name scope violation is found. +@opindex Whidden-declarations +@opindex Wno-hidden-declarations +@item -Whidden-declarations +Warn when a declaration hides another declaration in a larger reach. +This includes operators that hide firmly related operators defined in +larger reach. +@opindex Wextensions +@opindex Wno-extensions +@item -Wextensions +Warn when a non-portable Algol 68 construct is used, like GNU +extensions to Algol 68. +@end table + +@node Runtime options +@section Runtime options +@cindex options, runtime + +These options affect the runtime behavior of programs compiled with +@command{ga68}. + +@table @gcctabopt +@opindex fassert +@opindex fno-assert +@item -fno-assert +Turn off code generation for @code{ASSERT} contracts. + +@opindex fcheck +@item -fcheck=@var{<keyword>} +Enable the generation of run-time checks; the argument shall be a +comma-delimited list of the following keywords. Prefixing a check +with @option{no-} disables it if it was activated by a previous +specification. + +@table @asis +@item @samp{all} +Enable all run-time test of @option{-fcheck}. + +@item @samp{none} +Disable all run-time test of @option{-fcheck}. + +@item @samp{nil} +Check for nil while dereferencing. + +@item @samp{bounds} +Enable generation of run-time checks when indexing and trimming +multiple values. +@end table +@end table + +@node Linking options +@section Linking options +@cindex options, linking +@cindex linking, static + +These options come into play when the compiler links object files into +an executable output file. They are meaningless if the compiler is +not doing a link step. + +@table @gcctabopt + +@opindex shared-libga68 +@item -shared-libga68 +On systems that provide @file{libga68} as a shared and a static +library, this option forces the use of the shared version. If no +shared version was built when the compiler was configured, this option +has no effect. + +@opindex static-libga68 +@item -static-libga68 +On systems that provide @file{libga68} as a shared and a static +library, this option forces the use of the static version. If no +static version was built when the compiler was configured, this option +has no effect. This is the default. +@end table + +@node Developer options +@section Developer options +@cindex developer options +@cindex debug dump options +@cindex dump options + +This section describes command-line options that are primarily of +interest to developers. + +@table @gcctabopt +@opindex fa68-dump-modes +@item -fa68-dump-modes +Output a list of all the modes parsed by the front-end. + +@opindex fa68-dump-ast +@item -fa68-dump-ast +Dump a textual representation of the parse tree. +@end table + +@node Composing programs +@chapter Composing programs +@cindex program +@cindex separated compilation + +This chapter documents how to compose full Algol 68 programs using the +modules and separated compilation support provided by this compiler. + +@menu +* Packets:: Compilation units. +* Modules:: Facilities for bottom-up programming. +* Holes:: Facilities for top-down programming. +* Particular programs:: The main program. +* The standard environment:: Environment conforming a full program. +@end menu + +@node Packets +@section Packets +@cindex packet +@cindex compilation unit + +Each Algol 68 source file contains a @dfn{packet}. Packets therefore +play the role of @dfn{compilation units}, and each packet can be +compiled separately to an object file. A set of compiled object files +can then be linked in the usual fashion into an executable, archive or +shared object by the system linker, without the need of any +language-specific link editor or build system. + +@noindent +This compiler supports three different kind of packets: + +@itemize @minus +@item +@dfn{Particular programs} constitute the entry point of a program. +They correspond to the @code{main} function of other languages like C. + +@xref{Particular programs}. + +@item +@dfn{Prelude packets} contain the definition of one or more modules, +which @dfn{publicize} definitions of modes, procedures, variables, +operators and even the publicized definitions of other modules. The +modules defined at the top-level of a prelude packet can be accessed +by other packets via an @code{@B{access}} construct. Prelude packets +are so-called because their contents get stuffed in the +@dfn{user-prelude} in the case of user-defined modules, or the +@dfn{library-prelude} in the case of module packets provided by the +compiler. They are usually used to compose libraries that can be used +in a bottom-up fashion. + +@xref{Modules}. + +@item +@dfn{Stuffing packets} contain the definition of an @dfn{actual hole}, +an @code{@B{egg}} construct, that can be stuffed in a matching +@dfn{formal hole} in another package via a @code{@B{nest}} construct. +Formal holes are used in order to achieve separated compilation in a +top-bottom fashion, and also to invoke procedures written in other +languages, such as C functions or Fortran subroutines. + +@xref{Holes}. +@end itemize + +A @dfn{collection of packets}, all of which must be compatible with +each other, constitutes either a @dfn{program} or a @dfn{library}. +Exactly one of the packets constituting a program shall be a +particular program. In libraries at least one packet must be a +prelude packet. + +@node Modules +@section Modules +@cindex module + +@dfn{Definition modules}, often referred as just @dfn{modules} in the +sequel, fulfill two different but related purposes. On one side, they +provide some degree of @dfn{protection} by preventing accessing +indicators defined within the module but not explicitly publicized. +On the other, they allow to define @dfn{interfaces}, allow separated +compilation based on these interfaces, and conform libraries. + +Modules are usually associated with bottom-up development strategies, +where several already written components are grouped and combined to +conform bigger components. + +@menu +* Writing modules:: Writing modules. +* Accessing modules:: Using the definitions of a module. +* Module activation:: How and when modules execute. +* Modules and libraries:: Using modules to conform libraries. +* Modules and protection:: When block structure is not enough. +@end menu + +@node Writing modules +@subsection Writing modules + +A @dfn{definition module} is a construct that provides access to a set +of publicized definitions. They can appear anywhere, but are +typically found in the outer reach and compiled separately, in which +case they conform a prelude packet (@pxref{Packets}). They are +composed of a prelude and a postlude. The publicized definitions +appear in the module's prelude. + +Consider for example the following definition module, which implements +a very simple logging facility: + +@example +@B{module} @B{Logger} = + @B{def} @B{int} fd = stderr; + @B{pub} @B{string} originator; + @B{pub} @B{proc} log = (@B{string} msg) @B{void}: + fputs (fd, (originator /= "" | ": ") + msg + "\n"); + + log ("beginning of log\n"); + @B{postlude} + log ("end of log\n"); + @B{fed} +@end example + +@noindent +The @dfn{module text} delimited by @code{@B{def}} and @code{@B{fed}} +gets ascribed to the module indicator @code{@B{Logger}}. Module +indicators are bold tags. Once defined, the module @code{@B{Logger}} +is accessible anywhere within its reach. + +The @dfn{prelude} of the module spans from @code{@B{def}} to either +@code{@B{postlude}}, or to @code{@B{fed}} in case of modules not +featuring a postlude. It consists on a restricted serial clause in a +void strong context, which can contain units and declarations, but no +labels or completers. The declarations in the prelude may be either +publicized or no publicized. As we shall see, publicized indicators +are accessible within the reach of the defining module publicizing +them. Publicized declarations are marked by preceding them with +@code{@B{pub}}. + +In our example the module prelude consists on three declarations and +one unit. The indicator @code{fd} is not publicized and is to be used +internally by the module. The indicators @code{originator} and +@code{log}, on the other hand, are publicized and conform the +interface of the module. Note how the range of the prelude also +covers the postlude: the @code{log} procedure is reachable there, as +it would be @code{fd} as well. + +The @dfn{postlude} of the module is optional and spans from +@code{@B{postlude}} to @code{@B{fed}}. It consists on a serial clause +in a @code{@B{void}} strong context, where definitions, labels and +module accesses are not allowed, just units. + +@node Accessing modules +@subsection Accessing modules + +Once a module is defined (@pxref{Writing modules}) it can be accessed, +provided it is within reach, using an @dfn{access clause}. The access +clause identifies the modules to access and then makes the publicized +definitions of these modules visible within a @dfn{control clause}. + +For example, this is how we could use the logger definition module +defined in a previous section to log the progress of some program that +reads an input file and writes some output file: + +@example +@B{access} @B{Logger} +@B{begin} # Identify ourselves with the program name # + originator := argv (1); + + # Read input file. # + @B{if} @B{NOT} parse_input (argv (2)) + @B{then} log ("error parsing input file"); stop @B{fi}; + + # Write output file. # + @B{if} @B{NOT} write_output (argv (3)) + @B{then} log ("error writing output file"); stop @B{fi}; + + log ("success") +@B{end} +@end example + +@noindent +In this case the controlled clause is the closed clause conforming the +particular program, and the definitions publicized by the logger +module, in this case @code{originator} and @code{log}, can be used +within it. + +@subsubsection Accessing several modules + +An access clause is not restricted to just provide access to a single +module: any number of module indicators can be specified in an access +clause. Suppose that our example processing program has to read and +write the data in JSON format, and that a suitable JSON library is +available in the form of a reachable module. We could then make both +logger and json modules accessible like this: + +@example +@B{access} @B{Logger}, @B{JSON} +@B{begin} # Identify ourselves with the program name # + originator := argv (1); + + @B{JSONVal} data; + + # Read input file. # + @B{if} data := json_from_file (argv (2)); + data = json no val + @B{then} log ("error parsing input file"); stop @B{fi}; + + # Write output file. # + @B{if} @B{not} json_to_file (argv (3), data) + @B{then} log ("error writing output file"); stop @B{fi}; + + log ("success") +@B{end} +@end example + +@noindent +In this version of the program the access clause includes the module +indicator @code{@B{json}}, and that makes the mode indicator +@code{@B{jsonval}} and the tags @code{@B{json no val}}, @code{json +from file} and @code{json to file} visible within the program's +closed clause. + +Note that the following two access clauses are not equivalent: + +@example +@B{access} @B{Logger}, @B{JSON} @B{C} ... @B{C}; +@B{access} @B{Logger} @B{access} @B{JSON} @B{C} ... @B{C}; +@end example + +@noindent +In the first case, a compilation time error is emitted if there is a +conflict among the publicized definitions of both modules; for +example, if both modules were to publicize a procedure called +@code{log}. In the second case, the declaration of @code{log} +publicized by @code{@B{Logger}} would hide the declaration of +@code{log} publicized by @code{@B{JSON}}. This also has implications +related to activation, that we will be discussing in a later section. + +@subsubsection The controlled clause + +The controlled clause in an access clause doesn't have to be a serial +clause, like in the examples above. It can be any enclosed clause, +like for example a loop clause: + +@example +@B{proc} frobnicate frobs = ([]@B{Frob} frobs) @B{void}: + @B{access} @B{Logger} @B{to} @B{UPB} frobs + @B{do} log ("frobnicating " + name @B{of} frob); + frobnicate (frob) + @B{od} +@end example + +@subsubsection The value yielded by an access clause + +The elaboration of an access clause yields a value, which is the value +yielded by the elaboration of the controlled clause. Since the later +is an enclosed clause, coercions get passed into them whenever +required, the usual fashion. + +We can see an example of this in the following procedure, whose body +is a controlled closed clause that yields a @code{@B{real}} value: + +@example +@B{proc} incr factor = (@B{ref}[]@B{real} factors, @B{int} idx) @B{real}: + @B{access} @B{logger} (log ("factor increased"); factors[idx] +:= 1.0) +@end example + +@noindent +Note how the access clause above is in a strong context requiring a +value of mode @code{@B{real}}. The value yielded by the access clause +is the value yielded by the controlled enclosed clause, which in this +case is a closed clause. The strong context and required mode gets +passed to the last unit of the closed clause (the assignation) which +in this case yields a value of mode @code{@B{ref} @B{real}}. The unit +is coerced to @code{@B{real}} by dereferencing, and the resulting +value becomes the value yielded by the access clause. + +@subsubsection Modules accessing other modules + +A definition module may itself access other modules. This is done by +placing the module text as a controlled clause of an access clause. +Suppose we rewrite our logger module so it uses JSON internally to log +JSON objects rather than raw strings. We could do it this way: + +@example +@B{module} @B{logger} = + @B{access} @B{json} + @B{def} @B{int} fd = stderr; + @B{pub} @B{string} originator; + @B{pub} @B{proc} log = (@B{string} msg) @B{void}: + fputs (fd, json array (json string (originator), + json string (msg))); + + log (json string ("beginning of log\n")); + @B{postlude} + log (json string ("end of log\n")); + @B{fed} +@end example + +@noindent +Note how this version of @code{@B{logger}} uses a few definitions +publicized by the @code{@B{json}} module. + +A program accessing @code{@B{logger}} will not see the definitions +publicized by the @code{@B{json}} module. If that is what we +intended, for example to allow the users of the logger to tweak their +own JSON, we would need to specify it this way: + +@example +@B{module} @B{logger} = + @B{access} @B{pub} @B{json} + @B{def} @B{c} ...as before... @B{c} @B{fed} +@end example + +@noindent +In this version the definitions publicized by @code{@B{json}} become +visible to programs accessing @code{@B{logger}}. + +@node Module activation +@subsection Module activation + +In all the examples seen so far the modules were accessed just once. +In these cases, accessing the module via an access-clause caused the +@dfn{activation} of the module. + +Activating a module involves elaborating all the declarations and +units that conform its prelude. Depending on the particular module +definition that gets activated, this may involve all sort of side +effects, such as allocating space for values and initializing them, +opening files, @i{etc}. Once the modules specified in the access +clause are successfully activated, the controlled clause gets +elaborated itself, within the reach of all the publicized definitions +by the activated modules as we saw in the last section. Finally, once +the controlled clause has been elaborated, the module gets +@dfn{revoked} by elaborating the serial clause in its postlude. + +However, nothing prevents some given definition module to be accessed +more than once in the same program. The following program, that makes +use of the @code{@B{logger}} module, exemplifies this: + +@example +@B{access} @B{logger} +@B{begin} originator := argv (1); + log ("executing program"); + @B{c} ... @B{c} + @B{access} @B{logger} (originator := argv (1) + ":subtask"; + log ("doing subtask") + @B{c} ... @B{c}) +@B{end} +@end example + +@noindent +In this program the module @code{@B{logger}} is accessed twice. The +code is obviously written assuming that the inner access clause +triggers a new activation of the @code{@B{logger}} module, allocating +new storage and executing its prelude. This would result in the +following log contents: + +@example +a.out: beginning of log +a.out: executing program +a.out:subtask: beginning of log +a.out:subtask: doing subtask +a.out:subtask: end of log +a.out: end of log +@end example + +@noindent +However, this is not what happens. The module gets only activated +once, as the result of the outer access clause. The inner access +clause just makes the publicized indicators visible in its controlled +clause. The actual resulting log output is: + +@example +a.out: beginning of log +a.out: executing program +a.out:subtask: doing subtask +a.out:subtask: end of log +@end example + +@noindent +Which is not what we intended. Modules are not classes. If we wanted +the logger to support several originators that can be nested, we would +need to add support for it in the definition module. Something like: + +@example +@B{module} @B{logger} = + @B{def} @B{int} fd = stderr, max originators = 10; + @B{int} orig := 0; + [max originators]@B{string} originators; + + @B{pub} @B{proc} push originator = (@B{string} str) @B{void}: + (@B{assert} (orig < max originators); + orig +:= 1; + originators[orig] := str); + @B{pub} @B{proc} pop originator = @B{void}: + (@B{assert} (max originators > 0); + orig -:= 1); + @B{pub} @B{proc} log = (@B{string} msg) @B{void}: + fputs (fd, (originator[orig] /= "" | ": ") + msg + "\n"); + + log ("beginning of log\n"); + @B{postlude} + log ("end of log\n"); + @B{fed} +@end example + +@noindent +Note how in this version of @code{@B{logger}} @code{originators} acts +as a stack of originator strings, and it is not publicized. The +management of the stack is done via a pair of publicized procedures +@code{push originator} and @code{pop originator}. Our program will +now look like: + +@example +@B{access} @B{logger} +@B{begin} push originator (argv (1)); + log ("executing program"); + @B{c} ... @B{c} + @B{access} @B{logger} (push originator ("subtask"); + log ("doing subtask") + @B{c} ... @B{c}; + pop originator) +@B{end} +@end example + +@noindent +And the log output is: + +@example +a.out: beginning of log +a.out: executing program +a.out:subtask: doing subtask +a.out: end of log +@end example + + +-------------------------------------------------------------- + +module-indications are used to find interface-definitions of modules: + + ACCESS FOO SKIP + +Looks for (in order): + + foo.m68 + foo.o + libfoo.so + +Should we use instead: + + ACCESS "foo" SKIP + +That would use for module indicators the same syntax than hole +indicators. + +Modules get accessed, invoked and revoked. + +Access clauses: + +: ACCESS A, B <enclosed clause> + +Where A and B are ``revelations''. + +In + +: MODULE A = ACCESS B DEF ... FED + +Doesn't reveals any contents of B. Whereas in: + +: MODULE A = ACCESS PUB B DEF .. FED + +The module A is also revealing B's public declarations. So accessing +A provides access to B. + +User-defined preludes go to the user-prelude. + +Invocation and revocation:: How modules are executed. + +It is possible for a definition module to not publicize any +definition. Such modules would be used only for the side effects +produced from executing the prelude and postlude when the module gets +invoked and revoked. XXX: provide an example? + +XXX + +@node Modules and libraries +@subsection Modules and libraries +@cindex library +@cindex prelude packet + +XXX + +@node Modules and protection +@subsection Modules and protection +@cindex protection +@cindex publicized definition + +XXX + +@node Holes +@section Holes +@cindex hole + +XXX + +@node Particular programs +@section Particular programs +@cindex particular program + +An Algol 68 @dfn{particular program} consists on an enclosed clause in +a strong context with target mode @code{@B{void}}, possibly preceded +by a set of zero or more labels. For example: + +@example +hello: +@B{begin} puts ("Hello, world!\n") +@B{end} +@end example + +@noindent +Note that the enclosed clause conforming the particular program +doesn't have to be a closed clause. Consider for example the +following program, that prints out its command line arguments: + +@example +@B{for} i @B{to} argc +@B{do} puts (argv (i) + "\n") @B{od} +@end example + +@menu +* Exit status:: How do programs communicate success or failure. +* The @code{stop} label:: How to terminate a program at any time. +@end menu + +@node Exit status +@subsection Exit status +@cindex exit status + +Some operating systems have the notion of @dfn{exit status} of a +process. In such systems, by default the execution of the particular +program results in an exit status of success. It is possible for the +program to specify an explicit exit status by using the standard +procedure @code{set exit status}, like: + +@example +@b{begin} # ... program code ... # + @B{if} error found; + @B{then} set exit status (1) @B{fi} +@b{end} +@end example + +In POSIX systems the status is an integer, and the system interprets a +value other than zero as a run-time error. In other systems the +status may be of some other type. To support this, the @code{set +error status} procedure accepts as an argument an united value that +accommodates all the supported systems. + +The following example shows a very simple program that prints ``Hello +world'' on the standard output and then returns to the operating +system with a success status: + +@example +@B{begin} puts ("Hello world\n") +@B{end} +@end example + +@node The @code{stop} label +@subsection The @code{stop} label +@cindex @code{stop} + +A predefined label named @code{stop} is defined in the standard +postlude. This label can be jumped to at any time by a program and it +will cause it to terminate and exit. For example: + +@example +@B{begin} @B{if} argc /= 2 + @B{then} puts ("Program requires exactly two arguments."); + goto stop + @B{fi} + @B{C} ... @B{C} +@B{end} +@end example + +@node The standard environment +@section The standard environment +@cindex standard environment + +The environment in which particular programs run is expressed here in +the form of pseudo code: + +@example +(@B{c} standard-prelude @B{c}; + @B{c} library-prelude @B{c}; + @B{c} system-prelude @B{c}; + @B{par} @B{begin} @B{c} system-task-1 @B{c}, + @B{c} system-task-2 @B{c}, + @B{c} system-task-n @B{c}, + @B{c} user-task-1 @B{c}, + @B{c} user-task-2 @B{c}, + @B{c} user-task-m @B{c} + @B{end}) +@end example + +@noindent +Where each user task consists on: + +@example +(@B{c} particular-prelude @B{c}; + @B{c} user-prelude @B{c}; + @B{c} particular-program @B{c}; + @B{c} particular-postlude @B{c}) +@end example + +The only standard system task described in the report is expressed in +pseudo-code as: + +@example +@B{do} @B{down} gremlins; undefined; @B{up} bfileprotect @B{od} +@end example + +@noindent +Which denotes that, once a book (file) is closed, anything may happen. +Other system tasks may exist, depending on the operating system. In +general these tasks in the parallel clause denote the fact that the +operating system is running in parallel (intercalated) with the user's +particular programs. + +@itemize @bullet +@item +The library-prelude contains, among other things, the prelude parts of +the defining modules provided by library. + +@item +The particular-prelude and particular-postlude are common to all the +particular programs. + +@item +The user-prelude is where the prelude parts of the defining modules +involved in the compilation get stuffed. If no defining module is +involved then the user-prelude is empty. +@end itemize + +Subsequent sections in this manual include a detailed description of +the contents of these preludes. + +@node Comments and pragmats +@chapter Comments and pragmats + +Comments and pragmats, also known collectively as @dfn{pragments}, can +appear almost anywhere in an Algol 68 program. Comments are usually +used for documentation purposes, and pragmats contain annotations for +the compiler. Both are handled at the lexical level. + +@menu +* Comments:: Your typical friendly comments. +* Pragmats:: In-source directives for the compiler. +@end menu + +@node Comments +@section Comments + +In the default modern stropping regime supported by GCC comments are +written between @code{@{} and @code{@}} delimiters, and can be nested +to arbitrary depth. For example: + +@example +foo +:= 1; @{ Increment foo. @} +@end example + +If UPPER stropping is selected, this compiler additionally supports +three classical Algol 68 comment styles, in which the symbols marking +the beginning of comments are the same than the symbols marking the +end of comments and therefore can't be nested: @code{@B{comment} +... @B{comment}}, @code{@B{co} ... @B{co}} and @code{# .. #}. For +example: + +@example +@B{comment} + This is a comment. +@B{comment} + +foo := 10; @B{co} this is also a comment @B{co} +foo +:= 1; # and so is this. # +@end example + +Unless @option{-std=algol68} is specified in the command line, two +styles of nestable comments can be also used with UPPER stropping: the +already explained @code{@{ ... @}} and a ``bold'' style that uses +@code{@B{code} ... @B{edoc}}. For example: + +@example +foo := 10; @{ this is a nestable comment in brief style. @} +foo +:= 1; @B{note} this is a nestable comment in bold style. @B{eton}. +@end example + +@example +@B{note} + "Bold" nestable comments. +@B{eton} + +@{ "Brief" nestable comments. @} +@end example + +In UPPER stropping all comment styles are available, both classic and +nestable. In modern SUPPER stropping, which is based on reserved +words, only @code{@{ ... @}} is available. + +@node Pragmats +@section Pragmats + +@cindex pragmat +@dfn{Pragmats} (also known as @dfn{pragmas} in other programming +languages) are directives and annotations for the compiler, and their +usage impacts the compilation process in several ways. A pragmat +starts with either @code{@B{pragmat}} or @code{@B{pr}} and finished +with either @code{@B{pragmat}} or @code{@B{pr}} respectively. +Pragmats cannot be nested. For example: + +@example +@B{pr} include "foo.a68" @B{pr} +@end example + +The interpretation of pragmats is compiler-specific. This chapter +documents the pragmats supported by GCC. + +@menu +* pragmat include:: Include another source file. +@end menu + +@node pragmat include +@subsection pragmat include +@cindex include + +An @dfn{include pragmat} has the form: + +@example +@B{pr} include "PATH" @B{pr} +@end example + +@noindent +Where @code{PATH} is the path of the file whose contents are to be +included at the location of the pragmat. If the provided path is +relative then it is interpreted as relative to the directory +containing the source file that contains the pragmat. + +The @option{-I} command line option can be used in order to add +additional search paths for @code{include}. + +@node Hardware representation +@chapter Hardware representation + +The @dfn{reference language} specified by the Revised Report describes +Algol 68 particular programs as composed by @dfn{symbols}. However, +the Report leaves the matter of the concrete representation of these +symbols, the @dfn{representation language}, open to the several +implementations. This was motivated by the very heterogeneous +computer systems in existence at the time the Report was written, +which made flexibility in terms of representation a crucial matter. + +This flexibility was indeed exploited by the early implementations, +and there was a price to pay for it. A few years after the +publication of the Revised Report the different implementations had +already given rise to a plethora of many related languages that, +albeit being strict Algol 68, differed considerably in appearance. +This, and the fact that people were already engrossed in writing +programs other than compilers that needed to process Algol 68 +programs, such as code formatters and macro processors, prompted the +WG 2.1 to develop and publish a @dfn{Report on the Standard Hardware +Representation for ALGOL 68}, which came out in 1975. + +This compiler generally follows the Standard Hardware Representation, +but deviates from it in a few aspects. This chapter provides an +overview of the hardware representation and documents any deviation. + +@menu +* Representation languages:: From symbols to syntactic marks. +* Worthy characters:: Marks that can appear in a program. +* Base characters:: Mapping of worthy characters to code points. +* Stropping regimes:: Representation of bold words. +* Monads and Nomads:: Characters that can appear in operator names. +* String breaks:: String literals and escape sequences. +@end menu + +@node Representation languages +@section Representation languages + +A program in the strict Algol 68 language is composed by a series of +symbols. These symbols have names such as @code{letter-a-symbol} and +@code{assigns-to-symbol} which are, well, purely symbolic. In fact, +these are notions in the two-level grammar that defines the strict +language. + +A @dfn{representation language} provides a mapping between symbols in +the strict language and the representation of these symbols. Each +representation is a sequence of syntactic marks. For example, the +@code{completion symbol} may be represented by @strong{exit}, where +the marks are the bold letters. The @code{tilde symbol} may be +represented by @code{~}, which is a single mark. The representation of +@code{assigns to symbol} is @code{:=}, which is composed by the two +marks @code{:} and @code{=}. The representation of @code{letter-a} +is, not surprising, the single mark @code{a}. + +The section 9.4 of the Report describes the recommended representation +for all the symbols of the language. The set of all recommendations +constitutes the so-called @dfn{reference language}. Algol 68 +implementations are strongly encouraged to use representation +languages which are similar enough to the reference language, +recognizable ``without further elucidation'', but this is not +strictly required. + +A representation language may specify more than one representation for +a given symbol. For example, in the reference language the @code{is +not symbol} is represented by @strong{isnt}, @code{:/=:} and a variant +of the later where the slash sign is superimposed on the equal sign. +In this case, an implementation can choose to implement any number of +the representations. + +Spaces, tabs and newlines are @dfn{typographical display features} +that, when they appear between symbols, are of no significance and do +not alter the meaning of the program. However, when a space or a tab +appear in string or character denotations, they represent the +@code{space symbol} and the @code{tab symbol} +respectively@footnote{The @code{tab symbol} is a GNU extension}. + +@node Worthy characters +@section Worthy characters +@cindex worthy characters + +The syntactic marks of a representation language, both symbols and +typographical display features, are realized as a set of @dfn{worthy +characters} and the newline. Effectively, an Algol 68 program is a +sequence of @dfn{worthy characters} and newlines. The worthy +characters are: + +@example +a b c d e f g h i j k l m n o p q r s t u v w x y z +A B C D E F G H I J K L M N O P Q R S T U V W X Y Z +0 1 2 3 4 5 6 7 8 9 +space tab " # $ % & ' ( ) * + , - . / : ; < = > @ [ \ ] +^ _ | @ ! ? ~ @{ @} +@end example + +Some of the characters above were considered unworthy by the original +Standard Hardware Representation: + +@table @code +@item ! +It was considered unworthy because many installations didn't have a +vertical bar base character, and @code{!} was used as a base character +for @code{|}. Today every computer system features a vertical bar +character, so @code{!} can qualify as a worthy character. +@item & +The Revised Report specifies that @code{&} is a monad, used as a +symbol for the dyadic @code{@B{and}} operator. The Standard Hardware +representation decided to turn it into an unworthy character, +motivated by the fact that no nomads existed for the other logical +operators @code{@B{not}} and @code{@B{or}}, and also with the goal of +maintaining the set of worthy characters as small as possible to +improve portability. Recognizing that the first motivation still +holds, but not the second, this compiler re-instates @code{&} as a +monad but doesn't use it as an alternative representation of the +@code{@B{and}} operator. +@item ~ +The Standard Hardware Representation vaguely cites some ``severe +difficulties'' with the hardware representation of the tilde +character. Whatever these difficulties were at the time, they surely +don't exist anymore. This compiler therefore recognizes @code{~} as a +worthy character, and is used as a monad. +@item ? +The question mark character was omitted as a worthy character to limit +the size of the worthy set. This compiler recognizes @code{?} as a +worthy character, and is used as a monad. +@item \ +Back-slash wasn't included as a worthy character because back in 1975 +it wasn't supported in EBCDIC (it is now). This compiler recognizes +@code{\} as a worthy character. +@item tab +This compiler recognizes the tabulator character as a worthy +character, and it is used as a typographical display feature. +@end table + +@node Base characters +@section Base characters +@cindex base characters + +The worthy characters described in the previous section are to be +interpreted symbolically rather than visually. The worthy character +@code{|}, for example, is the vertical line character and generally +looks the same in every system. The worthy character @code{space} is +obviously referred by a symbolic name. + +The actual visually distinguishable characters available in an +installation are known as @dfn{base characters}. The Standard +Hardware Representation allows implementations the possibility of +using two or more base characters to represent a single worthy +character. This was the case of the @code{|} character, which was +represented in many implementations by either @code{|} or @code{!}. + +This compiler uses the set of base characters corresponding to the +subset of the Unicode character set that maps one to one to the set of +worthy characters described in the previous section: + +@example +A-Z 65-90 +a-z 97-122 +space 32 +tab 9 +! 33 +" 34 +# 35 +$ 36 +% 37 +& 38 +' 39 +( 40 +) 41 +* 42 ++ 43 +, 44 +- 45 +. 46 +/ 47 +: 58 +; 59 +< 60 += 61 +> 62 +? 63 +@@ 64 +[ 91 +\ 92 +] 93 +^ 94 +_ 95 +| 124 +~ 126 +@end example + +@node Stropping regimes +@section Stropping regimes + +The Algol 68 reference language establishes that certain source +constructs, namely mode indications and operator indications, consist +in a sequence of @dfn{bold letters} and @dfn{bold digits}, known as a +@dfn{bold word}. In contrast, other constructs like identifiers, +field selectors and labels, collectively known as @dfn{tags}, are +composed of regular, non-bold letters and digits. + +What is precisely a bold letter or digit, and how they differ from +non-bold letters and digits, is not specified by the Report. This is +no negligence, but a conscious effort at abstracting the definition of +the so-called @dfn{strict language} from its representation. This +allows different representations of the same language. + +Some representations of Algol 68 are intended to be published in +books, be it paper or electronic devices, and be consumed by persons. +These are called @dfn{publication languages}. In publication +languages bold letters and digits are typically represented by actual +bold alphanumeric typographic marks. An Algol 68 program hand written +on a napkin or a sheet of paper would typically represent bold letters +and digits underlined, or stroked using a different color ink. + +Other representations of Algol 68 are intended to be automatically +processed by a computer. These representations are called +@dfn{hardware languages}. Sometimes the hardware languages are also +intended to be written and read by programmers; these are called +@dfn{programming languages}. + +Unfortunately, computer systems today usually do not yet provide +readily usable and ergonomic bold or underline alphanumeric marks, +despite the existence of Unicode and modern and sophisticated editing +environments. The lack of appropriate input methods surely plays a +role to explain this. Thus, the programming representation languages +of Algol 68 should resort to a technique known as @dfn{stropping} in +order to differentiate bold letters and digits from non-bold letters +and digits. The set of rules specifying the representation of these +characters is called a @dfn{stropping regime}. + +There are three classical stropping regimes for Algol 68, which are +standardized and specified in the Standard Hardware Representation +normative document. These are @dfn{POINT stropping}, @dfn{RES +stropping} and @dfn{UPPER stropping}. The following sections do a +cursory tour over them; for more details the reader is referred to the +Standard Hardware Representation. + +This compiler implements UPPER stropping and SUPPER stropping. + +@menu +* POINT stropping:: +* RES stropping:: +* UPPER stropping:: +* SUPPER stropping:: +@end menu + +@node POINT stropping +@subsection POINT stropping + +POINT stropping is in a way the most fundamental of the three standard +regimes. It was designed to work in installations with limited +character sets that provide only one alphabet, one set of digits, and +a very restricted set of other symbols. + +In POINT stropping a bold word is represented by its constituent +letters and digits preceded by a point character. For example, the +symbol @code{bold begin symbol} in the strict language, which is +represented as @strong{begin} in bold face in the reference language, +would be represented as @code{.BEGIN} in POINT stropping. + +More examples are summarized in the following table. + +@multitable @columnfractions .33 .33 .33 +@headitem Strict language @tab Reference language @tab POINT stropping +@item @code{true symbol} @tab @strong{true} @tab @code{.TRUE} +@item @code{false symbol} @tab @strong{false} @tab @code{.FALSE} +@item @code{integral symbol} @tab @strong{int} @tab @code{.INT} +@item @code{completion symbol} @tab @strong{exit} @tab @code{.EXIT} +@item @code{bold-letter-c-...} @tab @strong{crc32} @tab @code{.CRC32} +@end multitable + +In POINT stropping a tag is represented by writing its constituent +non-bold letters and digits in order. But they are organized in +several @dfn{taggles}. + +Each taggle is a sequence of one or more letters and digits, +optionally followed by an underscore character. For example, the tag +@code{PRINT} is composed of a single taggle, but the tag +@code{PRINT_TABLE} is composed of a first taggle @code{PRINT_} +followed by a second taggle @code{TABLE}. + +To improve readability it is possible to insert zero or more white +space characters between the taggles in a tag. Therefore, the tag +@code{PRINT_TABLE} could have been written @code{PRINT TABLE}, or even +@code{PRINT_ TABLE}. This is the reason why Algol 68 identifiers, +labels and field selectors can and do usually feature white spaces in +them. + +It is important to note that both the trailing underscore characters +in taggles and the white spaces in a tag do not contribute anything to +the denoted tag: these are just stropping artifacts aimed to improve +readability. Therefore @code{FOOBAR} @code{FOO BAR}, @code{FOO_BAR} +and @code{FOO_BAR_} are all representations of the same tag, that +represents the +@code{letter-f-letter-o-letter-o-letter-b-letter-a-letter-r} language +construct. + +Below is the text of an example Algol 68 procedure encoded in POINT +stropping. + +@example +.PROC RECSEL OUTPUT RECORDS = .VOID: +.BEGIN .BITS FLAGS + := (INCLUDE DESCRIPTORS | REC F DESCRIPTOR | REC F NONE); + .RECRSET RES = REC DB QUERY (DB, RECUTL TYPE, + RECUTL QUICK, FLAGS); + .RECWRITER WRITER := REC WRITER FILE NEW (STDOUT); + + SKIP COMMENTS .OF WRITER := .TRUE; + .IF RECUTL PRINT SEXPS + .THEN MODE .OF WRITER := REC WRITER SEXP .FI; + REC WRITE (WRITER, RES) +.END +@end example + +@node RES stropping +@subsection RES stropping + +The early installations where Algol 68 ran not only featured a very +restricted character set, but also suffered from limited storage and +complex to use and time consuming input methods such as card punchers +and readers. It was important for the representation of programs to +be as compact as possible. + +It is likely that is what motivated the introduction of the RES +stropping regime. As its name implies, it removes the need of +stropping many bold words by introducing @dfn{reserved words}. + +A @dfn{reserved word} is one of the bold words specified in the +section 9.4.1 of the Report as a representation of some symbol. +Examples are @strong{at}, @strong{begin}, @strong{if}, @strong{int} +and @strong{real}. + +RES stropping encodes bold words and tags like POINT stropping, but if +a bold word is a reserved word then it can then be written without a +preceding point, achieving this way a more compact, and easier to +read, representation for programs. + +Introducing reserved words has the obvious disadvantage that some tags +cannot be written the obvious way due to the possibility of conflicts. +For example, to represent a tag @code{if} it is not possible to just +write @code{IF}, because it conflicts with a reserved word, but this +can be overcome easily (if not elegantly) by writing @code{IF_} +instead. + +Below is the @code{recsel output records} procedure again, this time +encoded in RES stropping. + +@example +PROC RECSEL OUTPUT RECORDS = VOID: +BEGIN BITS FLAGS + := (INCLUDE DESCRIPTORS | REC F DESCRIPTOR | REC F NONE); + .RECRSET RES = REC DB QUERY (DB, RECUTL TYPE, + RECUTL QUICK, FLAGS); + .RECWRITER WRITER := REC WRITER FILE NEW (STDOUT); + + SKIP COMMENTS OF WRITER := TRUE; + IF RECUTL PRINT SEXPS + THEN MODE .OF WRITER := REC WRITER SEXP FI; + REC WRITE (WRITER, RES) +END +@end example + +Note how user-defined mode an operator indications still require +explicit stropping. + +@node UPPER stropping +@subsection UPPER stropping + +In time computers added support for more than one alphabet by +introducing character sets with both upper and lower case letters, +along with convenient ways to both input and display these. + +In UPPER stropping the bold letters in bold word are represented by +upper-case letters, whereas the letters in tags are represented by +lower-case letters. + +The notions of upper- and lower-case are not applicable to digits, but +since the language syntax assures that it is not possible to have a +bold word that starts with a digit, digits are considered to be bold +if they follow a bold letter or another bold digit. + +Below is the @code{recsel output records} procedure again, this time +encoded in UPPER stropping. + +@example +PROC recsel output records = VOID: +BEGIN BITS flags + := (include descriptors | rec f descriptor | rec f none); + RECRSET res = rec db query (db, recutl type, + recutl quick, flags); + RECWRITER writer := rec writer file new (stdout); + + skip comments of writer := TRUE; + IF recutl print sexps + THEN mode OF writer := rec writer sexp FI; + rec write (writer, res) +END +@end example + +Note how in this regime it is almost never necessary to introduce bold +tags with points. All in all, it looks much more natural to +contemporary readers. UPPER stropping is in fact the stropping regime +of choice today. It is difficult to think of any reason why anyone +would resort to use POINT or RES stropping. + +@node SUPPER stropping +@subsection SUPPER stropping + +In the SUPPER stropping regime bold words are written by writing a +sequence of one or more @dfn{taggles}. Each taggle is written by +writing a letter followed by zero or more other letters and digits and +is optionally followed by a trailing underscore character. The first +letter in a bold word shall be an upper-case letter. The rest of the +letters in the bold word may be either upper- or lower-case. + +For example, @code{RecRset}, @code{Rec_Rset} and @code{RECRset} are +all different ways to represent the same mode indication. This allows +to recreate popular naming conventions such as @code{CamelCase}. + +As in the other stropping regimes, the casing of the letters and the +underscore characters are not really part of the mode or operator +indication. + +Operator indications are also bold words and are written in exactly +the same way than mode indications, but it is usually better to always +use upper-case letters in operator indications. On one side, it looks +better, especially in the case of dyadic operators where the asymmetry +of, for example @code{Equal} would look odd, consider @code{m1 Equal +m2} as opposed to @code{m1 EQUAL m2}. On the other side, tools like +editors can make use of this convention in order to highlight operator +indications differently than mode indications. + +In the SUPPER stropping regime tags are written by writing a sequence +of one or more @dfn{taggles}. Each taggle is written by writing a +letter followed by zero or more other letters and digits and is +optionally followed by a trailing underscore character. All letters +in a tag shall be lower-case letters. + +For example, the identifier @code{list} is represented by a single +taggle, and it is composed by the letters @code{l}, @code{i}, @code{s} +and @code{t}, in order. In the jargon of the strict language we would +spell the tag as @code{letter-l-letter-i-letter-s-letter-t}. + +The label @code{found_zero} is represented by two taggles, +@code{found_} and @code{zero}, and it is composed by the letters +@code{f}, @code{o}, @code{u}, @code{n}, @code{d}, @code{z}, @code{e}, +@code{r} and @code{o}, in order. In the jargon of the strict language +we would spell the tag as @code{letter-f-letter-o-letter-u-letter-n +-letter-d-letter-z-letter-e-letter-r-letter-o}. + +The identifier @code{crc_32} is likewise represented by two taggles, +@code{crc_} and @code{32}. Note how the second taggle contains only +digits. In the jargon of the strict language we would spell the tag +as @code{letter-c-letter-r-letter-c-digit-three-digit-two}. + +The underscore characters are not really part of the tag, but part of +the stropping. For example, both @code{goto found_zero} and +@code{goto foundzero} jump to the same label. + +The @code{recsel output records} procedure, encoded in SUPPER +stropping, looks like below. + +@example +proc recsel_output_records = void: +begin bits flags + := (include_descriptors | rec_f_descriptor | rec_f_none); + RecRset res = rec_db_query (db, recutl_type, + recutl_uick, flags); + RecWriter writer := rec_writer_file_new (stdout); + + skip_comments of writer := true; + if recutl_print_sexps + then mode_ of writer := rec_writer_sexp fi; + rec_write (writer, res) +end +@end example + +@node Monads and Nomads +@section Monads and Nomads +@cindex monads +@cindex nomads + +Algol68 operators, be them predefined or defined by the programmer, +can be referred via either bold tags or sequences of certain +non-alphabetic symbols. For example, the dyadic operator @code{+} is +defined for many modes to perform addition, the monadic operator +@code{@B{entier}} gets a real value and rounds it to an integral +value, and the operator @code{:=:} is the identity relation. Many +operators provide both bold tag names and symbols names, like in the +case of @code{:/=:} that can also be written as @code{@B{isnt}}. + +Bold tags are lexically well delimited, and if the same tag is used to +refer to a monadic operator and to a dyadic operator, no ambiguity can +arise. For example, in the following program it is clear that the +second instance of @code{@B{plus}} refers to the monadic operator, and +the first instance refers to the dyadic operator@footnote{If one would +write @code{@B{plusplus}}, it would be a third different bold tag.}. + +@example +@B{op} @B{PLUS} = (@B{int} a, b) @B{int}: a + b, + @B{PLUS} = (@B{int} a): a; +@B{int} val = 2 @B{PLUS} @B{PLUS} 3; +@end example + +On the other hand, symbols are not lexically delimited as words, and +one symbol can appear immediately following another symbol. This can +lead to ambiguities. For example, if we were to define a C-like +monadic operator @code{++} like: + +@example +@B{op} ++ = (@B{ref} @B{int} a) @B{int}: (@B{int} t = a; a +:=1; t); +@end example + +@noindent +Then the expression @code{++a} would be ambiguous: is it @code{++a} or +@code{+(+a)}?. In a similar way, if we would use @code{++} as the +name of a dyadic operator, an expression like @code{a++b} could be +also interpreted as both @code{a++b} and @code{a+(+b)}. + +To avoid these problems Algol 68 divides the symbols which are +suitable to appear in the name of an operator into two classes: monads +and nomads. @dfn{Monads} are symbols that can be used as monadic +operators. @dfn{Nomads} are symbols which can be used as both monadic +or dyadic operators. Given these two sets, the rules to conform a +valid operator are: + +@itemize @minus +@item A bold tag. +@item Any monad. +@item A monad followed by a nomad. +@item A monad optionally followed by a nomad followed by either @code{:=} or @code{=:}, but not by both. +@end itemize + +@noindent +In the GNU Algol 68 compiler: + +@itemize @minus +@item The set of monads is @code{%^&+-~!?}. +@item The set of nomads is @code{></=*}. +@end itemize + +@node String breaks +@section String breaks + +The intrinsic value of each worthy character that appears inside a +string denotation is itself. The string @code{"/abc"}, therefore, +contains a slash character followed by the three letters @code{a}, +@code{b} and @code{c}. + +Sometimes, however, it becomes necessary to represent some non-worthy +character in a string denotation. In these cases, an escape +convention has to be used to represent these extra string-items. It +is up to the implementation to decide this convention, and the only +requirement imposed by the Standard Hardware Representation on this +regard is that the character used to introduce escapes, the +@dfn{escape character}, shall be the apostrophe. This section +documents the escape conventions implemented by the GNU compiler. + +Two characters have special meaning inside string denotations: double +quote (@code{"}) and apostrophe (@code{'}). The first finishes the +string denotation, and the second starts a @dfn{string break}, which +is the Algol 68 term for what is known as an ``escape sequence'' in +other programming languages. Two consecutive double-quote characters +specify a single double-quote character. + +The following string breaks are recognized by this compiler: + +@table @code +@item '' +Apostrophe character @code{'}. +@item 'n +Newline character. +@item 'f +Form feed character. +@item 'r +Carriage return (no line feed). +@item 't +Tab. +@item '(list of character codes separated by commas) +The indicated characters, where each code has the form @code{uhhhh} or +@code{Uhhhhhhhh}, where @code{hhhh} and @code{hhhhhhhh} are integers +expressing the character code in hexadecimal. The list must contain +at least one entry. +@end table + +A string break can appear as the single string-item in a character +denotation, subject to the following restrictions: + +@itemize @bullet +@item +List of characters string breaks @code{'(...)} that contain more than +one character code are not allowed in character denotations. If the +specified code point is not a valid Unicode character then the value +of the denotation is @code{invalid char}. +@end itemize + +@node Standard prelude +@chapter Standard prelude +@cindex prelude, standard + +The Algol 68 Revised Report defines an extensive set of standard +modes, operators, procedures and values, collectively known as the +@dfn{standard prelude}. + +The standard prelude is available to Algol 68 programs without needing +to import any module. + +For brevity, in this section the pseudo-mode @code{@B{L}} represents a +@dfn{shortsety}, i.e. a sequence of either zero or more +@code{@B{LONG}} or zero or more @code{@B{SHORT}}. + +@menu +* Environment enquiries:: Information about the implementation. +* Standard modes:: Modes defined by the standard prelude. +* Standard priorities:: Priorities of all standard operators. +* Rows operators:: Rows and associated operations. +* Boolean operators:: Operations on boolean operands. +* Integral operators:: Operations on integral operands. +* Real operators:: Operations on real operands. +* Character operators:: Operations on character operands. +* String operators:: Strings and associated operations. +* Complex operators:: Operations on complex operands. +* Bits operators:: Bits and associated operations. +* Bytes operators:: Bytes and associated operations. +* Semaphore operators:: Synchronization operations. +* Math procedures:: Standard mathematical constants and functions. +@end menu + +@node Environment enquiries +@section Environment enquiries + +An @dfn{environment enquiry} is a constant or a procedure, whose +elaboration yields a value that may be useful to the programmer, that +reflects some characteristic of the particular implementation. The +values of these enquiries are also determined by the architecture and +operating system targeted by the compiler. + +@deftypevr Constant @B{int} {int lengths} +1 plus the number of extra lenghts of integers which are meaningful. +@end deftypevr + +@deftypevr Constant @B{int} {int shorths} +1 plus the number of extra shorths of integers which are meaningful. +@end deftypevr + +@deftypevr Constant {@B{l} @B{int}} {L max int} +The largest integral value. +@end deftypevr + +@deftypevr Constant @B{int} {real lengths} +1 plus the number of extra lenghts of real numbers which are +meaningful. +@end deftypevr + +@deftypevr Constant @B{int} {real shorths} +1 plus the number of extra shorths of real numbers which are +meaningful. +@end deftypevr + +@deftypevr Constant {@B{l} @B{real}} {L max real} +The largest real value. +@end deftypevr + +@deftypevr Constant {@B{l} @B{real}} {L small real} +The smallest real value such that both @code{1 + small real > 1} and +@code{1 - small real < 1}. +@end deftypevr + +@deftypevr Constant @B{int} {bits lengths} +1 plus the number of extra widths of bits which are meaningful. +@end deftypevr + +@deftypevr Constant @B{int} {bits shorths} +1 plus the number of extra shorths of bits which are meaningful. +@end deftypevr + +@deftypevr Constant @B{int} {bits width} +@deftypevrx Constant @B{int} {long bits width} +@deftypevrx Constant @B{int} {long long bits width} +The number of bits in a @code{@B{bits}} value. +@end deftypevr + +@deftypevr Constant @B{int} {bytes lengths} +1 plus the number of extra widths of bytes which are meaningful. +@end deftypevr + +@deftypevr Constant @B{int} {bytes shorths} +1 plus the number of extra shorths of bytes which are meaningful. +@end deftypevr + +@deftypevr Constant @B{int} {bytes width} +@deftypevrx Constant @B{int} {long bytes width} +@deftypevrx Constant @B{int} {long long bytes width} +The number of chars in a @code{@B{bytes}} value. +@end deftypevr + +@deftypevr Constant @B{int} {max abs char} +The largest value which @code{@B{abs}} of a @code{@B{char}} can yield. +@end deftypevr + +@deftypevr Constant @B{char} {null character} +Some character. +@end deftypevr + +@deftypevr Constant @B{char} flip +@deftypevrx Constant @B{char} flop +Characters used to represent @code{@B{true}} and @code{@B{false}} +boolean values in textual transput. +@end deftypevr + +@deftypevr Constant @B{char} {error char} +Character used to represent the digit of a value resulting from a +conversion error in textual transput. +@end deftypevr + +@deftypevr Constant @B{char} blank +The space character. +@end deftypevr + +@deftypevr Constant {@B{l} @B{real}} {L pi} +The number pi. +@end deftypevr + +@node Standard modes +@section Standard modes + +@deftp Mode @B{void} +The only value of this mode is @code{@B{empty}}. +@end deftp + +@deftp Mode @B{bool} +Mode for the boolean truth values @code{@B{true}} and @code{@B{false}}. +@end deftp + +@deftp Mode {@B{l} @B{int}} +Modes for signed integral values. Each @code{@B{long}} or +@code{@B{short}} may increase or decrease the range of the domain, +depending on the characteristics of the current target. Further +@code{@B{long}}s and @code{@B{short}}s may be specified with no +effect. +@end deftp + +@deftp Mode {@B{l} @B{real}} +Modes for signed real values. Each @code{@B{long}} may increase the +upper range of the domain, depending on the characteristics of the +current target. Further @code{@B{long}}s may be specified but with no +effect. +@end deftp + +@deftp Mode @B{char} +Mode for character values. The character values are mapped one-to-one +to code points in the 21-bit space of Unicode. +@end deftp + +@deftp Mode @B{string} {= @B{flex}[1:0]@B{char}} +Mode for sequences of characters. This is implemented as a flexible +row of @code{@B{char}} values. +@end deftp + +@deftp Mode {@B{l} @B{compl}} {= @B{struct} (@B{real} re,im)} +Modes for complex values. Each @code{@B{long}} may increase the +precision of both the real and imaginary parts of the numbers, +depending on the characteristics of the current target. Further +@code{@B{long}}s may be specified with no effect. +@end deftp + +@deftp Mode {@B{l} @B{bits}} +Compact and efficient representation of a row of boolean values. Each +@code{@B{long}} may increase the number of booleans that can be packed +in a bits, depending on the characteristics of the current target. +@end deftp + +@deftp Mode {@B{l} @B{bytes}} +Compact and efficient representation of a row of character values. +Each @code{@B{long}} may increase the number of characters that can be +packed in a bytes, depending on the characteristics of the current +target. +@end deftp + +@node Standard priorities +@section Standard priorities + +@table @code +@item 1 +@itemize @bullet +@item @code{plusab}, @code{+:=} +@item @code{minusab}, @code{-:=} +@item @code{timesab}, @code{*:=} +@item @code{divab}, @code{/:=} +@item @code{overab}, @code{%:=} +@item @code{modab}, @code{%*:=} +@item @code{plusto}, @code{+=:} +@end itemize + +@item 2 +@itemize @bullet +@item @code{or} +@end itemize + +@item 3 +@itemize @bullet +@item @code{and} +@item @code{xor} +@end itemize + +@item 4 +@itemize @bullet +@item @code{@B{eq}}, @code{=} +@item @code{@B{ne}}, @code{/=} +@end itemize + +@item 5 +@itemize @bullet +@item @code{@B{lt}}, @code{<}, +@item @code{@B{le}}, @code{<=} +@item @code{@B{gt}}, @code{>} +@item @code{@B{ge}}, @code{>=} +@end itemize + +@item 6 +@itemize @bullet +@item @code{+} +@item @code{-} +@end itemize + +@item 7 +@itemize @bullet +@item @code{*} +@item @code{/} +@item @code{@B{over}}, @code{%} +@item @code{@B{mod}}, @code{%*} +@item @code{@B{elem}} +@end itemize + +@item 8 +@itemize @bullet +@item @code{**} +@item @code{@B{shl}}, @code{@B{up}} +@item @code{@B{shr}}, @code{@B{down}} +@item @code{@B{up}}, @code{@B{down}} +@item @code{^} +@item @code{@B{lwb}} +@item @code{@B{upb}} +@end itemize + +@item 9 +@itemize @bullet +@item @code{@B{i}} +@item @code{+*} +@end itemize +@end table + +@node Rows operators +@section Rows operators + +The following operators work on any row mode, denoted below using the +pseudo-mode @code{@B{rows}}. + +@deftypefn Operator {} {@B{lwb}} {= (@B{rows} a) @B{int}} +Monadic operator that yields the lower bound of the first bound pair +of the descriptor of the value of @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{upb}} {= (@B{rows} a) @B{int}} +Monadic operator that yields the upper bound of the first bound pair +of the descriptor of the value of @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{lwb}} {= (@B{int} n, @B{rows} a) @B{int}} +Dyadic operator that yields the lower bound in the n-th bound pair of +the descriptor of the value of @code{a}, if that bound pair exists. +Attempting to access a non-existing bound pair results in a run-time +error. +@end deftypefn + +@deftypefn Operator {} {@B{upb}} {= (@B{int} n, @B{rows} a) @B{int}} +Dyadic operator that yields the upper bound in the n-th bound pair of +the descriptor of the value of @code{a}, if that bound pair exists. +Attempting to access a non-existing bound pair results in a run-time +error. +@end deftypefn + +@node Boolean operators +@section Boolean operators + +@deftypefn Operator {} {@B{not}} {= (@B{bool} a) @B{bool}} +@deftypefnx Operator {} {~} {= (@B{bool} a) @B{bool}} +Monadic operator that yields the logical negation of its operand. +@end deftypefn + +@deftypefn Operator {} {@B{or}} {= (@B{bool} a, b) @B{bool}} +Dyadic operator that yields the logical ``or'' of its operands. +@end deftypefn + +@deftypefn Operator {} {@B{and}} {= (@B{bool} a, b) @B{bool}} +@deftypefnx Operator {} {@B{&}} {= (@B{bool} a, b) @B{bool}} +Dyadic operator that yields the logical ``and'' of its operands. +@end deftypefn + +@deftypefn Operator {} {@B{eq}} {= (@B{bool} a, b) @B{bool}} +@deftypefnx Operator {} {=} {= (@B{bool} a, b) @B{bool}} +Dyadic operator that yields @code{@B{true}} if its operands are the +same truth value, @code{@B{false}} otherwise. +@end deftypefn + +@deftypefn Operator {} {@B{ne}} {= (@B{bool} a, b) @B{bool}} +@deftypefnx Operator {} {/=} {= (@B{bool} a, b) @B{bool}} +Dyadic operator that yields @code{@B{false}} if its operands are the +same truth value, @code{@B{true}} otherwise. +@end deftypefn + +@deftypefn Operator {} {@B{abs}} {= (@B{bool} a) @B{int}} +Monadic operator that yields 1 if its operand is @code{@B{true}}, and +0 if its operand is @code{@B{false}}. +@end deftypefn + +@node Integral operators +@section Integral operators + +@subsection Arithmetic + +@deftypefn Operator {} {+} {= (@B{l} @B{int} a) @B{l} @B{int}} +Monadic operator that yields the affirmation of its operand. +@end deftypefn + +@deftypefn Operator {} {-} {= (@B{l} @B{int} a) @B{l} @B{int}} +Monadic operator that yields the negative of its operand. +@end deftypefn + +@deftypefn Operator {} {@B{abs}} {= (@B{l} @B{int} a) @B{l} @B{int}} +Monadic operator that yields the absolute value of its operand. +@end deftypefn + +@deftypefn Operator {} {@B{sign}} {= (@B{l} @B{int} a) @B{int}} +Monadic operator that yields -1 if @code{a} if negative, 0 if @code{a} +is zero and 1 if @code{a} is positive. +@end deftypefn + +@deftypefn Operator {} {@B{odd}} {= (@B{l} @B{int} a) @B{bool}} +Monadic operator that yields @code{@B{true}} if its operand is odd, +@code{@B{false}} otherwise. +@end deftypefn + +@deftypefn Operator {} {+} {= (@B{l} @B{int} a, b) @B{l} @B{int}} +Dyadic operator that yields the addition of its operands. +@end deftypefn + +@deftypefn Operator {} {-} {= (@B{l} @B{int} a, b) @B{l} @B{int}} +Dyadic operator that yields @code{b} subtracted from @code{a}. +@end deftypefn + +@deftypefn Operator {} {*} {= (@B{l} @B{int} a, b) @B{l} @B{int}} +Dyadic operator that yields the multiplication of its operands. +@end deftypefn + +@deftypefn Operator {} {@B{over}} {= (@B{l} @B{int} a, b) @B{l} @B{int}} +@deftypefnx Operator {} {%} {= (@B{l} @B{int} a, b) @B{l} @B{int}} +Dyadic operator that yields the integer division of @code{a} by +@code{b}, rounding the quotient toward zero. +@end deftypefn + +@deftypefn Operator {} {@B{mod}} {= (@B{l} @B{int} a, b) @B{l} @B{int}} +@deftypefnx Operator {} {%*} {= (@B{l} @B{int} a, b) @B{l} @B{int}} +Dyadic operator that yields the remainder of the division of @code{a} +by @code{b}. +@end deftypefn + +@deftypefn Operator {} {/} {= (@B{l} @B{int} a, b) @B{l} @B{real}} +Dyadic operator that yields the integer division with real result of +@code{a} by @code{b}. +@end deftypefn + +@deftypefn Operator {} {**} {= (@B{l} @B{int} a, b) @B{l} @B{int}} +@deftypefnx Operator {} {^} {= (@B{l} @B{int} a, b) @B{l} @B{int}} +Dyadic operator that yields @code{a} raised to the exponent @code{b}. +@end deftypefn + +@subsection Arithmetic combined with assignation + +@deftypefn Operator {} {@B{plusab}} {= (@B{ref} @B{l} @B{int} a, @B{l} @B{int} b) @B{ref} @B{l} @B{int}} +@deftypefnx Operator {} {+:=} {= (@B{ref} @B{l} @B{int} a, @B{l} @B{int} b) @B{ref} @B{l} @B{int}} +@dfn{Plus and become}. Dyadic operator that calculates @code{a + b}, +assigns the result of the operation to the name @code{a} and then +yields @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{minusab}} {= (@B{ref} @B{l} @B{int} a, @B{l} @B{int} b) @B{ref} @B{l} @B{int}} +@deftypefnx Operator {} {-:=} {= (@B{ref} @B{l} @B{int} a, @B{l} @B{int} b) @B{ref} @B{l} @B{int}} +Dyadic operator that calculates @code{a - b}, assigns the result of +the operation to the name @code{a} and then yields @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{timesab}} {= (@B{ref} @B{l} @B{int} a, @B{l} @B{int} b) @B{ref} @B{l} @B{int}} +@deftypefnx Operator {} {*:=} {= (@B{ref} @B{l} @B{int} a, @B{l} @B{int} b) @B{ref} @B{l} @B{int}} +Dyadic operator that calculates @code{a * b}, assigns the result of +the operation to the name @code{a} and then yields @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{overab}} {= (@B{ref} @B{l} @B{int} a, @B{l} @B{int} b) @B{ref} @B{l} @B{int}} +@deftypefnx Operator {} {%:=} {= (@B{ref} @B{l} @B{int} a, @B{l} @B{int} b) @B{ref} @B{l} @B{int}} +Dyadic operator that calculates @code{a % b}, assigns the result of +the operation to the name @code{a} and then yields @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{modab}} {= (@B{ref} @B{l} @B{int} a, @B{l} @B{int} b) @B{ref} @B{l} @B{int}} +@deftypefnx Operator {} {%*:=} {= (@B{ref} @B{l} @B{int} a, @B{l} @B{int} b) @B{ref} @B{l} @B{int}} +Dyadic operator that calculates @code{a %* b}, assigns the result of +the operation to the name @code{a} and then yields @code{a}. +@end deftypefn + +@subsection Relational + +@deftypefn Operator {} {@B{eq}} {= (@B{l} @B{int} a, b) @B{bool}} +@deftypefnx Operator {} {=} {= (@B{l} @B{int} a, b) @B{bool}} +Dyadic operator that yields whether its operands are equal. +@end deftypefn + +@deftypefn Operator {} {@B{ne}} {= (@B{l} @B{int} a, b) @B{bool}} +@deftypefnx Operator {} {/=} {= (@B{l} @B{int} a, b) @B{bool}} +Dyadic operator that yields whether its operands are not equal. +@end deftypefn + +@deftypefn Operator {} {@B{lt}} {= (@B{l} @B{int} a, b) @B{bool}} +@deftypefnx Operator {} {<} {= (@B{l} @B{int} a, b) @B{bool}} +Dyadic operator that yields whether @code{a} is less than @code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{le}} {= (@B{l} @B{int} a, b) @B{bool}} +@deftypefnx Operator {} {<=} {= (@B{l} @B{int} a, b) @B{bool}} +Dyadic operator that yields whether @code{a} is less than, or equal to +@code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{gt}} {= (@B{l} @B{int} a, b) @B{bool}} +@deftypefnx Operator {} {>} {= (@B{l} @B{int} a, b) @B{bool}} +Dyadic operator that yields whether @code{a} is greater than +@code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{ge}} {= (@B{l} @B{int} a, b) @B{bool}} +@deftypefnx Operator {} {>=} {= (@B{l} @B{int} a, b) @B{bool}} +Dyadic operator that yields whether @code{a} is greater than, or equal +to @code{b}. +@end deftypefn + +@subsection Conversion + +@deftypefn Operator {} {@B{shorten}} {= (@B{short} @B{int} a) @B{short} @B{short} @B{int}} +@deftypefnx Operator {} {@B{shorten}} {= (@B{int} a) @B{short} @B{int}} +@deftypefnx Operator {} {@B{shorten}} {= (@B{long} @B{int} a) @B{int}} +@deftypefnx Operator {} {@B{shorten}} {= (@B{long} @B{long} @B{int} a) @B{long} @B{int}} +Monadic operator that yields, if it exists, the integral value that +can be lengthened to the value of @code{a}. If the value doesn't +exist then the operator yields either the most positive integral value +in the destination mode, if @code{a} is bigger than that value, or the +most negative integral value in the destination mode, if @code{a} is +smaller than that value. +@end deftypefn + +@deftypefn Operator {} {@B{leng}} {= (@B{short} @B{short} @B{int} a) @B{short} @B{int}} +@deftypefnx Operator {} {@B{leng}} {= (@B{short} @B{int} a) @B{int}} +@deftypefnx Operator {} {@B{leng}} {= (@B{int} a) @B{long} @B{int}} +@deftypefnx Operator {} {@B{leng}} {= (@B{long} @B{int} a) @B{long} @B{long} @B{int}} +Monadic operator that yields the integral value lengthened from the +value of @code{a}. +@end deftypefn + +@node Real operators +@section Real operators + +@subsection Arithmetic + +@deftypefn Operator {} {+} {= (@B{l} @B{real} a) @B{l} @B{real}} +Monadic operator that yields the affirmation of its operand. +@end deftypefn + +@deftypefn Operator {} {-} {= (@B{l} @B{real} a) @B{l} @B{real}} +Monadic operator that yields the negative of its operand. +@end deftypefn + +@deftypefn Operator {} {@B{abs}} {= (@B{l} @B{real} a) @B{l} @B{real}} +Monadic operator that yields the absolute value of its operand. +@end deftypefn + +@deftypefn Operator {} {@B{sign}} {= (@B{l} @B{real} a) @B{int}} +Monadic operator that yields -1 if @code{a} if negative, 0 if @code{a} +is zero and 1 if @code{a} is positive. +@end deftypefn + +@deftypefn Operator {} {+} {= (@B{l} @B{real} a, b) @B{l} @B{real}} +Dyadic operator that yields the addition of its operands. +@end deftypefn + +@deftypefn Operator {} {-} {= (@B{l} @B{real} a, b) @B{l} @B{real}} +Dyadic operator that yields @code{b} subtracted from @code{a}. +@end deftypefn + +@deftypefn Operator {} {*} {= (@B{l} @B{real} a, b) @B{l} @B{real}} +Dyadic operator that yields the multiplication of its operands. +@end deftypefn + +@deftypefn Operator {} {/} {= (@B{l} @B{real} a, b) @B{l} @B{real}} +Dyadic operator that yields the realeger division with real result of +@code{a} by @code{b}. +@end deftypefn + +@deftypefn Operator {} {**} {= (@B{l} @B{real} a, b) @B{l} @B{real}} +@deftypefnx Operator {} {^} {= (@B{l} @B{real} a, b) @B{l} @B{real}} +Dyadic operator that yields @code{a} raised to the real exponent @code{b}. +@end deftypefn + +@deftypefn Operator {} {**} {= (@B{l} @B{real} a, @B{int} b) @B{l} @B{real}} +@deftypefnx Operator {} {^} {= (@B{l} @B{real} a, @B{int} b) @B{l} @B{real}} +Dyadic operator that yields @code{a} raised to the integral exponent +@code{b}. +@end deftypefn + +@subsection Arithmetic combined with assignation + +@deftypefn Operator {} {@B{plusab}} {= (@B{ref} @B{l} @B{real} a, @B{l} @B{real} b) @B{ref} @B{l} @B{real}} +@deftypefnx Operator {} {+:=} {= (@B{ref} @B{l} @B{real} a, @B{l} @B{real} b) @B{ref} @B{l} @B{real}} +@dfn{Plus and become}. Dyadic operator that calculates @code{a + b}, +assigns the result of the operation to the name @code{a} and then +yields @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{minusab}} {= (@B{ref} @B{l} @B{real} a, @B{l} @B{real} b) @B{ref} @B{l} @B{real}} +@deftypefnx Operator {} {-:=} {= (@B{ref} @B{l} @B{real} a, @B{l} @B{real} b) @B{ref} @B{l} @B{real}} +Dyadic operator that calculates @code{a - b}, assigns the result of +the operation to the name @code{a} and then yields @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{timesab}} {= (@B{ref} @B{l} @B{real} a, @B{l} @B{real} b) @B{ref} @B{l} @B{real}} +@deftypefnx Operator {} {*:=} {= (@B{ref} @B{l} @B{real} a, @B{l} @B{real} b) @B{ref} @B{l} @B{real}} +Dyadic operator that calculates @code{a * b}, assigns the result of +the operation to the name @code{a} and then yields @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{divab}} {= (@B{ref} @B{l} @B{real} a, @B{l} @B{real} b) @B{ref} @B{l} @B{real}} +@deftypefnx Operator {} {/:=} {= (@B{ref} @B{l} @B{real} a, @B{l} @B{real} b) @B{ref} @B{l} @B{real}} +Dyadic operator that calculates @code{a / b}, assigns the result of +the operation to the name @code{a} and then yields @code{a}. +@end deftypefn + +@subsection Relational + +@deftypefn Operator {} {@B{eq}} {= (@B{l} @B{real} a, b) @B{bool}} +@deftypefnx Operator {} {=} {= (@B{l} @B{real} a, b) @B{bool}} +Dyadic operator that yields whether its operands are equal. +@end deftypefn + +@deftypefn Operator {} {@B{ne}} {= (@B{l} @B{real} a, b) @B{bool}} +@deftypefnx Operator {} {/=} {= (@B{l} @B{real} a, b) @B{bool}} +Dyadic operator that yields whether its operands are not equal. +@end deftypefn + +@deftypefn Operator {} {@B{lt}} {= (@B{l} @B{real} a, b) @B{bool}} +@deftypefnx Operator {} {<} {= (@B{l} @B{real} a, b) @B{bool}} +Dyadic operator that yields whether @code{a} is less than @code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{le}} {= (@B{l} @B{real} a, b) @B{bool}} +@deftypefnx Operator {} {<=} {= (@B{l} @B{real} a, b) @B{bool}} +Dyadic operator that yields whether @code{a} is less than, or equal to +@code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{gt}} {= (@B{l} @B{real} a, b) @B{bool}} +@deftypefnx Operator {} {>} {= (@B{l} @B{real} a, b) @B{bool}} +Dyadic operator that yields whether @code{a} is greater than +@code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{ge}} {= (@B{l} @B{real} a, b) @B{bool}} +@deftypefnx Operator {} {>=} {= (@B{l} @B{real} a, b) @B{bool}} +Dyadic operator that yields whether @code{a} is greater than, or equal +to @code{b}. +@end deftypefn + +@subsection Conversions + +@deftypefn Operator {} {@B{round}} {= (@B{l} @B{real} a) @B{int}} +Monadic operator that yields the nearest integer to its operand. +@end deftypefn + +@deftypefn Operator {} {@B{entier}} {= (@B{l} @B{real} a) @B{int}} +Monadic operator that yields the integer equal to @code{a}, or the +next integer below (more negative than) @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{shorten}} {= (@B{long} @B{real} a) @B{real}} +@deftypefnx Operator {} {@B{shorten}} {= (@B{long} @B{long} @B{real} a) @B{long} @B{real}} +Monadic operator that yields, if it exists, the real value that +can be lengthened to the value of @code{a}. If the value doesn't +exist then the operator yields either the most positive real value +in the destination mode, if @code{a} is bigger than that value, or the +most negative real value in the destination mode, if @code{a} is +smaller than that value. +@end deftypefn + +@deftypefn Operator {} {@B{leng}} {= (@B{real} a) @B{long} @B{real}} +@deftypefnx Operator {} {@B{leng}} {= (@B{long} @B{real} a) @B{long} @B{long} @B{real}} +Monadic operator that yields the real value lengthened from the +value of @code{a}. +@end deftypefn + +@node Character operators +@section Character operators + +@subsection Relational + +@deftypefn Operator {} {@B{eq}} {= (@B{char} a, b) @B{bool}} +@deftypefnx Operator {} {=} {= (@B{char} a, b) @B{bool}} +Dyadic operator that yields whether its operands are equal. +@end deftypefn + +@deftypefn Operator {} {@B{ne}} {= (@B{char} a, b) @B{bool}} +@deftypefnx Operator {} {/=} {= (@B{char} a, b) @B{bool}} +Dyadic operator that yields whether its operands are not equal. +@end deftypefn + +@deftypefn Operator {} {@B{lt}} {= (@B{char} a, b) @B{bool}} +@deftypefnx Operator {} {<} {= (@B{char} a, b) @B{bool}} +Dyadic operator that yields whether @code{a} is less than @code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{le}} {= (@B{char} a, b) @B{bool}} +@deftypefnx Operator {} {<=} {= (@B{char} a, b) @B{bool}} +Dyadic operator that yields whether @code{a} is less than, or equal to +@code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{gt}} {= (@B{char} a, b) @B{bool}} +@deftypefnx Operator {} {>} {= (@B{char} a, b) @B{bool}} +Dyadic operator that yields whether @code{a} is greater than @code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{ge}} {= (@B{char} a, b) @B{bool}} +@deftypefnx Operator {} {>=} {= (@B{char} a, b) @B{bool}} +Dyadic operator that yields whether @code{a} is greater than, or equal +to @code{b}. +@end deftypefn + +@subsection Conversions + +@deftypefn Operator {} {@B{ABS}} {= (@B{char} a) @B{int}} +Monadic operator that yields an unique integer for each permissable +value of @code{@B{char}}. +@end deftypefn + +@deftypefn Operator {} {@B{REPR}} {= (@B{int} a) @B{char}} +The opposite of @code{@B{abs}} of a character. +@end deftypefn + +@node String operators +@section String operators + +@subsection Relational + +@deftypefn Operator {} {@B{eq}} {= (@B{string} a, b) @B{bool}} +@deftypefnx Operator {} {=} {= (@B{string} a, b) @B{bool}} +Dyadic operator that yields whether its operands are equal. Two +strings are equal if they contain the same sequence of characters. +@end deftypefn + +@deftypefn Operator {} {@B{ne}} {= (@B{string} a, b) @B{bool}} +@deftypefnx Operator {} {/=} {= (@B{string} a, b) @B{bool}} +Dyadic operator that yields whether its operands are not equal. +@end deftypefn + +@deftypefn Operator {} {@B{lt}} {= (@B{string} a, b) @B{bool}} +@deftypefnx Operator {} {<} {= (@B{string} a, b) @B{bool}} +Dyadic operator that yields whether the string @code{a} is less than +the string @code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{le}} {= (@B{string} a, b) @B{bool}} +@deftypefnx Operator {} {<=} {= (@B{string} a, b) @B{bool}} +Dyadic operator that yields whether the string @code{a} is less than, +or equal to string @code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{gt}} {= (@B{string} a, b) @B{bool}} +@deftypefnx Operator {} {>} {= (@B{string} a, b) @B{bool}} +Dyadic operator that yields whether the string @code{a} is greater +than the string @code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{ge}} {= (@B{string} a, b) @B{bool}} +@deftypefnx Operator {} {>=} {= (@B{string} a, b) @B{bool}} +Dyadic operator that yields whether the string @code{a} is greater +than, or equal to the string @code{b}. +@end deftypefn + +@subsection Composition + +@deftypefn Operator {} {+} {= (@B{string} a, b) @B{string}} +Dyadic operator that yields the concatenation of the two given +strings as a new string. +@end deftypefn + +@deftypefn Operator {} {+} {= (@B{string} a, @B{char} b) @B{string}} +Dyadic operator that yields the concatenation of the given string +@code{a} and a string whose contents are the character @code{b}. +@end deftypefn + +@deftypefn Operator {} {*} (= (@B{int} a, @B{string} b) @B{string}) +@deftypefnx Operator {} {*} (= (@B{string} b, @B{int} a) @B{string}) +Dyadic operator that yields the string @code{a} concatenated @code{a} +times to itself. If @code{a} is less than zero then it is interpreted +to be zero. +@end deftypefn + +@subsection Composition combined with assignation + +@deftypefn Operator {} {@B{plusab}} {= (@B{ref} @B{string} a, @B{string} b) @B{ref} @B{string}} +@deftypefnx Operator {} {+:=} {= (@B{ref} @B{string} a, @B{string} b) @B{ref} @B{string}} +@dfn{Plus and become}. Dyadic operator that calculates @code{a + b}, +assigns the result of the operation to the name @code{a} and then +yields @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{plusto}} {= (@B{string} b, @B{ref} @B{string} a) @B{ref} @B{string}} +@deftypefnx Operator {} {+=:} {= (@B{string} b, @B{ref} @B{string} b) @B{ref} @B{string}} +Dyadic operator that calculates @code{a + b}, assigns the result of +the operation to the name @code{a} and then yields @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{timesab}} {= (@B{ref} @B{string} a, @B{string} b) @B{ref} @B{string}} +@deftypefnx Operator {} {*:=} {= (@B{ref} @B{string} a, @B{string} b) @B{ref} @B{stringl}} +@dfn{Plus and become}. Dyadic operator that calculates @code{a * b}, +assigns the result of the operation to the name @code{a} and then +yields @code{a}. +@end deftypefn + +@node Complex operators +@section Complex operators + +@node Bits operators +@section Bits operators + +@subsection Logical + +@deftypefn Operator {} {@B{NOT}} {= (@B{l} @B{bits} a, b) @B{l} @B{bits}} +@deftypefnx Operator {} {~} {= (@B{l} @B{bits} a, b) @B{l} @B{bits}} +Monadic operator that yields the element-wise not logical operation in +the elements of the given bits operand. +@end deftypefn + +@deftypefn Operator {} {@B{AND}} {= (@B{l} @B{bits} a, b) @B{l} @B{bits}} +@deftypefnx Operator {} {&} {= (@B{l} @B{bits} a, b) @B{l} @B{bits}} +Dyadic operator that yields the element-wise and logical operation in +the elements of the given bits operands. +@end deftypefn + +@deftypefn Operator {} {@B{OR}} {= (@B{l} @B{bits} a, b) @B{l} @B{bits}} +Dyadic operator that yields the element-wise ``or'' logical operation +in the elements of the given bits operands. +@end deftypefn + +@subsection Shifting + +@deftypefn Operator {} {@B{SHL}} {= (@B{l} @B{bits} a, @B{int} n) @B{l} @B{bits}} +@deftypefnx Operator {} {@B{UP}} {= (@B{l} @B{bits} a, @B{int} n) @B{l} @B{bits}} +Dyadic operator that yields the given bits operand shifted @code{n} +positions to the left. Extra elements introduced on the right are +initialized to @code{@B{false}}. +@end deftypefn + +@deftypefn Operator {} {@B{SHR}} {= (@B{l} @B{bits} a, @B{int} n) @B{l} @B{bits}} +@deftypefnx Operator {} {@B{DOWN}} {= (@B{l} @B{bits} a, @B{int} n) @B{l} @B{bits}} +Dyadic operator that yields the given bits operand shifted @code{n} +positions to the right. Extra elements introduced on the left are +initialized to @code{@B{false}}. +@end deftypefn + +@subsection Relational + +@deftypefn Operator {} {@B{eq}} {= (@B{l} @B{bits} a, b) @B{bool}} +@deftypefnx Operator {} {=} {= (@B{l} @B{bits} a, b) @B{bool}} +Dyadic operator that yields whether its operands are equal. Two +bits are equal if they contain the same sequence of booleans. +@end deftypefn + +@deftypefn Operator {} {@B{ne}} {= (@B{l} @B{bits} a, b) @B{bool}} +@deftypefnx Operator {} {/=} {= (@B{l} @B{bits} a, b) @B{bool}} +Dyadic operator that yields whether its operands are not equal. +@end deftypefn + +@deftypefn Operator {} {@B{lt}} {= (@B{l} @B{bits} a, b) @B{bool}} +@deftypefnx Operator {} {<} {= (@B{l} @B{bits} a, b) @B{bool}} +Dyadic operator that yields whether the bits @code{a} is less than +the bits @code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{le}} {= (@B{l} @B{bits} a, b) @B{bool}} +@deftypefnx Operator {} {<=} {= (@B{l} @B{bits} a, b) @B{bool}} +Dyadic operator that yields whether the bits @code{a} is less than, +or equal to bits @code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{gt}} {= (@B{l} @B{bits} a, b) @B{bool}} +@deftypefnx Operator {} {>} {= (@B{l} @B{bits} a, b) @B{bool}} +Dyadic operator that yields whether the bits @code{a} is greater than +the bits @code{b}. +@end deftypefn + +@deftypefn Operator {} {@B{ge}} {= (@B{l} @B{bits} a, b) @B{bool}} +@deftypefnx Operator {} {>=} {= (@B{l} @B{bits} a, b) @B{bool}} +Dyadic operator that yields whether the bits @code{a} is greater +than, or equal to the bits @code{b}. +@end deftypefn + +@subsection Conversions + +@deftypefn Operator {} {@B{abs}} {= (@B{l} @B{bits} a) @B{l} @B{int}} +Monadic operator that yields the integral value whose constituent bits +correspond to the booleans stored in @code{a}. @xref{@code{@B{bin}} +and @code{@B{abs}} of negative integral values}. +@end deftypefn + +@deftypefn Operator {} {@B{bin}} {= (@B{l} @B{int} a) @B{l} @B{bits}} +Monadic operator that yields the bits value whose boolean elements map +the bits in the given integral operand. @xref{@code{@B{bin}} and +@code{@B{abs}} of negative integral values}. +@end deftypefn + +@deftypefn Operator {} {@B{shorten}} {= (@B{long} @B{bits} a) @B{bits}} +@deftypefnx Operator {} {@B{shorten}} {= (@B{long} @B{long} @B{bits} a) @B{long} @B{bits}} +Monadic operator that yields the bits value that can be lengthened to +the value of @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{leng}} {= (@B{bits} a) @B{long} @B{bits}} +@deftypefnx Operator {} {@B{leng}} {= (@B{long} @B{bits} a) @B{long} @B{long} @B{bits}} +Monadic operator that yields the bits value lengthened from the value +of @code{a}. The lengthened value features @code{@B{false}} in the +extra left positions added to match the lengthened size. +@end deftypefn + +@node Bytes operators +@section Bytes operators + +@node Semaphore operators +@section Semaphore operators + +@node Math procedures +@section Math procedures + +@subsection Arithmetic + +@deftypefn Procedure {} {@B{sqrt}} {= (@B{l} @B{real} a) @B{l} @B{real}} +Procedure that yields the square root of the given real argument. +@end deftypefn + +@subsection Logarithms + +@deftypefn Procedure {} {@B{ln}} {= (@B{l} @B{real} a) @B{l} @B{real}} +Procedure that yields the base @code{e} logarithm of the given real +argument. +@end deftypefn + +@deftypefn Procedure {} {@B{exp}} {= (@B{l} @B{real} a) @B{l} @B{real}} +Procedure that yields the exponential function of the given real +argument. This is the inverse of @code{@B{ln}}. +@end deftypefn + +@subsection Trigonometric + +@deftypefn Procedure {} {@B{sin}} {= (@B{l} @B{real} a) @B{l} @B{real}} +Procedure that yields the sin trigonometric function of the given real +argument. +@end deftypefn + +@deftypefn Procedure {} {@B{arcsin}} {= (@B{l} @B{real} a) @B{l} @B{real}} +Procedure that yields the arc-sin trigonometric function of the given real +argument. +@end deftypefn + +@deftypefn Procedure {} {@B{cos}} {= (@B{l} @B{real} a) @B{l} @B{real}} +Procedure that yields the cos trigonometric function of the given real +argument. +@end deftypefn + +@deftypefn Procedure {} {@B{arccos}} {= (@B{l} @B{real} a) @B{l} @B{real}} +Procedure that yields the arc-cos trigonometric function of the given real +argument. +@end deftypefn + +@deftypefn Procedure {} {@B{tan}} {= (@B{l} @B{real} a) @B{l} @B{real}} +Procedure that yields the tan trigonometric function of the given real +argument. +@end deftypefn + +@deftypefn Procedure {} {@B{arctan}} {= (@B{l} @B{real} a) @B{l} @B{real}} +Procedure that yields the arc-tan trigonometric function of the given +real argument. +@end deftypefn + +@node Extended prelude +@chapter Extended prelude +@cindex prelude, extended + +This chapter documents the GNU extensions to the standard prelude. +The facilities documented below are available to Algol 68 programs +only if the @option{gnu68} language dialect is selected, which is the +default. + +The extended prelude is available to Algol 68 programs without needing +to import any module, provided they are compiled as @code{gnu68} code, +which is the default. + +@menu +* Extended priorities:: Priorities of extended operators. +* Extended environment enquiries:: Information about the implementation. +* Extended rows operators:: Rows and associated operations. +* Extended boolean operators:: Operations on boolean operands. +* Extended bits operators:: Bits and associated operations. +* Extended math procedures:: Mathematical constants and functions. +@end menu + +@node Extended priorities +@section Extended priorities + +@table @code +@item 3 +@itemize @bullet +@item @code{@B{xor}} +@end itemize + +@item 8 +@itemize @bullet +@item @code{@B{elems}} +@end itemize +@end table + +@node Extended environment enquiries +@section Extended environment enquiries + +An @dfn{environment enquiry} is a constant, whose value may be useful +to the programmer, that reflects some characteristic of the particular +implementation. The values of these enquiries are also determined by +the architecture and operating system targeted by the compiler. + +@deftypevr Constant {@B{l} @B{int}} {L min int} +The most negative integral value. +@end deftypevr + +@deftypevr Constant {@B{l} @B{real}} {L min real} +The most negative real value. +@end deftypevr + +@deftypevr Constant {@B{l} @B{real}} {L infinity} +Positive infinity expressed in a real value. +@end deftypevr + +@deftypevr Constant {@B{l} @B{real}} {L minus infinity} +Negative infinity expressed in a real value. +@end deftypevr + +@deftypevr Constant @B{char} {invalid char} +A character that is unknown or unrepresentable in Unicode. +@end deftypevr + +@node Extended rows operators +@section Extended rows operators + +The following operators work on any row mode, denoted below using the +pseudo-mode @code{@B{rows}}. + +@deftypefn Operator {} {@B{elems}} {= (@B{rows} a) @B{int}} +Monadic operator that yields the number of elements implied by the +first bound pair of the descriptor of the value of @code{a}. +@end deftypefn + +@deftypefn Operator {} {@B{elems}} {= (@B{int} n, @B{rows} a) @B{int}} +Dyadic operator that yields the number of elements implied by the n-th +bound pair of the descriptor of the value of @code{a}. +@end deftypefn + +@node Extended boolean operators +@section Extended boolean operators + +@deftypefn Operator {} {@B{xor}} {= (@B{bool} a, b) @B{bool}} +Dyadic operator that yields the exclusive-or operation of the given +boolean arguments. +@end deftypefn + +@node Extended bits operators +@section Extended bits operators + +@deftypefn Operator {} {@B{xor}} {= (@B{l} @B{bits} a, b) @B{l} @B{bits}} +Dyadic operator that yields the bit exclusive-or operation of the +given bits arguments. +@end deftypefn + +@node Extended math procedures +@section Extended math procedures + +@subsection Logarithms + +@deftypefn Procedure {} {@B{log}} {= (@B{l} @B{real} a, b) @B{l} @B{real}} +Procedure that calculates the base ten logarithm of the given arguments. +@end deftypefn + +@node POSIX prelude +@chapter POSIX prelude + +The POSIX prelude provides facilities to perform simple transput (I/O) +based on POSIX file descriptors, accessing the file system, +command-line arguments, environment variables, etc. + +This prelude is available to Algol 68 programs without needing to +import any module, provided they are compiled as @code{gnu68} code, +which is the default. + +@menu +* POSIX process:: Process exit status. +* POSIX command line:: Parsing command-line arguments. +* POSIX environment:: Environment variables. +* POSIX errors:: Error handling and error descriptions. +* POSIX files:: Creating, opening and closing files. +* POSIX sockets:: Communication endpoints. +* POSIX string transput:: Reading and writing characters and strings. +@end menu + +@node POSIX process +@section POSIX process + +The Algol 68 program can report an exit status to the operating system +once they stop running. The exit status reported by default is zero, +which corresponds to success. + +@deftypefn Procedure {} {set exit status} {= (@B{int} status)} +Procedure that sets the exit status to report to the operating system +once the program stop executing. The default exit status is 0 which, +by convention, is interpreted by POSIX systems as success. A value +different to zero is interpreted as an error status. This procedure +can be invoked more than one, the previous exit status being +overwritten. +@end deftypefn + +@node POSIX command line +@section POSIX command line + +Algol 68 programs can access the command-line arguments passed to them +by using the following procedures. + +@deftypefn Procedure {} {argc} {= @B{int}} +Procedure that yields the number of arguments passed in the command +line, including the name of the program. +@end deftypefn + +@deftypefn Procedure {} {argv} {= (@B{int} n) @B{string}} +Procedure that yields the @code{n}th argument passed in the command +line. The first argument is always the name used to invoke the +program. If @code{n} is out of range then this procedure returns the +empty string. +@end deftypefn + +@node POSIX environment +@section POSIX environment + +@deftypefn Procedure {} {getenv} {= (@B{string} varname) @B{string}} +Procedure that yields the value of the environment variable +@code{varname} as a string. If the specified environmental variable +is not defined the this procedure returns an empty string. +@end deftypefn + +@node POSIX errors +@section POSIX errors + +When a call to a procedure in this prelude results in an error, the +called procedure signals the error in some particular way and also +sets a global @code{errno} to a code describing the error. For +example, trying to opening a file that doesn't exist will result in +@code{fopen} returning -1, which signals an error. The caller can +then inspect the global @code{errno} to see what particular error +prevented the operation to be completed: in this case, @code{errno} +will contain the error code corresponding to ``file doesn't exist''. + +@deftypefn Procedure {} {errno} {= @B{int}} +This procedure yields the current value of the global @code{errno}. +The yielded value reflects the error status of the last executed POSIX +prelude operation. +@end deftypefn + +@deftypefn Procedure {} {strerror} {= (@B{int} ecode) @B{string}} +This procedure gets an error code and yields a string containing an +explanatory short description of the error. It is typical to pass the +output of @code{errno} to this procedure. +@end deftypefn + +@deftypefn Procedure {} {perror} {= (@B{string} msg) @B{void}} +This procedure prints the given string @code{msg} in the standard +error output, followed by a colon character, a space character and +finally the string error of the current value of @code{errno}. +@end deftypefn + +@node POSIX files +@section POSIX files + +File descriptors are @code{@B{int}} values that identify open files +that can be accessed by the program. The @code{fopen} procedure +allocates file descriptors as it opens files, and the descriptor is +used in subsequent transput calls to perform operations on the files. + +@subsection Standard file descriptors + +There are three descriptors, however, which are automatically opened +when the program starts executing and automatically closed when the +program finishes. These are: + +@deftypevr Constant {@B{int}} {stdin} +File descriptor associated with the standard input. Its value is @code{0}. +@end deftypevr + +@deftypevr Constant {@B{int}} {stdout} +File descriptor associated with the standard output. Its value is @code{1}. +@end deftypevr + +@deftypevr Constant {@B{int}} {stderr} +File descriptor associated with the standard error. Its value is @code{2}. +@end deftypevr + +@subsection Opening and closing files + +@deftypefn Procedure {} {fopen} {= (@B{string} pathname, @B{bits} flags) @B{int}} +Open the file specified by @code{pathname}. The argument @code{flags} +is a combination of @code{file o} flags as defined below. If the +specified file is successfully opened while satisfying the constraints +implied by @code{flags} then this procedure yields a file descriptor +that is used in subsequent I/O calls to refer to the open +file. Otherwise, this procedure yields -1. The particular error can +be inspected by calling the @code{errno} procedure. +@end deftypefn + +@deftypefn Procedure {} {fclose} {= (@B{int} fd) @B{int}} +Close the given file descriptor, which no longer refers to any file. +This procedure yields zero on success, and -1 on error. In the later +case, the program can look at the particular error by calling the +@code{errno} procedure. +@end deftypefn + +@subsection Creating files + +@deftypefn Procedure {} {fcreate} {= (@B{string} pathname, @B{bits} mode) @B{int}} +Create a file with name @code{pathname}. The argument @code{mode} is +a @code{@B{bits}} value containing a bit pattern that determines the +permissions on the created file. The bit pattern has the form +@code{8rUGO}, where @code{U} reflects the permissions of the user who +owns the file, @code{U} reflects the permissions of the users +pertaining to the file's group, and @code{O} reflects the permissions +of all other users. The permission bits are 1 for execute, 2 for +write and 4 for read. If the file is successfully created then this +procedure yields a file descriptor that is used in subsequent I/O +calls to refer to the newly created file. Otherwise, this procedure +yields -1. The particular error can be inspected by calling the +@code{errno} procedure. +@end deftypefn + +@subsection Flags for @code{fopen} + +The following flags can be combined using bit-wise operators. Note +that in POSIX systems the effective mode of the created file is the +mode specified by the programmer masked with the process's +@dfn{umask}. + +@deftypevr Constant {@B{bits}} {file o default} +Flag for @code{fopen} indicating that the file shall be opened with +whatever capabilities allowed by its permissions. +@end deftypevr + +@deftypevr Constant {@B{bits}} {file o rdwr} +Flag for @code{fopen} indicating that the file shall be opened for +both reading and writing. +@end deftypevr + +@deftypevr Constant {@B{bits}} {file o rdonly} +Flag for @code{fopen} indicating that the file shall be opened for +reading only. This flag is not compatible with @code{file o rdwr} nor +with @code{file o wronly}. +@end deftypevr + +@deftypevr Constant {@B{bits}} {file o wronly} +Flag for @code{fopen} indicating that the file shall be opened for +write only. This flag is not compatible with @code{file o rdwr} nor +with @code{file o rdonly}. +@end deftypevr + +@deftypevr Constant {@B{bits}} {file o trunc} +Flag for @code{fopen} indicating that the opened file shall be +truncated upon opening it. The file must allow writing for this flag +to take effect. The effect of combining @code{file o trunc} and +@code{file o rdonly} is undefined and varies among implementations. +@end deftypevr + +@subsection Getting file properties + +@deftypefn Procedure {} {fsize} {= (@B{int} fd) @B{long} @B{long} @B{int}} +Return the size in bytes of the file characterized by the file +descriptor @code{fd}. If the system entity characterized by the given +file descriptor doesn't have a size, if the size of the file cannot be +stored in a @code{@B{long} @B{long} @B{int}}, or if there is any other +error condition, this procedure yields -1 and @code{errno} is set +appropriately. +@end deftypefn + +@node POSIX sockets +@section POSIX sockets + +A program can communicate with other computers, or with other +processes running in the same computer, via sockets. The sockets are +identified by file descriptors. + +@deftypefn Procedure {} {fconnect} {= (@B{string} host, @B{int} port) @B{int}} +This procedure creates a stream socket and connects it to the given +@code{host} using port @code{port}. The established communication is +full-duplex, and allows sending and receiving data using transput +until it gets closed. On success this procedure yields a file +descriptor. On error this procedure yields -1 and @code{errno} is set +appropriately. +@end deftypefn + +@node POSIX string transput +@section POSIX string transput + +The following procedures read or write characters and strings from and +to open files. The external encoding of the files is assumed to be +UTF-8. Since Algol 68 @code{@B{char}}s are USC-4, this means that +reading or writing a character may involve reading or writing more +than one byte, depending on the particular Unicode code points +involved. + +@subsection Output of strings and chars + +@deftypefn Procedure {} {putchar} {= (@B{char} c) @B{char}} +Write the given character to the standard output. This procedure +yields @code{c} in case the character got successfully written, or +@code{invalid char} otherwise. +@end deftypefn + +@deftypefn Procedure {} {puts} {= (@B{string} str) @B{void}} +Write the given string to the standard output. +@end deftypefn + +@deftypefn Procedure {} {fputc} {= (@B{int} fd, @B{char} c) @B{int}} +Write given character @code{c} to the file with descriptor @code{fd}. +This procedure yields @code{c} on success, or @code{invalid char} +on error. +@end deftypefn + +@deftypefn Procedure {} {fputs} {= (@B{int} fd, @B{string} str) @B{int}} +Write the given string @code{str} to the file with descriptor +@code{fd}. This procedure yields the number of bytes written on +success, or 0 on error. +@end deftypefn + +@subsection Input of strings and chars + +@deftypefn Procedure {} {getchar} {= @B{char}} +Read a character from the standard input. This procedure yields the +read character in case the character got successfully read, or +@code{invalid char} otherwise. +@end deftypefn + +@deftypefn Procedure {} {gets} {= (@B{int} n) @B{ref} @B{string}} +Read a string composed of @code{n} characters from the standard input +and yield a reference to it. If @code{n} is bigger than zero then +characters get read until either @code{n} characters have been read or +the end of line is reached. If @code{n} is zero or negative then +characters get read until either a new line character is read or the +end of line is reached. +@end deftypefn + +@deftypefn Procedure {} {fgetc} {= (@B{int} fd) @B{int}} +Read a character from the file with descriptor @code{fd}. This +procedure yields the read character in case the character got +successfully read, or @code{invalid char} otherwise. +@end deftypefn + +@deftypefn Procedure {} {fgets} {= (@B{int} fd, @B{int} n) @B{ref} @B{string}} +Read a string from the file with descriptor @code{fd} and yield a +reference to it. If @code{n} is bigger than zero then characters get +read until either @code{n} characters have been read or the end of +line is reached. If @code{n} is zero or negative then characters get +read until either a new line character is read or the end of line is +reached. +@end deftypefn + +@node Language extensions +@chapter Language extensions + +This chapter documents the GNU extensions implemented by this compiler +on top of the Algol 68 programming language. These extensions +collectively conform a strict @dfn{superlanguage} of Algol 68, and are +enabled by default. To disable them the user can select the strict +Algol 68 standard by passing the option @option{-std=algol68} when +invoking the compiler. + +@menu +* @code{@B{bin}} and @code{@B{abs}} of negative integral values:: +* Bold taggles:: Using underscores in mode and operator indications. +@end menu + +@node @code{@B{bin}} and @code{@B{abs}} of negative integral values +@section @code{@B{bin}} and @code{@B{abs}} of negative integral values + +The @code{@B{bin}} operator gets an integral value and yields a +@code{@B{bits}} value that reflects the internal bits of the integral +value. The semantics of this operator, as defined in the Algol 68 +standard prelude, are: + +@example +@B{op} @B{bin} = (L @B{int} a) L @B{bits}: + @B{if} a >= L 0 + @B{then} L @B{int} b := a; L @B{bits}; + @B{for} i @B{from} L bits width @B{by} -1 @B{to} 1 + @B{do} (L F @B{of} c)[i] := @B{odd} b; b := b % L 2 @B{od}; + c + @B{fi}; +@end example + +The @code{@B{abs}} operator performs the inverse operation of +@code{@B{bits}}. Given a @code{L @B{bits}} value, it yields the +@code{L @B{int}} value whose bits representation is the bits value. +The semantics of this operator, as defined in the Algol 68 prelude, +are: + +@example +@B{op} @B{abs} = (L @B{bits} a) L @B{int}: +@B{begin} L @B{int} c := L 0; + @B{for} i @B{to} L bits width + @B{do} c := L 2 * c + K @B{abs} (L F @B{of} a)[i] @B{od}; + c +@B{end} +@end example + +@noindent +Note how the @code{@B{bin}} of a negative integral value is not +defined: the implicit else-part of the conditional yields +@code{@B{skip}}, which is defined as any bits value in that context. +Note also how @code{@B{abs}} doesn't make any provision to check +whether the resulting value is positive: it assumes it is so. + +The GNU Algol 68 compiler, when working in strict Algol 68 mode +(@option{-std=algol68}), makes @code{@B{bin}} to always yield @code{L +@B{bits} (@B{skip})} when given a negative value, as mandated by the +report. But the skip value is always the bits representation of zero, +@i{i.e.} 2r0. Strict Algol 68 programs, however, must not rely on +this. + +When GNU extensions are enabled (@option{-std=gnu68}) the +@code{@B{bin}} of a negative value yields the two's complement bit +pattern of the value rather than zero. Therefore, @code{@B{bin} - +@B{short} @B{short} 2} yields @code{2r11111110}. And @code{@B{abs} +@B{short} @B{short} 2r11111110} yields -2. + +@node Bold taggles +@section Bold taggles + +This compiler supports the stropping regimes known as UPPER and +SUPPER. In both regimes bold words are written by writing their +constituent bold letters and digits, in order. In UPPER regime all +the letters of a bold word are to be written using upper-case. In +SUPPER regime, only the first bold letter is required to be written +using upper-case, and this only when the bold word is not a reserved +word. + +When a bold word comprises several natural words, it may be a little +difficult to distinguish them at first sight. Consider for example +the following code, written fist in UPPER stropping: + +@example +MODE TREENODE = STRUCT (TREENODEPAYLOAD data, REF TREENODE next), + TREENODEPAYLOAD = STRUCT (INT code, REAL average, mean); +@end example + +@noindent +Then written in SUPPER stropping: + +@example +mode TreeNode = struct (TreeNodePayload data, REF TreeNode next), + TreeNodePayload = struct (int code, real average, mean); +@end example + +Particularly in UPPER stropping, it may be difficult to distinguish +the constituent natural words at first sight. + +In order to improve this, this compiler implements a GNU extension +called @dfn{bold taggles} that allows to use underscore characters +(@code{_}) within mode and operator indications as a visual aid to +improve readability. When this extension is enabled, mode indications +and operator indications consist in a sequence of the so-called +@dfn{bold taggles}, which are themselves sequences of one or more bold +letters or digits optionally terminated by an underscore character. + +With bold taggles enabled the program above could have been written +using UPPER stropping as: + +@example +MODE TREE_NODE = STRUCT (TREE_NODE_PAYLOAD data, REF TREE_NODE next), + TREE_NODE_PAYLOAD = STRUCT (INT code, REAL average, mean); +@end example + +@noindent +And using SUPPER stropping as: + +@example +mode Tree_Node = struct (Tree_Node_Payload data, ref Tree_Node next), + Tree_Node_Payload = struct (int code, real average, mean); +@end example + +@noindent +Which is perhaps more readable for most people. Note that the +underscore characters are not really part of the mode or operator +indication. Both @code{TREE_NODE} and @code{TREENODE} denote the same +mode indication. Note also that, following the definition, constructs +like @code{Foo__bar} and @code{_Baz} are not valid indications. + +Bold taggles are available when the gnu68 dialect of the language is +selected. @xref{Dialect options}. + +@include gpl_v3.texi +@include fdl.texi + +@node Option Index +@unnumbered Option Index + +@command{ga68}'s command line options are indexed here without any initial +@samp{-} or @samp{--}. Where an option has both positive and negative forms +(such as @option{-f@var{option}} and @option{-fno-@var{option}}), relevant +entries in the manual are indexed under the most appropriate form; it may +sometimes be useful to look up both forms. + +@printindex op + +@node General Index +@unnumbered Index + +@printindex cp + +@bye diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index fd208f53844..52eb7851001 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -57,6 +57,7 @@ through the macros defined in the @file{.h} file. * D Language and ABI:: Controlling D ABI changes. * Rust Language and ABI:: Controlling Rust ABI changes. * JIT Language and ABI:: JIT ABI parameters +* ALGOL 68 Language and ABI:: Controlling ALGOL 68 ABI changes. * Named Address Spaces:: Adding support for named address spaces * Misc:: Everything else. @end menu @@ -11416,6 +11417,23 @@ keys added by this hook are made available at compile time by calling get_target_info. @end deftypefn +@node ALGOL 68 Language and ABI +@section ALGOL 68 ABI parameters +@cindex parameters, ALGOL 68 abi + +@deftypefn {Algol68 Target Hook} void TARGET_ALGOL68_CPU_INFO (void) +Declare all environmental CPU info and features relating to the target CPU +using the function @code{algol68_add_target_info}, which takes a string +representing the feature key and a string representing the feature value. +Configuration pairs predefined by this hook apply to all files that are being +compiled. +@end deftypefn + +@deftypefn {Algol68 Target Hook} void TARGET_ALGOL68_OS_INFO (void) +Similar to @code{TARGET_ALGOL68_CPU_INFO}, but is used for configuration info +relating to the target operating system. +@end deftypefn + @node Named Address Spaces @section Adding support for named address spaces @cindex named address spaces diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in index 14315dd5080..de505a8550c 100644 --- a/gcc/doc/tm.texi.in +++ b/gcc/doc/tm.texi.in @@ -57,6 +57,7 @@ through the macros defined in the @file{.h} file. * D Language and ABI:: Controlling D ABI changes. * Rust Language and ABI:: Controlling Rust ABI changes. * JIT Language and ABI:: JIT ABI parameters +* ALGOL 68 Language and ABI:: Controlling ALGOL 68 ABI changes. * Named Address Spaces:: Adding support for named address spaces * Misc:: Everything else. @end menu @@ -7317,6 +7318,14 @@ floating-point support; they are not included in this mechanism. @hook TARGET_JIT_REGISTER_CPU_TARGET_INFO +@node ALGOL 68 Language and ABI +@section ALGOL 68 ABI parameters +@cindex parameters, ALGOL 68 abi + +@hook TARGET_ALGOL68_CPU_INFO + +@hook TARGET_ALGOL68_OS_INFO + @node Named Address Spaces @section Adding support for named address spaces @cindex named address spaces -- 2.30.2
