25. Bigloo -- Global Index

Browsing

Home: | Bigloo A ``practical Scheme compiler'' User manual for version 2.6b December 2003
Previous chapter: | Bigloo Development Environment
Next chapter: | Library Index

Chapters

| Acknowledgements
1. | Table of contents
2. | Overview of Bigloo
3. | Modules
4. | Core Language
5. | Standard Library
6. | Pattern Matching
7. | Object System
8. | Threads
9. | Regular parsing
10. | Lalr(1) parsing
11. | Errors and Assertions
12. | Eval and code interpretation
13. | Macro expansion
14. | Command Line Parsing
15. | Explicit typing
16. | The C interface
17. | The Java interface
18. | Bigloo Libraries
19. | Extending the Runtime System
20. | SRFIs
21. | DSSSL support
22. | Compiler description
23. | User Extensions
24. | Bigloo Development Environment
25. | Global Index
26. | Library Index
| Bibliography

#, *, +, -, ., /, <, =, >, @, A, B, C, D, E, F, G, I, J, L, M, N, O, P, R, S, T, U, W, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, z
#

    #! Unix shell interpreter

*

    *
    *about-to-read*
    *auto-mode*
    *bigloo-strict-r5rs-strings*
    *debug-parser*
    *dynamic-load-path*
    *extend-entry*
    *fl
    *fx
    *load-path*
       ...*load-path*
    *pp-case*
    *pp-width*
    *second
    *user-pass*
    *warning*

+

    +
    +fl
    +fx
    +second

-

    -
    -fl
    -fx
    -second

.

    .afile
    .afile
    .bigloorc
    .jfile

/

    /
    /fl
    /fx

<

    <
    <=
    <=fl
    <=fx
    <=second
    <fl
    <fx
    <second

=

    =
    =fl
    =fx
    =second

>

    >
    >=
    >=fl
    >=fx
    >=second
    >fl
    >fx
    >second

@

    @

A

    A complete library example
    A new way of reading
    Acknowledgements
    Automatic Java clauses generation

B

    Booleans
    Building a library

C

    C arrays
    C atomic types
    C enum
    C functions
    C interface
    C null pointers
    C opaque
    C pointers
    C requirement
    C structure and union types
    Calendar
    Class declaration
    Compiler description
    Compiling
    Compiling with the JVM back-end
    Connecting Scheme and Java code
    Creating and accessing objects
    Custom types

D

    DSSSL formal argument lists
    DSSSL support
    Date
    Debugging Lalr Grammars
    Declaring Java arrays
    Declaring Java classes
    Declaring abstract Java classes
    Definitions

E

    Efficiency
    Embedded Bigloo applications
    Entering the Bee
    Equality
    Equivalence predicates
    Eval and the foreign interface
    Eval command line options
    Eval standard functions
    Expansing
    Exporting Scheme variables to Java
    Expressions

F

    Fair Threads

G

    Generic functions
    Genericity of arithmetic procedures

I

    IP number
       ...IP number
    Importing and Exporting
    Interpreting
    Introspection

J

    JVM requirement
    Java interface

L

    Lalr grammar and Regular grammar
    Lalr parsing
    Lalr precedence and associativity
    Library and SRFI
    Library and inline functions
    Library and modules
    Limitation of the JVM back-end

M

    Module body language
    Modules and DSSSL formal argument lists
    Multi-line comments
    Multi-line comments

N

    Name mangling
    Numbers

O

    Object
    Object System
    Object library
    Object serialization
    Overview of Bigloo

P

    Pairs and lists
    Performance of the JVM back-end
    Process support
    Program Structure

R

    Read Eval Print Loop customized
    Regular expressions
    Regular parsing

S

    SRFI
    SRFI-0:bigloo-c
    SRFI-0:bigloo-jvm
    SRFI-1
       ...SRFI-1
       ...SRFI-1
       ...SRFI-1
       ...SRFI-1
    SRFI-18
    SRFI-2
    SRFI-22
    SRFI-28
    SRFI-30
    SRFI-6
       ...SRFI-6
    SRFI-8
    SRFI-9
    Serialization
    Socket support
    Stack allocation
    Strings
    Syntax
    System programming

T

    The compiler environment and options
    The runtime-command file
    The syntax of the foreign declarations
    The syntax of the regular parser
    The very dangerous ``pragma'' Bigloo special form
    Threads
    Time
    Typed identifier

U

    UCS-2 characters
    UCS-2 strings
    Using C bindings within the interpreter

W

    Widening and shrinking

