This is bigloo.info, produced by makeinfo version 4.5 from bigloo.texi.

  This file documents Bigloo, an implementation of an extended version
of the Scheme programming language.

  Copyright (C) 1992-99, 2000-02 Manuel Serrano

     This program is free software; you can redistribute it
     and/or modify it under the terms of the GNU General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
     
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
     
     You should have received a copy of the GNU General Public
     License along with this program; if not, write to the Free
     Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
     MA 02111-1307, USA.

INFO-DIR-SECTION The Algorithmic Language Scheme
START-INFO-DIR-ENTRY
* bigloo: (bigloo).            The Bigloo Scheme compiler
END-INFO-DIR-ENTRY


File: bigloo.info,  Node: Global Index,  Next: Library Index,  Prev: Bee,  Up: Top

Global Index
************

* Menu:

* #! Unix shell interpreter:             SRFIs.
* ':                                     Expressions.
* *:                                     Numbers.
* *about-to-read*:                       A New Way of Reading.
* *auto-mode*:                           User Extensions.
* *bigloo-strict-r5rs-strings*:          Strings.
* *debug-parser*:                        Debugging Lalr Grammars.
* *dynamic-load-path*:                   Eval standard functions.
* *extend-entry*:                        User Extensions.
* *fl:                                   Numbers.
* *fx:                                   Numbers.
* *load-path* <1>:                       Eval standard functions.
* *load-path*:                           Reading Path.
* *pp-case*:                             Input and Output.
* *pp-width*:                            Input and Output.
* *second:                               Date.
* *user-pass*:                           User Extensions.
* *warning*:                             Errors and Assertions.
* +:                                     Numbers.
* +fl:                                   Numbers.
* +fx:                                   Numbers.
* +second:                               Date.
* -:                                     Numbers.
* -fl:                                   Numbers.
* -fx:                                   Numbers.
* -second:                               Date.
* .afile:                                Module Access File.
* .bigloorc:                             Compiler Description.
* .jfile:                                Compiling with the JVM back-end.
* /:                                     Numbers.
* /fl:                                   Numbers.
* /fx:                                   Numbers.
* <:                                     Numbers.
* <=:                                    Numbers.
* <=fl:                                  Numbers.
* <=fx:                                  Numbers.
* <=second:                              Date.
* <constant>:                            Expressions.
* <fl:                                   Numbers.
* <fx:                                   Numbers.
* <second:                               Date.
* <variable>:                            Expressions.
* =:                                     Numbers.
* =fl:                                   Numbers.
* =fx:                                   Numbers.
* =second:                               Date.
* >:                                     Numbers.
* >=:                                    Numbers.
* >=fl:                                  Numbers.
* >=fx:                                  Numbers.
* >=second:                              Date.
* >fl:                                   Numbers.
* >fx:                                   Numbers.
* >second:                               Date.
* @:                                     Qualified Notation.
* `:                                     Expressions.
* A complete library example:            Bigloo Libraries.
* A new way of reading:                  A New Way of Reading.
* a simple example of Lalr(1) parsing:   A Simple Example.
* abandoned-mutex-exception?:            SRFI-18.
* abs:                                   Numbers.
* abstract-class:                        Class declaration.
* Acknowledgements:                      Acknowledgements.
* acos:                                  Numbers.
* afile:                                 Module Access File.
* and:                                   Expressions.
* and-let*:                              Expressions.
* any:                                   Pairs And Lists.
* any?:                                  Pairs And Lists.
* append:                                Pairs And Lists.
* append!:                               Pairs And Lists.
* append-output-binary-file:             Serialization.
* append-output-file:                    Input and Output.
* apply:                                 Control Features.
* args-parse:                            Command Line Parsing.
* args-parse-usage:                      Command Line Parsing.
* arguments parsing:                     Command Line Parsing.
* asin:                                  Numbers.
* assert:                                Errors and Assertions.
* assertions:                            Errors and Assertions.
* assoc:                                 Pairs And Lists.
* assq:                                  Pairs And Lists.
* assv:                                  Pairs And Lists.
* asynchronous data transfer:            Signal.
* asynchronous input:                    Signal.
* asynchronous output:                   Signal.
* asynchronous process termination:      Signal.
* asynchronous sleep:                    Signal.
* asynchronous socket connect:           Signal.
* atan:                                  Numbers.
* automatic extern clauses generation:   Automatic extern clauses generation.
* Automatic Java clauses generation:     Automatic Java clauses generation.
* basename:                              Files.
* begin:                                 Expressions.
* bigloo:                                Top.
* bigloo development environment:        Bee.
* bigloo-class-demangle:                 Name mangling.
* bigloo-class-mangled?:                 Name mangling.
* bigloo-demangle:                       Name mangling.
* bigloo-mangle:                         Name mangling.
* bigloo-mangled?:                       Name mangling.
* bigloo-module-mangle:                  Name mangling.
* bigloo-need-mangling:                  Name mangling.
* bigloo.foreign.must_exitp:             Bigloo runtime customization.
* binary-port?:                          Serialization.
* bind-exit:                             Control Features.
* bit manipulation:                      Bit Manipulation.
* bit-and:                               Bit Manipulation.
* bit-lsh:                               Bit Manipulation.
* bit-not:                               Bit Manipulation.
* bit-or:                                Bit Manipulation.
* bit-rsh:                               Bit Manipulation.
* bit-xor:                               Bit Manipulation.
* blit-string!:                          Strings.
* boolean?:                              Booleans.
* Booleans:                              Booleans.
* broadcast!:                            Signal.
* Building a library:                    Bigloo Libraries.
* building a makefile:                   Building a Makefile.
* C arrays:                              C arrays.
* C atomic types:                        Atomic types.
* C enum:                                C enums.
* C functions:                           C functions.
* C interface:                           C Interface.
* C null pointers:                       C null pointers.
* C opaque:                              C opaques.
* C pointers:                            C pointers.
* C requirement:                         Compiler Description.
* C structure and union types:           C structures and unions.
* caar:                                  Pairs And Lists.
* cadr:                                  Pairs And Lists.
* Calendar:                              Date.
* call:                                  Expressions.
* call-with-input-file:                  Input and Output.
* call-with-output-file:                 Input and Output.
* call-with-values:                      Control Features.
* call/cc:                               Control Features.
* car:                                   Pairs And Lists.
* case:                                  Expressions.
* cdddar:                                Pairs And Lists.
* cddddr:                                Pairs And Lists.
* cdr:                                   Pairs And Lists.
* ceiling:                               Numbers.
* char->integer:                         Characters.
* char->ucs2:                            UCS-2 Characters.
* char-alphabetic?:                      Characters.
* char-ci<=?:                            Characters.
* char-ci<?:                             Characters.
* char-ci=?:                             Characters.
* char-ci>=?:                            Characters.
* char-ci>?:                             Characters.
* char-downcase:                         Characters.
* char-lower-case?:                      Characters.
* char-numeric?:                         Characters.
* char-ready?:                           Input and Output.
* char-ready? and run-process:           Input and Output.
* char-upcase:                           Characters.
* char-upper-case?:                      Characters.
* char-whitespace?:                      Characters.
* char<=?:                               Characters.
* char<?:                                Characters.
* char=?:                                Characters.
* char>=?:                               Characters.
* char>?:                                Characters.
* char?:                                 Characters.
* characters:                            Characters.
* chdir:                                 Files.
* chmod:                                 Files.
* cigloo:                                Automatic extern clauses generation.
* class:                                 Class declaration.
* Class declaration:                     Class declaration.
* class-all-fields:                      Introspection.
* class-creator:                         Introspection.
* class-field-accessor:                  Introspection.
* class-field-indexed?:                  Introspection.
* class-field-info:                      Introspection.
* class-field-len-accessor:              Introspection.
* class-field-mutable?:                  Introspection.
* class-field-mutator:                   Introspection.
* class-field-name:                      Introspection.
* class-field?:                          Introspection.
* class-fields:                          Introspection.
* class-name:                            Object library.
* class-subclasses:                      Object library.
* class-super:                           Object library.
* class?:                                Object library.
* client-server:                         Socket.
* close-binary-port:                     Serialization.
* close-input-port:                      Input and Output.
* close-output-port:                     Input and Output.
* close-process-ports:                   Process.
* co-instantiate:                        Creating and accessing objects.
* cobj:                                  Atomic types.
* command line parsing:                  Command Line Parsing.
* command-line:                          Operating System Interface.
* comments:                              Comments.
* Compiler description:                  Compiler Description.
* compiler JVM options:                  Compiling with the JVM back-end.
* compiler options:                      Compiler Description.
* Compiling:                             Compiling.
* compiling and linking with a library:  Bigloo Libraries.
* Compiling with the JVM back-end:       Compiling with the JVM back-end.
* complex?:                              Numbers.
* cond:                                  Expressions.
* cond-expand:                           SRFIs.
* condition-variable-broadcast!:         SRFI-18.
* condition-variable-name:               SRFI-18.
* condition-variable-signal!:            SRFI-18.
* condition-variable-specific!:          SRFI-18.
* condition-variable-specific-set!:      SRFI-18.
* condition-variable?:                   SRFI-18.
* Connecting Scheme and Java code:       Connecting Scheme and Java code.
* cons*:                                 Pairs And Lists.
* control features:                      Control Features.
* cooperative process:                   Signal.
* copy-vector:                           Vectors.
* cos:                                   Numbers.
* Creating and accessing objects:        Creating and accessing objects.
* current-date:                          Date.
* current-error-port:                    Input and Output.
* current-exception-handler:             SRFI-18.
* current-input-port:                    Input and Output.
* current-output-port:                   Input and Output.
* current-printer:                       Input and Output.
* current-scheduler:                     Scheduler.
* current-seconds:                       Date.
* current-thread:                        Thread.
* current-time:                          SRFI-18.
* Custom types:                          Extending the Runtime System.
* Date:                                  Date.
* date:                                  Operating System Interface.
* date->seconds:                         Date.
* date->string:                          Date.
* date->utc-string:                      Date.
* date-copy:                             Date.
* date-day:                              Date.
* date-hour:                             Date.
* date-is-dst:                           Date.
* date-minute:                           Date.
* date-month:                            Date.
* date-second:                           Date.
* date-timezone:                         Date.
* date-wday:                             Date.
* date-yday:                             Date.
* date-year:                             Date.
* date?:                                 Date.
* day-aname:                             Date.
* day-name:                              Date.
* day-seconds:                           Date.
* debugging:                             Debugging.
* Debugging Lalr Grammars:               Debugging Lalr Grammars.
* Declaring abstract Java classes:       Declaring abstract Java classes.
* Declaring Java arrays:                 Declaring Java arrays.
* Declaring Java classes:                Declaring Java classes.
* default-repl-error-notifier:           Eval standard functions.
* define <1>:                            Explicit Typing.
* define:                                Definitions.
* define-expander:                       Macro Expansion.
* define-generic:                        Generic functions.
* define-inline <1>:                     Explicit Typing.
* define-inline:                         Inline Procedures.
* define-macro:                          Macro Expansion.
* define-method:                         Generic functions.
* define-record-type:                    Records (SRFI-9).
* define-struct:                         Structures.
* define-syntax:                         Macro Expansion.
* defining an extern type:               Defining an extern type.
* Definitions:                           Definitions.
* delay:                                 Expressions.
* delete:                                Pairs And Lists.
* delete!:                               Pairs And Lists.
* delete-directory:                      Files.
* delete-file:                           Files.
* directives:                            Module Declaration.
* directory->list:                       Files.
* directory?:                            Files.
* dirname:                               Files.
* display:                               Input and Output.
* display*:                              Input and Output.
* display-circle:                        Input and Output.
* do:                                    Expressions.
* DSSSL formal argument lists:           DSSSL Support.
* DSSSL support:                         DSSSL Support.
* duplicate:                             Creating and accessing objects.
* duplicate:::                           Creating and accessing objects.
* dynamic-load:                          Eval standard functions.
* dynamic-wind:                          Control Features.
* Efficiency:                            Compiler Description.
* elong->flonum:                         Numbers.
* elong->string:                         Numbers.
* elong?:                                Numbers.
* Embedded Bigloo applications:          Embedded Bigloo applications.
* Entering the Bee:                      Entering the Bee.
* eof-object?:                           Input and Output.
* eq?:                                   Equivalence Predicates.
* equal?:                                Equivalence Predicates.
* Equality:                              Equality.
* Equivalence predicates:                Equivalence Predicates.
* eqv?:                                  Equivalence Predicates.
* error:                                 Errors and Assertions.
* error handling:                        Errors and Assertions.
* error/location:                        Errors and Assertions.
* eval <1>:                              Eval standard functions.
* eval:                                  Module Declaration.
* Eval and the foreign interface:        Eval and the foreign interface.
* Eval command line options:             Eval command line options.
* Eval standard functions:               Eval standard functions.
* even?:                                 Numbers.
* every:                                 Pairs And Lists.
* every?:                                Pairs And Lists.
* exact fixnum:                          Numbers.
* exact->inexact:                        Numbers.
* exact?:                                Numbers.
* examples of regular grammar:           Examples of Regular Grammar.
* executable-name:                       Operating System Interface.
* exit:                                  Operating System Interface.
* exp:                                   Numbers.
* expand:                                Eval standard functions.
* expand-once:                           Eval standard functions.
* Expansing:                             Expansing.
* expansion passing style:               Macro Expansion.
* explicit typing:                       Explicit Typing.
* export:                                Module Declaration.
* exporting a Scheme variable:           Exporting a Scheme variable.
* Exporting Scheme variables to Java:    Exporting Scheme variables.
* Expressions:                           Expressions.
* expt:                                  Numbers.
* extern:                                Module Declaration.
* Fair Threads:                          Threads.
* fair-read/rp:                          Signal.
* file handling:                         Files.
* file-exists?:                          Files.
* file-modification-time:                Files.
* file-separator:                        Operating System Interface.
* file-size:                             Files.
* filter:                                Control Features.
* filter!:                               Control Features.
* final-class:                           Class declaration.
* find-class-field:                      Introspection.
* find-file/path:                        Files.
* fixnum:                                Numbers.
* fixnum (long):                         Numbers.
* fixnum->flonum:                        Numbers.
* fixnum?:                               Numbers.
* flonum:                                Numbers.
* flonum->elong:                         Numbers.
* flonum->fixnum:                        Numbers.
* flonum->llong:                         Numbers.
* flonum?:                               Numbers.
* floor:                                 Numbers.
* flush-output-port:                     Input and Output.
* for-each:                              Control Features.
* for-each-hash:                         Deprecated Hash Tables.
* force:                                 Control Features.
* format:                                Input and Output.
* fprint:                                Input and Output.
* fprintf:                               Input and Output.
* from:                                  Module Declaration.
* gcd:                                   Numbers.
* Generic functions:                     Generic functions.
* Genericity of arithmetic procedures:   Compiler Description.
* gensym:                                Symbols.
* get-hash:                              Deprecated Hash Tables.
* get-output-string:                     Input and Output.
* get-procedure-serialization:           Serialization.
* get-process-serialization:             Serialization.
* get-prompter:                          Eval standard functions.
* get-repl-error-notifier::procedure:    Eval standard functions.
* get-signal-handler:                    Operating System Interface.
* get-write-length:                      Input and Output.
* getenv:                                Operating System Interface.
* getprop:                               Symbols.
* hardware fixnum:                       Numbers.
* hash tables <1>:                       Deprecated Hash Tables.
* hash tables:                           New Hash Tables.
* hash-table-nb-entry:                   Deprecated Hash Tables.
* hash-table?:                           Deprecated Hash Tables.
* hashtable->list:                       New Hash Tables.
* hashtable->vector:                     New Hash Tables.
* hashtable-for-each:                    New Hash Tables.
* hashtable-get:                         New Hash Tables.
* hashtable-put!:                        New Hash Tables.
* hashtable-remove!:                     New Hash Tables.
* hashtable-size:                        New Hash Tables.
* hashtable-update!:                     New Hash Tables.
* hashtable?:                            New Hash Tables.
* hostname:                              Operating System Interface.
* if:                                    Expressions.
* ignore:                                The Semantics Actions.
* import:                                Module Declaration.
* importing an extern function:          Importing an extern function.
* importing an extern variable:          Importing an extern variable.
* Importing and Exporting:               Importing and Exporting.
* include:                               Module Declaration.
* including an extern file:              Including an extern file.
* inexact->exact:                        Numbers.
* inexact?:                              Numbers.
* inline procedure:                      Inline Procedures.
* input and output:                      Input and Output.
* input-char:                            Serialization.
* input-obj:                             Serialization.
* input-port-name:                       Input and Output.
* input-port-position:                   Input and Output.
* input-port-reopen!:                    Input and Output.
* input-port?:                           Input and Output.
* input-string-port?:                    Input and Output.
* installing the bee:                    Installing the Bee.
* instantiate:                           Creating and accessing objects.
* instantiate:::                         Creating and accessing objects.
* int->0..255:                           Deprecated Hash Tables.
* int->0..2^x-1:                         Deprecated Hash Tables.
* integer->char:                         Characters.
* integer->second:                       Date.
* integer->string:                       Numbers.
* integer->ucs2:                         UCS-2 Characters.
* integer?:                              Numbers.
* interaction-environment:               Eval standard functions.
* Interpreting:                          Interpreting.
* Introspection:                         Introspection.
* iota:                                  Pairs And Lists.
* IP number:                             Socket.
* is-a?:                                 Object library.
* java:                                  Module Declaration.
* Java interface:                        Java Interface.
* jfile:                                 Compiling with the JVM back-end.
* jigloo:                                Automatic Java clauses generation.
* join-timeout-exception?:               SRFI-18.
* JVM requirement:                       Compiler Description.
* keyword->string:                       Keywords.
* keyword?:                              Keywords.
* keywords:                              Keywords.
* labels <1>:                            Explicit Typing.
* labels:                                Expressions.
* Lalr grammar and Regular grammar:      The Regular Grammar.
* Lalr parsing:                          Lalr Parsing.
* Lalr precedence and associativity:     Precedence and Associativity.
* lalr(1) grammar definition:            Grammar Definition.
* lalr-grammar:                          Grammar Definition.
* lambda:                                Expressions.
* last-pair:                             Pairs And Lists.
* lcm:                                   Numbers.
* leap-year?:                            Date.
* length:                                Pairs And Lists.
* let <1>:                               Explicit Typing.
* let:                                   Expressions.
* let* <1>:                              Explicit Typing.
* let*:                                  Expressions.
* let-syntax:                            Macro Expansion.
* letrec <1>:                            Explicit Typing.
* letrec:                                Expressions.
* letrec-syntax:                         Macro Expansion.
* libraries:                             Bigloo Libraries.
* library:                               Module Declaration.
* Library and inline functions:          Bigloo Libraries.
* Library and modules:                   Bigloo Libraries.
* library and repl:                      Bigloo Libraries.
* Library and SRFI:                      Bigloo Libraries.
* Limitation of the JVM back-end:        Limitation of the JVM back-end.
* linking:                               Compiler Description.
* list:                                  Pairs And Lists.
* list->string:                          Strings.
* list->ucs2-string:                     Unicode (UCS-2) Strings.
* list->vector:                          Vectors.
* list-ref:                              Pairs And Lists.
* list-tabulate:                         Pairs And Lists.
* list-tail:                             Pairs And Lists.
* list?:                                 Pairs And Lists.
* literate programming:                  Literate Programming.
* llong->flonum:                         Numbers.
* llong->string:                         Numbers.
* llong?:                                Numbers.
* load <1>:                              Eval standard functions.
* load:                                  Module Declaration.
* loada:                                 Eval standard functions.
* loadq:                                 Eval standard functions.
* log:                                   Numbers.
* long fixnum:                           Numbers.
* macro expansion:                       Macro Expansion.
* main:                                  Module Declaration.
* make-accept-signal:                    Signal.
* make-client-socket:                    Socket.
* make-condition-variable:               SRFI-18.
* make-connect-signal:                   Signal.
* make-date:                             Date.
* make-directories:                      Files.
* make-directory:                        Files.
* make-elong:                            Numbers.
* make-file-name:                        Files.
* make-file-path:                        Files.
* make-hash-table:                       Deprecated Hash Tables.
* make-hashtable:                        New Hash Tables.
* make-input-signal:                     Signal.
* make-list:                             Pairs And Lists.
* make-mutex:                            SRFI-18.
* make-output-signal:                    Signal.
* make-process-signal:                   Signal.
* make-scheduler:                        Scheduler.
* make-send-chars-signal:                Signal.
* make-server-socket:                    Socket.
* make-shared-library-name:              Files.
* make-sleep-signal:                     Signal.
* make-static-library-name:              Files.
* make-string:                           Strings.
* make-thread:                           Thread.
* make-ucs2-string:                      Unicode (UCS-2) Strings.
* make-vector:                           Vectors.
* map:                                   Control Features.
* match-case:                            Bigloo Pattern Matching Facilities.
* match-lambda:                          Bigloo Pattern Matching Facilities.
* max:                                   Numbers.
* member:                                Pairs And Lists.
* memq:                                  Pairs And Lists.
* memv:                                  Pairs And Lists.
* min:                                   Numbers.
* module:                                Module Declaration.
* module access file:                    Module Access File.
* Module body language:                  Scheme Library.
* module declaration:                    Module Declaration.
* module export-all:                     Module Declaration.
* module export-exports:                 Module Declaration.
* module export-module:                  Module Declaration.
* modules:                               Modules.
* Modules and DSSSL formal argument lists: DSSSL Support.
* modulo:                                Numbers.
* month-aname:                           Date.
* month-name:                            Date.
* Multi-line comments:                   Syntax.
* multiple-value-bind:                   Control Features.
* mutex-lock!:                           SRFI-18.
* mutex-name:                            SRFI-18.
* mutex-specific:                        SRFI-18.
* mutex-specific-set!:                   SRFI-18.
* mutex-state:                           SRFI-18.
* mutex-unlock!:                         SRFI-18.
* mutex?:                                SRFI-18.
* Name mangling:                         Name mangling.
* native-printer:                        Input and Output.
* native-repl-printer:                   Eval standard functions.
* negative?:                             Numbers.
* negfl:                                 Numbers.
* negfx:                                 Numbers.
* newline:                               Input and Output.
* not:                                   Booleans.
* notify-error:                          Errors and Assertions.
* null-environment:                      Eval standard functions.
* null?:                                 Pairs And Lists.
* number->string:                        Numbers.
* number?:                               Numbers.
* Numbers:                               Numbers.
* obj:                                   Atomic types.
* obj->0..255:                           Deprecated Hash Tables.
* obj->0..2^x-1:                         Deprecated Hash Tables.
* obj->string:                           Serialization.
* Object:                                Object System.
* object dumping:                        Serialization.
* Object library:                        Object library.
* Object serialization:                  Object serialization.
* Object System:                         Object System.
* object->struct:                        Object library.
* object-class:                          Object library.
* object-constructor:                    Object library.
* object-display:                        Object library.
* object-equal?:                         Object library.
* object-hashnumber <1>:                 Object library.
* object-hashnumber:                     New Hash Tables.
* object-write:                          Object library.
* odd?:                                  Numbers.
* on-line documentation:                 On-line documentation.
* open-input-binary-file:                Serialization.
* open-input-c-string:                   Input and Output.
* open-input-file:                       Input and Output.
* open-input-procedure:                  Input and Output.
* open-input-string:                     Input and Output.
* open-output-binary-file:               Serialization.
* open-output-file:                      Input and Output.
* open-output-string:                    Input and Output.
* operating system interface:            Operating System Interface.
* operator:                              Expressions.
* option:                                Module Declaration.
* or:                                    Expressions.
* os-arch:                               Operating System Interface.
* os-class:                              Operating System Interface.
* os-name:                               Operating System Interface.
* os-tmp:                                Operating System Interface.
* os-version:                            Operating System Interface.
* output-char:                           Serialization.
* output-obj:                            Serialization.
* output-port-position:                  Input and Output.
* output-port?:                          Input and Output.
* output-string-port?:                   Input and Output.
* Overview of Bigloo:                    Overview.
* pair-nil:                              Atomic types.
* pair-or-null?:                         Pairs And Lists.
* pair?:                                 Pairs And Lists.
* Pairs and lists:                       Pairs And Lists.
* path-separator:                        Operating System Interface.
* pattern matching:                      Pattern Matching.
* peek-char:                             Input and Output.
* Performance of the JVM back-end:       Performance of the JVM back-end.
* port?:                                 Input and Output.
* positive?:                             Numbers.
* pp:                                    Input and Output.
* pragma:::                              The very dangerous pragma Bigloo special form.
* prefix:                                Files.
* pregexp:                               Regular Expressions Procedures.
* pregexp-match:                         Regular Expressions Procedures.
* pregexp-match-positions:               Regular Expressions Procedures.
* pregexp-replace:                       Regular Expressions Procedures.
* pregexp-replace*:                      Regular Expressions Procedures.
* pregexp-split:                         Regular Expressions Procedures.
* pretty printing:                       Pretty Printing.
* print:                                 Input and Output.
* printf:                                Input and Output.
* procedure?:                            Control Features.
* procedure call:                        Expressions.
* process:                               Process.
* Process support:                       Process.
* process-alive?:                        Process.
* process-continue:                      Process.
* process-error-port:                    Process.
* process-exit-status:                   Process.
* process-input-port:                    Process.
* process-kill:                          Process.
* process-list:                          Process.
* process-output-port:                   Process.
* process-pid:                           Process.
* process-send-signal:                   Process.
* process-stop:                          Process.
* process-wait:                          Process.
* process?:                              Process.
* profiling:                             Profiling.
* Program Structure:                     Program Structure.
* put-hash!:                             Deprecated Hash Tables.
* putenv:                                Operating System Interface.
* putprop!:                              Symbols.
* pwd:                                   Files.
* qualified notation:                    Qualified Notation.
* quasiquote:                            Expressions.
* quit:                                  Eval standard functions.
* quotation:                             Expressions.
* quote:                                 Expressions.
* quotient:                              Numbers.
* raise:                                 SRFI-18.
* rational?:                             Numbers.
* read:                                  Input and Output.
* read eval print loop:                  Eval.
* Read Eval Print Loop customized:       Eval standard functions.
* read-case-insensitive:                 Input and Output.
* read-case-sensitive:                   Input and Output.
* read-char:                             Input and Output.
* read-chars:                            Input and Output.
* read-fill-string!:                     Input and Output.
* read-line:                             Input and Output.
* read-lines:                            Input and Output.
* read-of-strings:                       Input and Output.
* read-string:                           Input and Output.
* read/case:                             Input and Output.
* read/lalrp <1>:                        The Parsing Function.
* read/lalrp:                            Input and Output.
* read/rp <1>:                           A New Way of Reading.
* read/rp:                               Input and Output.
* reading path:                          Reading Path.
* real->string:                          Numbers.
* real?:                                 Numbers.
* receive:                               Control Features.
* records:                               Records (SRFI-9).
* regexp-quote:                          Regular Expressions Procedures.
* register-eval-srfi!:                   SRFIs.
* register-exit-function!:               Operating System Interface.
* register-procedure-serialization:      Serialization.
* register-process-serialization:        Serialization.
* Regular expressions:                   Posix Regular Expressions.
* Regular parsing:                       Regular Parsing.
* regular-grammar:                       The Syntax of The Regular Parser.
* rem-key-hash!:                         Deprecated Hash Tables.
* rem-obj-hash!:                         Deprecated Hash Tables.
* remainder:                             Numbers.
* remprop!:                              Symbols.
* remq:                                  Pairs And Lists.
* remq!:                                 Pairs And Lists.
* rename-file:                           Files.
* repl:                                  Eval standard functions.
* reverse:                               Pairs And Lists.
* reverse!:                              Pairs And Lists.
* revised(5) macro expansion:            Macro Expansion.
* revision control:                      Revision control.
* rgc-context:                           The Semantics Actions.
* round:                                 Numbers.
* run-process:                           Process.
* run-process and char-ready?:           Input and Output.
* run-process and input/output:          Input and Output.
* safety:                                Compiler Description.
* scheduler-broadcast!:                  Signal.
* scheduler-instant:                     Scheduler.
* scheduler-react!:                      Scheduler.
* scheduler-start!:                      Scheduler.
* scheduler-terminate!:                  Scheduler.
* scheduler?:                            Scheduler.
* scheme-report-environment:             Eval standard functions.
* searching for source code:             Searching for source code.
* seconds->date:                         Date.
* seconds->string:                       Date.
* seconds->utc-string:                   Date.
* select (à la unix):                    Thread.
* send-chars:                            Input and Output.
* Serialization:                         Serialization.
* set!:                                  Expressions.
* set-car!:                              Pairs And Lists.
* set-cdr!:                              Pairs And Lists.
* set-input-port-position!:              Input and Output.
* set-output-port-position!:             Input and Output.
* set-printer!:                          Input and Output.
* set-prompter!:                         Eval standard functions.
* set-repl-error-notifier!:              Eval standard functions.
* set-repl-printer!:                     Eval standard functions.
* set-write-length!:                     Input and Output.
* shrink!:                               Widening and shrinking.
* signal:                                Operating System Interface.
* sin:                                   Numbers.
* sleep:                                 Operating System Interface.
* Socket support:                        Socket.
* socket-accept:                         Socket.
* socket-accept-connection:              Socket.
* socket-client?:                        Socket.
* socket-close:                          Socket.
* socket-down?:                          Socket.
* socket-dup:                            Socket.
* socket-host-address:                   Socket.
* socket-hostname:                       Socket.
* socket-input:                          Socket.
* socket-local-address:                  Socket.
* socket-output:                         Socket.
* socket-port-number:                    Socket.
* socket-server?:                        Socket.
* socket-shutdown:                       Socket.
* socket?:                               Socket.
* sort:                                  Control Features.
* sqrt:                                  Numbers.
* SRFI:                                  SRFIs.
* srfi-0:                                SRFIs.
* srfi-0: library:                       Bigloo Libraries.
* srfi-0:bigloo:                         SRFIs.
* SRFI-0:bigloo-c:                       JVM back-end and SRFI-0.
* SRFI-0:bigloo-jvm:                     JVM back-end and SRFI-0.
* SRFI-1:                                Pairs And Lists.
* SRFI-18:                               SRFI-18.
* SRFI-2:                                Expressions.
* SRFI-22:                               SRFIs.
* SRFI-28:                               Input and Output.
* SRFI-30:                               Syntax.
* SRFI-6:                                Input and Output.
* SRFI-8:                                Control Features.
* SRFI-9:                                Records (SRFI-9).
* Stack allocation:                      Compiler Description.
* static:                                Module Declaration.
* string:                                Strings.
* string->0..255:                        Deprecated Hash Tables.
* string->0..2^x-1:                      Deprecated Hash Tables.
* string->elong:                         Numbers.
* string->integer:                       Numbers.
* string->keyword:                       Keywords.
* string->list:                          Strings.
* string->llong:                         Numbers.
* string->number:                        Numbers.
* string->obj:                           Serialization.
* string->real:                          Numbers.
* string->symbol:                        Symbols.
* string->symbol-ci:                     Symbols.
* string-append:                         Strings.
* string-capitalize:                     Strings.
* string-capitalize!:                    Strings.
* string-case:                           The Syntax of The Regular Parser.
* string-ci<=?:                          Strings.
* string-ci<?:                           Strings.
* string-ci=?:                           Strings.
* string-ci>=?:                          Strings.
* string-ci>?:                           Strings.
* string-compare3:                       Strings.
* string-compare3-ci:                    Strings.
* string-copy:                           Strings.
* string-downcase:                       Strings.
* string-downcase!:                      Strings.
* string-fill!:                          Strings.
* string-for-read:                       Strings.
* string-length:                         Strings.
* string-ptr-null?:                      C null pointers.
* string-ref:                            Strings.
* string-set!:                           Strings.
* string-shrink!:                        Strings.
* string-upcase:                         Strings.
* string-upcase!:                        Strings.
* string<=?:                             Strings.
* string<?:                              Strings.
* string=?:                              Strings.
* string>=?:                             Strings.
* string>?:                              Strings.
* string?:                               Strings.
* Strings:                               Strings.
* struct->object:                        Object library.
* struct?:                               Structures.
* structures:                            Structures.
* substring:                             Strings.
* substring=?:                           Strings.
* subucs2-string:                        Unicode (UCS-2) Strings.
* suffix:                                Files.
* symbol->string:                        Symbols.
* symbol-append:                         Symbols.
* symbol-plist:                          Symbols.
* symbol?:                               Symbols.
* symbols:                               Symbols.
* Syntax:                                Syntax.
* syntax-rules:                          Macro Expansion.
* system:                                Operating System Interface.
* System programming:                    System Programming.
* system->string:                        Operating System Interface.
* tan:                                   Numbers.
* terminated-thread-exception?:          SRFI-18.
* the bee root directory:                The Bee Root Directory.
* The compiler environment and options:  Compiler Description.
* the interpreter:                       Eval.
* the lalr(1) parsing function:          The Parsing Function.
* the pattern language:                  The Pattern Language.
* The runtime-command file:              Compiler Description.
* the semantics actions:                 The Semantics Actions.
* The syntax of the foreign declarations: The syntax of the foreign declarations.
* The syntax of the regular parser:      The Syntax of The Regular Parser.
* The very dangerous "pragma" Bigloo special form: The very dangerous pragma Bigloo special form.
* the-character:                         The Semantics Actions.
* the-context:                           The Semantics Actions.
* the-failure:                           The Semantics Actions.
* the-fixnum:                            The Semantics Actions.
* the-flonum:                            The Semantics Actions.
* the-keyword:                           The Semantics Actions.
* the-length:                            The Semantics Actions.
* the-port:                              The Semantics Actions.
* the-string:                            The Semantics Actions.
* the-substring:                         The Semantics Actions.
* the-symbol:                            The Semantics Actions.
* thread-await!:                         Thread.
* thread-await*!:                        Thread.
* thread-await-values!:                  Thread.
* thread-await-values*!:                 Thread.
* thread-cleanup:                        Thread.
* thread-cleanup-set!:                   Thread.
* thread-get-values!:                    Thread.
* thread-get-values*!:                   Thread.
* thread-join!:                          Thread.
* thread-name:                           Thread.
* thread-resume!:                        Thread.
* thread-sleep!:                         Thread.
* thread-specific:                       Thread.
* thread-specific-set!:                  Thread.
* thread-start!:                         Thread.
* thread-suspend!:                       Thread.
* thread-terminate!:                     Thread.
* thread-yield!:                         Thread.
* thread?:                               Thread.
* Threads:                               Threads.
* Time:                                  Date.
* time->seconds:                         SRFI-18.
* time?:                                 SRFI-18.
* transcript-off:                        Eval standard functions.
* transcript-on:                         Eval standard functions.
* truncate:                              Numbers.
* try <1>:                               Errors and Assertions.
* try:                                   Control Features.
* type:                                  Module Declaration.
* Typed identifier:                      Syntax.
* UCS-2 characters:                      UCS-2 Characters.
* UCS-2 strings:                         Unicode (UCS-2) Strings.
* ucs2->char:                            UCS-2 Characters.
* ucs2->integer:                         UCS-2 Characters.
* ucs2-alphabetic?:                      UCS-2 Characters.
* ucs2-ci<=?:                            UCS-2 Characters.
* ucs2-ci<?:                             UCS-2 Characters.
* ucs2-ci=?:                             UCS-2 Characters.
* ucs2-ci>=?:                            UCS-2 Characters.
* ucs2-ci>?:                             UCS-2 Characters.
* ucs2-downcase:                         UCS-2 Characters.
* ucs2-lower-case?:                      UCS-2 Characters.
* ucs2-numeric?:                         UCS-2 Characters.
* ucs2-string:                           Unicode (UCS-2) Strings.
* ucs2-string->list:                     Unicode (UCS-2) Strings.
* ucs2-string->utf8-string:              Unicode (UCS-2) Strings.
* ucs2-string-append:                    Unicode (UCS-2) Strings.
* ucs2-string-ci<=?:                     Unicode (UCS-2) Strings.
* ucs2-string-ci<?:                      Unicode (UCS-2) Strings.
* ucs2-string-ci=?:                      Unicode (UCS-2) Strings.
* ucs2-string-ci>=?:                     Unicode (UCS-2) Strings.
* ucs2-string-ci>?:                      Unicode (UCS-2) Strings.
* ucs2-string-copy:                      Unicode (UCS-2) Strings.
* ucs2-string-downcase:                  Unicode (UCS-2) Strings.
* ucs2-string-downcase!:                 Unicode (UCS-2) Strings.
* ucs2-string-fill!:                     Unicode (UCS-2) Strings.
* ucs2-string-length:                    Unicode (UCS-2) Strings.
* ucs2-string-ref:                       Unicode (UCS-2) Strings.
* ucs2-string-set!:                      Unicode (UCS-2) Strings.
* ucs2-string-upcase:                    Unicode (UCS-2) Strings.
* ucs2-string-upcase!:                   Unicode (UCS-2) Strings.
* ucs2-string<=?:                        Unicode (UCS-2) Strings.
* ucs2-string<?:                         Unicode (UCS-2) Strings.
* ucs2-string=?:                         Unicode (UCS-2) Strings.
* ucs2-string>=?:                        Unicode (UCS-2) Strings.
* ucs2-string>?:                         Unicode (UCS-2) Strings.
* ucs2-string?:                          Unicode (UCS-2) Strings.
* ucs2-upcase:                           UCS-2 Characters.
* ucs2-upper-case?:                      UCS-2 Characters.
* ucs2-whitespace?:                      UCS-2 Characters.
* ucs2<=?:                               UCS-2 Characters.
* ucs2<?:                                UCS-2 Characters.
* ucs2=?:                                UCS-2 Characters.
* ucs2>=?:                               UCS-2 Characters.
* ucs2>?:                                UCS-2 Characters.
* ucs2?:                                 UCS-2 Characters.
* unbufferized socket port:              Socket.
* uncaught-exception-reason:             SRFI-18.
* uncaught-exception?:                   SRFI-18.
* unix-path->list:                       Operating System Interface.
* unspecified:                           Control Features.
* unwind-protect:                        Control Features.
* use:                                   Module Declaration.
* user extensions:                       User Extensions.
* Using C bindings within the interpreter: Using C bindings within the interpreter.
* utf8-string->ucs2-string:              Unicode (UCS-2) Strings.
* values:                                Control Features.
* vector:                                Vectors.
* vector->list:                          Vectors.
* vector-copy:                           Vectors.
* vector-fill!:                          Vectors.
* vector-length:                         Vectors.
* vector-ref:                            Vectors.
* vector-set!:                           Vectors.
* vector?:                               Vectors.
* vectors:                               Vectors.
* void*-null?:                           C null pointers.
* warning:                               Errors and Assertions.
* warning/location:                      Errors and Assertions.
* wide-class:                            Class declaration.
* wide-object?:                          Object library.
* widen!:                                Widening and shrinking.
* widen!:::                              Widening and shrinking.
* Widening and shrinking:                Widening and shrinking.
* with:                                  Module Declaration.
* with-access:                           Creating and accessing objects.
* with-access:::                         Creating and accessing objects.
* with-error-to-file:                    Input and Output.
* with-error-to-port:                    Input and Output.
* with-error-to-string:                  Input and Output.
* with-exception-handler:                SRFI-18.
* with-input-from-file:                  Input and Output.
* with-input-from-port:                  Input and Output.
* with-input-from-procedure:             Input and Output.
* with-input-from-string:                Input and Output.
* with-output-to-file:                   Input and Output.
* with-output-to-port:                   Input and Output.
* with-output-to-string:                 Input and Output.
* write:                                 Input and Output.
* write-char:                            Input and Output.
* write-circle:                          Input and Output.
* zero?:                                 Numbers.

