Go to the Previous section, the Detailed Contents, or the Amiga E Encyclopedia.


Main Index

This index should be used to find detailed information about particular concepts. There is a separate index which deals with the keywords, variables, functions and constants which are part of Amiga E (see E Language Index).

a

  • A4 register
  • A5 register
  • Absolute value
  • Absolute value (floating-point)
  • Abstract class
  • Abstract method
  • Access array outside bounds
  • Accessing array data
  • Accuracy of floating-point numbers
  • Addition
  • Address, Address
  • Address, finding
  • Algebra
  • Alignment
  • Allocating an object
  • Allocating memory
  • Allocation, dynamic memory
  • Allocation, memory
  • Allocation, static memory
  • Allocation, typed memory dynamically
  • Allowable assignment left-hand sides
  • Amiga E author
  • Amiga system module
  • Amiga system objects
  • Analogy, pointers
  • And
  • AND, bit-wise
  • AND-ing flags
  • Apostrophe
  • Append to a list
  • Append to an E-string
  • arg, using
  • Argument
  • Argument parsing
  • Argument, default
  • Array
  • Array and array pointer declaration
  • Array diagram
  • Array pointer, decrementing
  • Array pointer, incrementing
  • Array pointer, next element
  • Array pointer, previous element
  • Array size
  • Array, access outside bounds
  • Array, accessing data
  • Array, first element short-hand
  • Array, initialised
  • Array, pointer
  • Array, procedure parameter
  • ASCII character constant
  • Assembly and E constants
  • Assembly and E variables
  • Assembly and labels
  • Assembly and procedures
  • Assembly and static memory
  • Assembly statements
  • Assembly, calling system functions
  • Assembly, potential problems
  • Assignment expression
  • Assignment versus copying
  • Assignment, allowable left-hand sides
  • Assignment, colon-equals symbol
  • Assignment, Emodules
  • Assignment, multiple
  • Automatic exceptions
  • Automatic exceptions and initialisation
  • Automatic voiding
  • b

  • Background pen, setting colour
  • Backslash
  • Base case
  • Base class
  • Beginner's Guide author
  • Binary constant
  • Binary tree
  • Bit shift left
  • Bit shift right
  • Bit-wise AND and OR
  • Black box
  • Block, conditional
  • Block, IF
  • Block, SELECT
  • Block, SELECT..OF
  • Books, further reading
  • Bounding a value
  • Box drawing
  • Box, black
  • Bracketing expressions
  • Branch
  • Breaking a string over several lines
  • Breaking statements over several lines
  • Bug, finding
  • Built-in constants
  • Built-in functions
  • Built-in functions, floating-point
  • Built-in functions, linked list
  • Built-in functions, list and E-list
  • Built-in functions, string and E-string
  • Built-in variables
  • BUT expression
  • Button click, left
  • Button click, left (wait)
  • Buttons state
  • c

  • Calculating with floating-point numbers
  • Calling a method
  • Calling a procedure, Calling a procedure
  • Calling system functions from Assembly
  • Carriage return
  • Case of characters in identifiers
  • Case, base
  • Case, recursive
  • Ceiling of a floating-point value
  • Changing stdin
  • Changing stdout
  • Changing stdrast
  • Changing the value of a variable
  • Character constant
  • Character, apostrophe
  • Character, backslash
  • Character, carriage return
  • Character, double quote
  • Character, escape
  • Character, linefeed
  • Character, null
  • Character, printing
  • Character, read from a file
  • Character, tab
  • Character, write to file
  • Choice, conditional block
  • Class (OOP)
  • Class hierarchy
  • Class, abstract
  • Class, base
  • Class, derived
  • Class, super
  • Classes and modules
  • Clean-up, program termination
  • Close screen
  • Close window
  • Code fragment
  • Code modules
  • code part of Intuition message
  • Code, reuse
  • Code, style
  • Colour, setting
  • Colour, setting foreground and background pen
  • Command line argument parsing
  • Comment, nested
  • Comments
  • Common logarithm
  • Common problems
  • Common use of pointers
  • Comparison of lists
  • Comparison of strings
  • Comparison operators
  • Compiler, ec
  • Complex memory, deallocate
  • Complex memory, free
  • Complex types
  • Conditional block
  • Constant
  • Constant string
  • Constant, binary
  • Constant, built-in
  • Constant, character
  • Constant, decimal
  • Constant, enumeration
  • Constant, hexadecimal
  • Constant, named
  • Constant, numeric
  • Constant, set
  • Constant, use in Assembly
  • Constructor
  • Constructor, names
  • Control-C testing
  • Controlling program flow
  • Conversion of floating-point numbers
  • Convert an expression to a statement
  • Convert header file to module
  • Convert include file to module
  • Convert pragma file to module
  • Converting floating-point numbers from a string
  • Converting strings to numbers
  • Copy middle part of a string
  • Copy right-hand part of an E-string
  • Copying a list
  • Copying a string
  • Copying versus assignment
  • Cosine function
  • Crash, avoiding stack problems
  • Crash, running out of stack
  • Create gadget
  • Cure for linefeed problem
  • d

  • Data, extracting from a pointer
  • Data, input
  • Data, manipulation
  • Data, named
  • Data, output
  • Data, static
  • Data, storage
  • Data-abstraction
  • Data-hiding
  • Deallocating an object
  • Deallocating complex memory
  • Deallocating memory
  • Deallocation of memory
  • Deallocation, potential problems
  • Decimal constant
  • Decimal number, printing
  • Decision, conditional block
  • Declaration, array and array pointer
  • Declaration, illegal
  • Declaration, initialised
  • Declaration, variable type
  • Declaring a variable
  • Decrementing a variable
  • Decrementing array pointer
  • Default arguments
  • Default type
  • Definition of a procedure with parameters
  • Dereferencing a pointer
  • Derivation (OOP)
  • Derived class
  • Descoping a global variable
  • Destructor
  • Destructor, end
  • Direct type
  • Division
  • Division, 32-bit
  • Double quote
  • Doubly linked list
  • Dragon curve
  • Drawing, box
  • Drawing, line
  • Drawing, text
  • Dynamic (typed) memory allocation
  • Dynamic E-list allocation
  • Dynamic E-string allocation
  • Dynamic memory allocation
  • Dynamic type
  • e

  • E author
  • E-list
  • E-list functions
  • E-list, append
  • E-list, comparison
  • E-list, copying
  • E-list, dynamic allocation
  • E-list, length
  • E-list, maximum length
  • E-list, setting the length
  • E-string
  • E-string functions
  • E-string handling example
  • E-string, append
  • E-string, comparison
  • E-string, copying
  • E-string, dynamic allocation
  • E-string, format text to
  • E-string, length
  • E-string, lowercase
  • E-string, maximum length
  • E-string, middle copy
  • E-string, reading from a file
  • E-string, right-hand copy
  • E-string, set length
  • E-string, trim leading whitespace
  • E-string, uppercase
  • Early termination of a function
  • ec compiler
  • Element selection
  • Element types
  • Elements of a linked list
  • Elements of an array
  • Elements of an object
  • Emodules assignment
  • end destructor
  • End of file
  • Enumeration
  • EOF
  • Error handling
  • Escape character
  • Evaluation of quoted expressions
  • Even number
  • Example module use
  • Examples, altering
  • Examples, tinkering
  • Exception
  • Exception handler in a procedure
  • Exception handling
  • Exception, automatic
  • Exception, raising
  • Exception, raising from a handler
  • Exception, recursive handling
  • Exception, throwing
  • Exception, use of stack
  • Exception, zero
  • Exceptions and initialisation
  • Exclusive or
  • Executing a procedure
  • Execution
  • Execution, jumping to a label
  • Exists a list element
  • EXIT statement
  • Exiting a loop
  • Exponentiation
  • Expression, Expression
  • Expression in parentheses
  • Expression, assignment
  • Expression, bad grouping
  • Expression, bracketing
  • Expression, BUT
  • Expression, conversion to a statement
  • Expression, grouping
  • Expression, IF
  • Expression, quotable
  • Expression, quoted
  • Expression, sequence
  • Expression, side-effects
  • Expression, timing example
  • Expression, voiding
  • Extracting data from a pointer
  • Extracting floating-point numbers from a string
  • Extracting numbers from a string
  • f

  • Factorial function
  • Field formatting
  • Field size
  • Field, left-justify
  • Field, right-justify
  • Field, zero fill
  • File length
  • Filtering a list
  • Find sub-string in a string
  • Finding addresses
  • Finding bugs
  • First element of an array
  • Flag, AND-ing
  • Flag, IDCMP
  • Flag, mouse button
  • Flag, OR-ing
  • Flag, screen resolution
  • Flag, set constant
  • Flag, window
  • Floating-point conversion operator
  • Floating-point functions
  • Floating-point number
  • Floating-point number, extracting from a string
  • Floor of a floating-point value
  • Flow control
  • Following elements in a linked list
  • Font, setting Topaz
  • For all list elements
  • FOR loop
  • Foreground pen, setting colour
  • Format rules
  • Format text to an E-string
  • Forward through a linked list
  • Fragment, code
  • Free stack space
  • Freeing complex memory
  • Freeing memory
  • Function
  • Function, built-in
  • Function, early termination
  • Function, factorial
  • Function, graphics
  • Function, input
  • Function, Intuition support
  • Function, logic
  • Function, maths
  • Function, one-line
  • Function, output
  • Function, recursive
  • Function, return value
  • Function, system support
  • Functions, floating-point
  • Functions, linked list
  • Functions, list and E-list
  • Functions, string and E-string
  • Further reading
  • g

  • Gadget and IDCMP example
  • Gadget, create
  • Gadgets example
  • General loop
  • Global variable
  • Global variable, descoping
  • Graphics example
  • Graphics functions
  • Grouping expressions
  • Grouping, bad
  • Guide author
  • h

  • Handler in a procedure
  • Handler raising an exception
  • Handler, recursive
  • Handling exceptions
  • Head of a linked list
  • Header file, convert to module
  • Hexadecimal constant
  • Hexadecimal number, printing
  • Hierarchy, class
  • Horizontal FOR loop
  • Horizontal function definition
  • Horizontal IF block
  • Horizontal WHILE loop
  • i

  • I/O example
  • I/O example, with handler
  • iaddr part of Intuition message
  • IDCMP and gadget example
  • IDCMP flags
  • IDCMP message, code part
  • IDCMP message, iaddr part
  • IDCMP message, qual part
  • IDCMP message, waiting for
  • Identifier
  • Identifier, case of characters
  • IF block
  • IF block, nested
  • IF block, overlapping conditions
  • IF expression
  • Illegal declaration
  • Include file, convert to module
  • Incrementing a variable
  • Incrementing array pointer
  • Indentation
  • Indirect type
  • Inheritance (OOP)
  • Inheritance, OBJECT..OF
  • Initialisation
  • Initialisation and automatic exceptions
  • Initialisation, general
  • Initialised array
  • Initialised declaration
  • Inlining procedures
  • Input a character
  • Input a string
  • Input functions
  • Input/output example
  • Input/output example, with handler
  • Interface
  • Intuition message flags
  • Intuition message, code part
  • Intuition message, iaddr part
  • Intuition message, qual part
  • Intuition message, waiting for
  • Intuition support functions
  • Iteration
  • j

  • Jumping out of a loop
  • Jumping to a label
  • k

  • Kickstart version
  • l

  • Label
  • Label, use in Assembly
  • Languages
  • Layout rules
  • Leaf
  • Left mouse button click
  • Left mouse button click (wait)
  • Left shift
  • Left-hand side of an assignment, allowable
  • Left-justify field
  • Length (maximum) of an E-list
  • Length (maximum) of an E-string
  • Length of a file
  • Length of a list
  • Length of a string
  • Length of an E-list, setting
  • Length of an E-string
  • Length of an E-string, setting
  • Line drawing
  • Linefeed
  • Linefeed problem
  • Linefeed problem, cure
  • Linefeed, \n
  • Linked list
  • Linked list, doubly
  • Linked list, elements
  • Linked list, following elements
  • Linked list, functions
  • Linked list, head
  • Linked list, linking
  • Linked list, next element
  • Linked list, singly
  • Linking a linked list
  • List
  • List functions
  • List, append
  • List, comparison
  • List, copying
  • List, filtering
  • List, for all elements
  • List, length
  • List, linked
  • List, mapping a quoted expression
  • List, normal
  • List, selecting an element
  • List, tag
  • List, there exists an element
  • List, typed
  • Lists and quoted expressions
  • Local variable
  • Local variable, initialisation
  • Local variable, same names
  • Local variable, self
  • Local variables in a quoted expression
  • Locate sub-string in a string
  • Location, memory, Location, memory
  • Logarithm, common
  • Logarithm, natural
  • Logic
  • Logic functions
  • Logic operators
  • Logic, and
  • Logic, exclusive or
  • Logic, not
  • Logic, or
  • LONG type
  • LONG type, definition
  • Loop
  • LOOP block
  • Loop check, REPEAT..UNTIL
  • Loop check, WHILE
  • Loop termination
  • Loop, EXIT
  • Loop, exiting
  • Loop, FOR
  • Loop, general
  • Loop, LOOP
  • Loop, REPEAT..UNTIL
  • Loop, terminate by jumping to a label
  • Loop, WHILE
  • Lowercase a string
  • m

  • main procedure
  • Making pointers
  • Manipulation, safe
  • Mapping a quoted expression over a list
  • Matching patterns
  • Mathematical operators
  • Maths functions
  • Maximum
  • Maximum length of an E-list
  • Maximum length of an E-string
  • Memory address, Memory address
  • Memory, allocating
  • Memory, allocation
  • Memory, deallocate
  • Memory, deallocate complex
  • Memory, deallocation
  • Memory, dynamic (typed) allocation
  • Memory, dynamic allocation
  • Memory, free
  • Memory, free complex
  • Memory, reading
  • Memory, sharing
  • Memory, static allocation
  • Memory, writing
  • Method (OOP)
  • Method, abstract
  • Method, calling
  • Method, constructor
  • Method, destructor
  • Method, end
  • Method, overriding
  • Method, PROC..OF
  • Method, self local variable
  • Middle copy of a string
  • Minimum
  • Mnemonics, Assembly
  • Module
  • Module, Amiga system
  • Module, code
  • Module, convert from include, header or pragma file
  • Module, example use
  • Module, non-standard
  • Module, using
  • Module, view contents
  • Modules and classes
  • Modulus
  • Mouse button flags
  • Mouse buttons state
  • Mouse click, left button
  • Mouse click, left button (wait)
  • Mouse x-coordinate
  • Mouse y-coordinate
  • Multiple return values
  • Multiple-assignment
  • Multiplication
  • Multiplication, 32-bit
  • Mutual recursion
  • n

  • Named constant
  • Named data
  • Named elements
  • Names of constructors
  • Names of local variables
  • Natural logarithm
  • Nested comment
  • Nested IF blocks
  • Next element of a linked list
  • Node
  • Non-standard module
  • Normal list
  • Normal list, selecting an element
  • Normal string
  • Not
  • Null character
  • Number, even
  • Number, extracting from a string
  • Number, floating-point
  • Number, odd
  • Number, printing
  • Number, printing (simple)
  • Number, quick random
  • Number, random
  • Number, real
  • Number, signed or unsigned
  • Numbered elements of an array
  • Numeric constant
  • o

  • Object
  • Object (OOP)
  • Object element types
  • Object elements, private
  • Object elements, public
  • Object pointer
  • Object selection, use of ++ and -
  • Object, allocation
  • Object, Amiga system
  • Object, deallocation
  • Object, element selection
  • Object, named elements
  • Object, size
  • OBJECT..OF, inheritance
  • Odd number
  • One-line function
  • OOP, class
  • OOP, derivation
  • OOP, inheritance
  • OOP, method
  • OOP, object
  • Open screen
  • Open window
  • Operator precedence
  • Operator, SUPER
  • Operators, comparison
  • Operators, logic
  • Operators, mathematical
  • Option, set constant
  • Optional return values
  • Or
  • OR, bit-wise
  • Or, exclusive
  • OR-ing flags
  • Output a character
  • Output functions
  • Output text
  • Output window
  • Overlapping conditions
  • Overriding methods
  • p

  • Pad byte
  • Parameter
  • Parameter variable
  • Parameter, default
  • Parameter, procedure local variables
  • Parentheses and expressions
  • Parsing command line arguments
  • Pattern matching
  • Peeking memory
  • Pen colour, setting
  • Pen, setting foreground and background colour
  • Place-holder, decimal `\d'
  • Place-holder, field formatting
  • Place-holder, field size
  • Place-holders
  • Plot a point
  • Point, plot
  • Pointer
  • Pointer (array) and array declaration
  • Pointer analogy
  • Pointer diagram
  • Pointer type
  • Pointer, array
  • Pointer, common use
  • Pointer, dereference
  • Pointer, making
  • Pointer, object
  • Pointer, sharing memory
  • Poking memory
  • Polymorphism
  • Potential problems using Assembly
  • Pragma file, convert to module
  • Precedence, operators
  • Printing characters
  • Printing decimal numbers
  • Printing hexadecimal numbers
  • Printing numbers
  • Printing strings
  • Printing text
  • Printing to an E-string
  • Private, object elements
  • Problems, common
  • PROC..OF, method
  • Procedure
  • Procedure argument
  • Procedure parameter
  • Procedure parameter local variables
  • Procedure parameter types
  • Procedure parameter variable
  • Procedure parameter, array
  • Procedure parameter, default
  • Procedure with parameters, definition
  • Procedure, calling, Procedure, calling
  • Procedure, definition
  • Procedure, early termination
  • Procedure, exception handler
  • Procedure, execution
  • Procedure, inlining
  • Procedure, recent
  • Procedure, return value
  • Procedure, reuse
  • Procedure, running, Procedure, running
  • Procedure, style
  • Procedure, use in Assembly
  • Program flow control
  • Program termination
  • Program, finish
  • Program, running
  • Program, start
  • Pseudo-random number
  • Public, object elements
  • q

  • qual part of Intuition message
  • Quick random number
  • Quotable expressions
  • Quoted expression
  • Quoted expression, evaluation
  • Quoted expression, for all list elements
  • Quoted expression, local variables
  • Quoted expression, mapping over a list
  • Quoted expression, there exists a list element
  • Quoted expressions and lists
  • r

  • Raising an exception
  • Raising an exception from a handler
  • Raising to a power
  • Random number
  • Random number, quick
  • Range of floating-point numbers
  • ReadArgs, using
  • Reading a character from a file
  • Reading a string from a file
  • Reading from memory
  • Reading, further
  • Real number
  • Recent procedure
  • Recursion
  • Recursion example
  • Recursion, mutual
  • Recursive case
  • Recursive exception handling
  • Recursive function
  • Recursive type
  • Registers, A4 and A5
  • Regular return value
  • Remainder
  • REPEAT..UNTIL loop
  • REPEAT..UNTIL loop check
  • REPEAT..UNTIL loop version of a FOR loop
  • Repeated execution
  • Resolution flags
  • Return value of a function
  • Return value, optional
  • Return value, regular
  • Return values, multiple
  • Reusing code
  • Reusing procedures
  • Revision, Kickstart
  • Rewriting a FOR loop as a REPEAT..UNTIL loop
  • Rewriting a FOR loop as a WHILE loop
  • Rewriting SELECT block as IF block
  • Rewriting SELECT..OF block as IF block
  • Right shift
  • Right-hand copy of an E-string
  • Right-justify field
  • Root
  • Rounding a floating-point value
  • Rules, format and layout
  • Running a method
  • Running a procedure
  • Running a program
  • s

  • Safe manipulation
  • Same names of local variables
  • Screen example, with handler
  • Screen example, without handler
  • Screen resolution flags
  • Screen, close
  • Screen, open
  • Seed of a random sequence
  • SELECT block
  • SELECT block, rewriting as IF block
  • SELECT..OF block
  • SELECT..OF block, rewriting as IF block
  • SELECT..OF block, speed versus size
  • Selecting an element of a normal list
  • Selecting an element of an object
  • Selection, use of ++ and -
  • self, method local variable
  • Separators
  • Sequencing expressions
  • Sequential composition
  • Set
  • Set length of an E-string
  • Setting foreground and background pen colours
  • Setting pen colours
  • Setting stdin
  • Setting stdout
  • Setting stdrast
  • Setting the length of an E-list
  • Setting Topaz font
  • Sharing memory
  • Shift left
  • Shift right
  • Short-hand for first element of an array
  • Show module contents
  • Side-effects
  • Sign of a number
  • Signed and unsigned values
  • Sine function
  • Singly linked list
  • Size of an array
  • Size of an object
  • Size versus speed, SELECT..OF block
  • Spacing
  • Special character sequences
  • Speed versus size, SELECT..OF block
  • Splitting a string over several lines
  • Splitting statements over several lines
  • Square root
  • Stack and crashing
  • Stack and exceptions
  • Stack space, free
  • Stack, avoiding crashes
  • State of mouse buttons
  • Statement
  • Statement, Assembly
  • Statement, breaking
  • Statement, conversion from an expression
  • Statement, several on one line
  • Statement, splitting
  • Static data
  • Static data, potential problems
  • Static memory allocation
  • Static memory, use in Assembly
  • stdin, setting
  • stdout, setting
  • stdrast, setting
  • String, String
  • String diagram
  • String functions
  • String handling example
  • String handling example, with handler
  • STRING type
  • String, append
  • String, breaking
  • String, comparison
  • String, constant
  • String, converting to floating-point number
  • String, converting to numbers
  • String, copying
  • String, find sub-string
  • String, length
  • String, lowercase
  • String, middle copy
  • String, printing
  • String, right-hand copy
  • String, special character sequence
  • String, splitting
  • String, trim leading whitespace
  • String, uppercase
  • Structure
  • Sub-string location in a string
  • Subtraction
  • Successful, zero exception
  • Summary of Part One
  • Super class
  • SUPER, operator
  • System function, calling from Assembly
  • System module
  • System objects
  • System support functions
  • System variables
  • t

  • Tab character
  • Table of data
  • Tag list
  • Tail of a linked list
  • Tangent function
  • Terminating loops
  • Termination, program
  • Test for control-C
  • Test for even number
  • Test for odd number
  • Text drawing
  • Text, printing
  • There exists a list element
  • Throwing an exception
  • Timing expressions example
  • Tinkering
  • Topaz, setting font
  • Tree, binary
  • Tree, branch
  • Tree, leaf
  • Tree, node
  • Tree, root
  • Trigonometry functions
  • Trim leading whitespace from a string
  • Trouble-shooting
  • Truth values as numbers
  • Turn an expression into a statement
  • Type
  • Type of a variable
  • Type, 16-bit
  • Type, 32-bit
  • Type, 8-bit
  • Type, address
  • Type, array
  • Type, complex
  • Type, default
  • Type, direct
  • Type, dynamic
  • Type, E-list
  • Type, indirect
  • Type, list
  • Type, LONG
  • Type, LONG (definition)
  • Type, object
  • Type, object elements
  • Type, pointer
  • Type, procedure parameters
  • Type, recursive
  • Type, STRING
  • Type, variable declaration
  • Typed list
  • u

  • Unification
  • Unsigned and signed values
  • Uppercase a string
  • Using a module
  • Using arg
  • Using modules, example
  • Using ReadArgs
  • Using wbmessage
  • v

  • van Oortmerssen, Wouter
  • Variable
  • Variable initialisation and automatic exceptions
  • Variable type
  • Variable, built-in
  • Variable, changing value
  • Variable, declaration
  • Variable, decrement
  • Variable, global
  • Variable, increment
  • Variable, initialisation
  • Variable, local
  • Variable, procedure parameter
  • Variable, same global and local names
  • Variable, same local names
  • Variable, system
  • Variable, type
  • Variable, use in Assembly statements
  • Version, Kickstart
  • Vertical FOR loop
  • Vertical IF block
  • Vertical WHILE loop
  • View module contents
  • Voiding an expression
  • Voiding, automatic
  • w

  • Wait for left mouse button click
  • Waiting for Intuition messages
  • wbmessage, using
  • WHILE loop
  • WHILE loop check
  • WHILE loop version of a FOR loop
  • Whitespace
  • Whitespace, trim from a string
  • Window flags
  • Window, close
  • Window, open
  • Window, output
  • Wouter van Oortmerssen
  • Writing a character to file
  • Writing to memory
  • x

  • X-coordinate, mouse
  • y

  • Y-coordinate, mouse
  • z

  • Zero exception (success)
  • Zero fill field

  • Go to the Previous section, the Detailed Contents, or the Amiga E Encyclopedia.