a

    a simple example of Lalr(1) parsing
    abandoned-mutex-exception?
    abs
    abstract-class
    acos
    afile
    and
    and-let*
    any
    any?
    append
    append!
    append-output-binary-file
    append-output-file
    apply
    args-parse
    args-parse-usage
    arguments parsing
    asin
    assert
    assertions
    assoc
    assq
    assv
    asynchronous data transfer
    asynchronous input
    asynchronous output
    asynchronous process termination
    asynchronous sleep
    asynchronous socket connect
       ...asynchronous socket connect
    atan
    automatic extern clauses generation

b

    basename
    begin
    bigloo development environment
    bigloo-class-demangle
    bigloo-class-mangled?
    bigloo-demangle
    bigloo-mangle
    bigloo-mangled?
    bigloo-module-mangle
    bigloo-need-mangling
    bigloo.foreign.must_exitp
    binary-port?
    bind-exit
    bit manipulation
    bit-and
    bit-lsh
    bit-not
    bit-or
    bit-rsh
    bit-xor
    blit-string!
    boolean?
    broadcast!
    building a makefile

c

    caar
    cadr
    call
    call-with-input-file
    call-with-output-file
    call-with-values
    call-with-values
    call/cc
    call/cc
    car
    case
    cdddar
    cddddr
    cdr
    ceiling
    char->integer
    char->ucs2
    char-alphabetic?
    char-ci<=?
    char-ci<?
    char-ci=?
    char-ci>=?
    char-ci>?
    char-downcase
    char-lower-case?
    char-numeric?
    char-ready?
    char-ready? and run-process
    char-upcase
    char-upper-case?
    char-whitespace?
    char<=?
    char<?
    char=?
    char>=?
    char>?
    char?
    characters
    chdir
    chmod
    cigloo
    class
    class-all-fields
    class-creator
    class-field-accessor
    class-field-indexed?
    class-field-info
    class-field-len-accessor
    class-field-mutable?
    class-field-mutator
    class-field-name
    class-field?
    class-fields
    class-name
    class-subclasses
    class-super
    class?
    client-server
    close-binary-port
    close-input-port
    close-output-port
    close-process-ports
    co-instantiate
    cobj
    command line parsing
    command-line
    comments
    compiler JVM options
    compiler options
    compiling and linking with a library
    complex?
    cond
    cond-expand
    condition-variable-broadcast!
    condition-variable-name
    condition-variable-signal!
    condition-variable-specific!
    condition-variable-specific-set!
    condition-variable?
    cons*
    control features
    cooperative process
    copy-vector
    cos
    current-date
    current-error-port
    current-exception-handler
    current-input-port
    current-output-port
    current-printer
    current-scheduler
    current-seconds
    current-thread
    current-time

d

    date
    date->seconds
    date->string
    date->utc-string
    date-copy
    date-day
    date-hour
    date-is-dst
    date-minute
    date-month
    date-second
    date-timezone
    date-wday
    date-yday
    date-year
    date?
    day-aname
    day-name
    day-seconds
    debugging
    default-repl-error-notifier
    define
    define-expander
    define-generic
    define-inline
    define-macro
    define-method
    define-record-type
    define-struct
    define-syntax
    defining an extern type
    delay
    delete
    delete!
    delete-directory
    delete-file
    directives
    directory->list
    directory?
    dirname
    display
    display*
    display-circle
    do
    duplicate
    duplicate::
    dynamic-load
    dynamic-wind

e

    elong->flonum
    elong->string
    elong?
    eof-object?
    eq?
    equal?
    eqv?
    error
    error handling
    error/location
    eval
    even?
    every
    every?
    exact fixnum
    exact->inexact
    exact?
    examples of regular grammar
    executable-name
    exit
    exp
    expand
    expand-once
    expansion passing style
    explicit typing
    export
    exporting a Scheme variable
    expt
    extern

f

    fair-read/rp
    file handling
    file-exists?
    file-modification-time
    file-separator
    file-size
    filter
    filter!
    final-class
    find-class-field
    find-file/path
    fixnum
    fixnum (long)
    fixnum->flonum
    fixnum?
    flonum
    flonum->elong
    flonum->fixnum
    flonum->llong
    flonum?
    floor
    flush-output-port
    for-each
    for-each-hash
    force
    format
    fprint
    fprintf
    from

g

    gcd
    gensym
    get-hash
    get-output-string
    get-procedure-serialization
    get-process-serialization
    get-prompter
    get-repl-error-notifier::procedure
    get-signal-handler
    get-write-length
    getenv
    getprop

h

    hardware fixnum
    hash tables
       ...hash tables
    hash-table-nb-entry
    hash-table?
    hashtable->list
    hashtable->vector
    hashtable-for-each
    hashtable-get
    hashtable-put!
    hashtable-remove!
    hashtable-size
    hashtable-update!
    hashtable?
    hostname

i

    if
    ignore
    import
    importing an extern function
    importing an extern variable
    include
    including an extern file
    inexact->exact
    inexact?
    inline procedure
    input and output
    input-char
    input-obj
    input-port-name
    input-port-position
    input-port-reopen!
    input-port?
    input-string-port?
    installing the bee
    instantiate
    instantiate::
    int->0..255
    int->0..2^x-1
    integer->char
    integer->second
    integer->string
    integer->ucs2
    integer?
    interaction-environment
    iota
    is-a?

j

    java
    jfile
    jigloo
    join-timeout-exception?

k

    keyword->string
    keyword?
    keywords

l

    labels
    lalr(1) grammar definition
    lalr-grammar
    lambda
    last-pair
    lcm
    leap-year?
    length
    let
    let*
    let-syntax
    letrec
    letrec-syntax
    libraries
    library
    library and repl
    linking
    list
    list->string
    list->ucs2-string
    list->vector
    list-ref
    list-tabulate
    list-tail
    list?
    literate programming
    llong->flonum
    llong->string
    llong?
    load
    loada
    loadq
    log
    long fixnum

m

    macro expansion
    main
    make-accept-signal
    make-client-socket
    make-condition-variable
    make-connect-signal
    make-date
    make-directories
    make-directory
    make-elong
    make-file-name
    make-file-path
    make-hash-table
    make-hashtable
    make-input-signal
    make-list
    make-mutex
    make-output-signal
    make-process-signal
    make-scheduler
    make-send-chars-signal
    make-server-socket
    make-shared-library-name
    make-sleep-signal
    make-static-library-name
    make-string
    make-thread
    make-ucs2-string
    make-vector
    map
    match-case
    match-lambda
    max
    member
    memq
    memv
    min
    module
    module access file
    module declaration
    module export-all
    module export-exports
    module export-module
    modules
    modulo
    month-aname
    month-name
    multiple-value-bind
    mutex-lock!
    mutex-name
    mutex-specific
    mutex-specific-set!
    mutex-state
    mutex-unlock!
    mutex?

n

    native-printer
    native-repl-printer
    negative?
    negfl
    negfx
    newline
    not
    notify-error
    null-environment
    null?
    number->string
    number?

o

    obj
    obj->0..255
    obj->0..2^x-1
    obj->string
    object dumping
    object->struct
    object-class
    object-constructor
    object-display
    object-equal?
    object-hashnumber
    object-write
    odd?
    on-line documentation
    open-input-binary-file
    open-input-c-string
    open-input-file
    open-input-procedure
    open-input-string
    open-output-binary-file
    open-output-file
    open-output-string
    operating system interface
    operator
    option
    or
    os-arch
    os-class
    os-name
    os-tmp
    os-version
    output-char
    output-obj
    output-port-position
    output-port?
    output-string-port?

p

    pair-nil
    pair-or-null?
    pair?
    path-separator
    pattern matching
    peek-char
    port?
    positive?
    pp
    pragma::
    prefix
    pregexp
    pregexp-match
    pregexp-match-positions
    pregexp-replace
    pregexp-replace*
    pregexp-split
    pretty printing
    print
    printf
    procedure call
    procedure?
    process
    process-alive?
    process-continue
    process-error-port
    process-exit-status
    process-input-port
    process-kill
    process-list
    process-output-port
    process-pid
    process-send-signal
    process-stop
    process-wait
    process?
    profiling
    put-hash!
    putenv
    putprop!
    pwd

q

    qualified notation
    quasiquote
    quit
    quotation
    quote
    quotient

r

    raise
    rational?
    read
    read eval print loop
    read-case-insensitive
    read-case-sensitive
    read-char
    read-chars
    read-fill-string!
    read-line
    read-lines
    read-of-strings
    read-string
    read/case
    read/lalrp
    read/rp
    reading path
    real->string
    real?
    receive
    records
    regexp-quote
    register-eval-srfi!
    register-exit-function!
    register-procedure-serialization
    register-process-serialization
    regular-grammar
    rem-key-hash!
    rem-obj-hash!
    remainder
    remprop!
    remq
    remq!
    rename-file
    repl
    reverse
    reverse!
    revised(5) macro expansion
    revision control
    rgc-context
    round
    run-process
    run-process and char-ready?
    run-process and input/output

s

    safety
    scheduler-broadcast!
    scheduler-instant
    scheduler-react!
    scheduler-start!
    scheduler-terminate!
    scheduler?
    scheme-report-environment
    searching for source code
    seconds->date
    seconds->string
    seconds->utc-string
    select (à la unix)
    send-chars
    set!
    set-car!
    set-cdr!
    set-input-port-position!
    set-output-port-position!
    set-printer!
    set-prompter!
    set-repl-error-notifier!
    set-repl-printer!
    set-write-length!
    shrink!
    signal
    sin
    sleep
    socket-accept
    socket-accept-connection
    socket-client?
    socket-close
    socket-down?
    socket-dup
    socket-host-address
    socket-hostname
    socket-input
    socket-local-address
    socket-output
    socket-port-number
    socket-server?
    socket-shutdown
    socket?
    sort
    sqrt
    srfi-0
    srfi-0: library
    srfi-0:bigloo
    static
    string
    string->0..255
    string->0..2^x-1
    string->elong
    string->integer
    string->keyword
    string->list
    string->llong
    string->number
    string->obj
    string->real
    string->symbol
    string->symbol-ci
    string-append
    string-capitalize
    string-capitalize!
    string-case
    string-ci<=?
    string-ci<?
    string-ci=?
    string-ci>=?
    string-ci>?
    string-compare3
    string-compare3-ci
    string-copy
    string-downcase
    string-downcase!
    string-fill!
    string-for-read
    string-length
    string-ptr-null?
    string-ref
    string-set!
    string-shrink!
    string-upcase
    string-upcase!
    string<=?
    string<?
    string=?
    string>=?
    string>?
    string?
    struct->object
    struct?
    structures
    substring
    substring=?
    subucs2-string
    suffix
    symbol->string
    symbol-append
    symbol-plist
    symbol?
    symbols
    syntax-rules
    system
    system->string

t

    tan
    terminated-thread-exception?
    the bee root directory
    the interpreter
    the lalr(1) parsing function
    the pattern language
    the semantics actions
    the-character
    the-context
    the-failure
    the-fixnum
    the-flonum
    the-keyword
    the-length
    the-port
    the-string
    the-substring
    the-symbol
    thread-await!
    thread-await*!
    thread-await-values!
    thread-await-values*!
    thread-cleanup
    thread-cleanup-set!
    thread-get-values!
    thread-get-values*!
    thread-join!
    thread-name
    thread-resume!
    thread-sleep!
    thread-specific
    thread-specific-set!
    thread-start!
    thread-suspend!
    thread-terminate!
    thread-yield!
    thread?
    time->seconds
    time?
    transcript-off
    transcript-on
    truncate
    try
    type

u

    ucs2->char
    ucs2->integer
    ucs2-alphabetic?
    ucs2-ci<=?
    ucs2-ci<?
    ucs2-ci=?
    ucs2-ci>=?
    ucs2-ci>?
    ucs2-downcase
    ucs2-lower-case?
    ucs2-numeric?
    ucs2-string
    ucs2-string->list
    ucs2-string->utf8-string
    ucs2-string-append
    ucs2-string-ci<=?
    ucs2-string-ci<?
    ucs2-string-ci=?
    ucs2-string-ci>=?
    ucs2-string-ci>?
    ucs2-string-copy
    ucs2-string-downcase
    ucs2-string-downcase!
    ucs2-string-fill!
    ucs2-string-length
    ucs2-string-ref
    ucs2-string-set!
    ucs2-string-upcase
    ucs2-string-upcase!
    ucs2-string<=?
    ucs2-string<?
    ucs2-string=?
    ucs2-string>=?
    ucs2-string>?
    ucs2-string?
    ucs2-upcase
    ucs2-upper-case?
    ucs2-whitespace?
    ucs2<=?
    ucs2<?
    ucs2=?
    ucs2>=?
    ucs2>?
    ucs2?
    unbufferized socket port
    uncaught-exception-reason
    uncaught-exception?
    unix-path->list
    unspecified
    unwind-protect
    use
    user extensions
    utf8-string->ucs2-string

v

    values
    vector
    vector->list
    vector-copy
    vector-fill!
    vector-length
    vector-ref
    vector-set!
    vector?
    vectors
    void*-null?

w

    warning
    warning/location
    wide-class
    wide-object?
    widen!
    widen!::
    with
    with-access
    with-access::
    with-error-to-file
    with-error-to-port
    with-error-to-string
    with-exception-handler
    with-input-from-file
    with-input-from-port
    with-input-from-procedure
    with-input-from-string
    with-output-to-file
    with-output-to-port
    with-output-to-string
    write
    write-char
    write-circle

z

    zero?

This Scribe page has been generated by `scribeinfo`.
Last update Tue Dec 16 13:46:41 2003