--- /dev/null
+body{
+ color: #000000;
+ background: #ffffff;
+ font: 9pt helvetica;
+}
+body.navbar{
+ color: #000000;
+ background: #ffffff;
+ font: 10pt helvetica;
+ padding: 2px;
+}
+h1{
+ font: 14pt helvetica;
+ font-weight: bold;
+}
+h2{
+ font: 12pt helvetica;
+ font-weight: bold;
+}
+h3{
+ font: 10pt helvetica;
+ font-weight: bold;
+}
+table{
+ background: #ffffff;
+ font: 10pt helvetica;
+}
+th{
+ padding: 4px;
+ background: #ccddee;
+ border-bottom: 1px solid #bbccdd;
+ text-align: left;
+}
+td{
+ padding: 4px;
+ background: #ddeeff;
+ border-bottom: 1px solid #ccddee;
+}
+td.blank{
+ padding: 0px;
+ background: #ffffff;
+ border: none;
+}
+td.small{
+ padding: 2px;
+ background: #ddeeff;
+ border-bottom: 1px solid #ccddee;
+ font: 8pt helvetica;
+}
+td.doctop{
+ padding: 10px;
+ background: #ccddee;
+ border-bottom: 1px solid #bbccdd;
+ font: 10pt helvetica;
+ vertical-align: text-top;
+ font-weight: bold;
+}
+td.docleft{
+ padding: 10px;
+ background: #ccddee;
+ border-bottom: 1px solid #bbccdd;
+ font: 8pt helvetica;
+ vertical-align: text-top;
+ width: 10%;
+}
+td.docright{
+ padding:10px;
+ background: #ddeeff;
+ border-bottom: 1px solid #ccddee;
+ font: 10pt helvetica;
+ vertical-align: text-top;
+ width: 90%;
+}
+pre{
+ font: 10pt courier;
+ background: #eef8ff;
+ padding: 8px;
+}
+font.token{
+ font-weight: bold;
+}
+font.syntax{
+ color: #005555;
+}
+div.ref{
+ border: 1px solid #000000;
+}
+div.indent{
+ padding-left: 8px;
+}
+div.syntax{
+ color: #005555;
+ padding: 8px;
+}
+a{
+ color: #000088;
+ font: 10pt helvetica;
+ text-decoration: underline;
+}
+a.navbig{
+ color: #000088;
+ font: 9pt helvetica;
+ text-decoration: none;
+}
+a.navsmall{
+ color: #000088;
+ font: 8pt helvetica;
+ text-decoration: none;
+}
+a:hover{
+ color: #000088;
+}
+a.small{
+ color: #000088;
+ font: 8pt helvetica;
+}
+a.token{
+ color: #000088;
+ text-decoration: underline;
+}
+a.null{
+ text-decoration: none;
+}
+div.entries{
+ display: none;
+}
--- /dev/null
+
++Interfacing with C and other languages
+
+You can use the #Import command to add certain non-BlitzMax source files to your projects, and the #Extern command to make the functions in those files available to BlitzMax applications.
+
+The currently supported non-BlitzMax source file types are: .c (C); .cpp (C++); .cxx (C++); .m (ObjectiveC); and .s (Assembler).
+
+BlitzMax will use the GNU compiler tools to compile C, C++ and ObjectiveC files, and either the 'fasm' assembler for x86 assembly or GNU assembler for PowerPC assembly.
+
+Here is a simple example of importing C source code into your project and accessing a C function:
+{{
+//----- file: c_funcs.c -----
+int Doubler( int x ){
+ return x+x;
+}
+
+'----- file: app.bmx -----
+Import "c_funcs.c"
+
+Extern
+ Function Doubler( x )
+End Extern
+
+Print Doubler(10)
+}}
+
+You can also use #Import to add a C compiler 'include' directory. To do this, use an import path that ends in "*.h", for example:
+{{
+Import "include/*.h"
+}}
+
+#Extern can also be used to work with C++ style objects from within BlitzMax. To do this, simply place a user-defined type declaration within an extern block. For example:
+{{
+//----- file: mytype.cpp -----
+#include <stdio.h>
+
+class MyType{
+public:
+ virtual ~MyType(){}
+ virtual void Test(){ printf( "Hello World!\n" ); }
+};
+
+extern "C"{
+
+MyType *CreateMyType(){
+ return new MyType;
+}
+
+void DestroyMyType( MyType *t ){
+ delete t;
+}
+
+'----- File: app.bmx -----
+Import "mytype.cpp"
+
+Extern
+
+Type TMyType
+ Method _pad1() 'padding for virtual destructors
+ method _pad2()
+ Method Test()
+End Type
+
+Function CreateMyType:TMyType()
+Function DestroyMyType( t:TMyType )
+
+End Extern
+
+Local t:TMyType=CreateMyType()
+t.Test
+DestroyMyType t
+}}
+
+Note that there are several limits on the use of extern types:
+[
+* Methods declared in an extern type must be declared @virtual in the C++ class.
+* Objects of extern type cannot be created with #New. Instead, such objects must be created by an extern function.
+* Extern types can extend other extern types, but can not extend standard BlitzMax types. Similarly, BlitzMax types can not extend extern types.
+* Objects of extern type cannot be cast to 'Object'.
+]
--- /dev/null
+
++Memory management issues
+
+BlitzMax currently uses an optimized form of reference counting to implement memory management.
+
+However, there is one situation where you need to be a bit careful about memory management and that is when you are dealing with %{cyclic data structures}.
+
+A cyclic data structure is a data structure (in BlitzMax, a user defined type) that can potentially 'point to itself'. The most extreme example of a cyclic data structure is something like:
+{{
+Type TCyclic
+ Field cycle:TCyclic=Self
+End Type
+
+For k=1 To 10
+ Local cyclic:TCyclic=New TCyclic
+ GCCollect
+ Print GCMemAlloced()
+Next
+}}
+If you run this program, you will notice that memory is slowly leaking. This is happening because the reference count for each TCyclic object never reaches 0, thanks to the objects 'cyclic' field.
+
+It is therefore necessary to ensure such cyclic data structures are cleanly handled. This can be achieved by adding a method to 'unlink' any such cycles. For example:
+{{
+Type TCyclic
+ Field cycle:TCyclic=Self
+
+ Method Remove()
+ cycle=Null
+ End Method
+
+End Type
+
+For k=1 To 10
+ Local cyclic:TCyclic=New TCyclic
+ GCCollect
+ Print GCMemAlloced()
+ cyclic.Remove
+Next
+}}
+
+In real world use this problem seldom arises, and when it does it's typically when designing container types.
+
+If you are at all worried about this, you can easily track memory usage with the GCMemAlloced() function from the BlitzMax runtime library.
--- /dev/null
+
++Pointers
+
+BlitzMax supports 'C' style pointers for use by code that must perform low level interaction with the operating system and/or speed sensitive code.
+
+Pointers are not recommended for general use, as misuse of pointers can easily result in memory corruption causing all sorts of bugs and headaches!
+
+Pointers may be declared by appending @Ptr to the type of a variable or function declaration. For example:
+{{
+Local int_Ptr:Int Ptr
+}}
+Note the pointers are only supported for the primitive numeric types: Byte, Short, Int, Long, Float and Double.
+
+The #Varptr operator allows you to find the address of a variable, yielding a pointer. For example:
+{{
+Local an_int:Int=10
+Local int_ptr:Int Ptr=Varptr an_int
+}}
+Array style indexing is used to dereference pointers:
+{{
+Local an_int:Int=10
+Local int_ptr:Int Ptr=Varptr an_int
+Print int_ptr[0]
+}}
+BlitzMax will automatically convert any pointer type to a byte pointer for you. In addition, objects and arrays may be assigned to byte pointers. In the case of objects, the pointer will contain the address of the first field of the object. In the case of arrays, the pointer will contain the address of the first element of the array.
+
+Be very careful when assigning objects to pointers, as there is a danger that the garbage collector will 'reclaim' the object before you have finished with the pointer! It is recommended that you use #GCSuspend and #GCResume around code that converts objects to pointers.
+
+You may also explictily cast pointers to and from other pointers, and to and from Int. For example:
+{{
+Local an_int:Int=10
+Local int_ptr:Int Ptr=Varptr an_int
+Local float_ptr:Float Ptr=Float Ptr int_ptr
+Local var_address:Int=Int float_ptr
+}}
+
--- /dev/null
+
++Advanced topics
+
+This section covers some of the trickier topics involved when using BlitzMax.
+
--- /dev/null
+
++Arrays
+
+Arrays are used to store sequences of variables, or %elements. An element within an array is accessed by %indexing the array with an integer offset.
+
+The general syntax for indexing an array is:
+{
+%ArrayExpression @[ %index1 @, %index2 etc... @]
+}
+
++Creating Arrays
+
+The most common way to create an array is when declaring a variable:
+{{
+Local int_array[10]
+}}
+This will initialize the int_array variable with a 10 element array. You can declare an 'empty' array by using []:
+{{
+Local int_array[]
+}}
+An empty array is identical to an array with 0 elements.
+
+Arrays may also be created 'on the fly' using the syntax:
+{
+@New @[ %Dimension1 @, %Dimension2 etc... @]
+}
+This returns an array of the specified dimension(s) with each element initialized to #Null. For example:
+{{
+Local int_array:Int[]
+int_array=New Int[10]
+}}
+'Auto arrays' may be created using the syntax:
+{
+@[ %Element1 @, %Element2 etc... @]
+}
+This returns a 1 dimensional array containing the specified elements, for example:
+{{
+Local int_array[]=[1,2,3,4,5]
+}}
+Each element of an auto array must have exactly the same type. If necessary, you can use type conversions to enforce this.
+
+Arrays also provide the following methods:
+
+[ @Method | @Description
+* Sort( ascending=True ) | Sort the array.
+* Dimensions:Int[]() | Get array dimensions.
+]
+
+Arrays also provide a read-only @length field that returns the total number of elements in the array.
+
+Here are some examples of using array methods:
+{{
+Strict
+
+Local arr:String[]=["some","random","strings","in","a","string","array"]
+
+arr.Sort 'sort ascending
+Print "Array in ascending order..."
+For Local t:String=EachIn arr
+ Print t
+Next
+
+arr.Sort False 'sort descending
+Print "Array in descending order..."
+For Local t:String=EachIn arr
+ Print t
+Next
+
+Local arr2[10,20,30,40]
+
+'Dump array dimensions
+For Local i=EachIn arr2.Dimensions()
+ Print i
+Next
+}}
--- /dev/null
+
++BASIC Compatibility
+
+This section covers some of the differences between BlitzMax and 'classic' BASIC, and introduces features that help overcome some of classic BASIC's shortcomings.
+
++Strict mode
+
+Classic BASIC allows you to declare variables 'on the fly'. For example, consider a program consisting of:
+{{
+For k=1 To 10
+ sum=sum+k
+Next
+Print sum
+}}
+This program automatically creates 2 local variables: 'k' and 'sum'. However, this behaviour can often lead to unexpected bugs. For example, if you mistyped one of the 'sum' variables, the program would not work as expected. No error would be given - a new variable would simply be created.
+
+By default, BlitzMax will allow you to automatically declare variables like this. However, you can use the @Strict command to override this behaviour.
+
+#Strict must appear at the top of your program before any actual program code and puts your program into 'strict mode'. Strict mode forces you to declare all variables before use. For example, rewriting the above program in strict mode results in:
+{{
+Strict
+Local sum,k
+For k=1 To 10
+ sum=sum+k
+Next
+Print sum
+}}
+If you were to mistype one of the variable names in this program, you would receive an 'identifier not found' error when compiling, allowing you to easily find and correct the problem.
+
++Arrays
+
+Blitzmax does not support the Dim statement for array creation. Instead, arrays in BlitzMax are real types - they can be passed to functions, returned from functions and placed in variables.
+
+To create a classic BASIC style array in BlitzMax, use a global variable. For example:
+{{
+Global my_array$[100] 'create a 100 element string array
+}}
+Also note that arrays in BlitzMax are not '1 bigger' than their dimensioned size - the 100 element array above contains 100 elements, numbered 0 through 99 inclusive.
+
+BlitzMax also does not support a 'Redim' operation. Instead, you can use #slices. For example:
+{{
+Global my_array$[100] 'create a 100 element string array
+my_array=my_array[..200] 'now a 200 element array!
+}}
+
++Goto and Gosub
+
+BlitzMax does not support the Gosub command. Use #functions instead.
+
+The Goto command is supported, but only in non-strict mode. Goto labels should be prefixed with a ~# character. For example:
+{{
+For k=1 To 10
+ a=Rand(10)
+ If a<5 Then Goto LessThan5
+ If a>5 Then Goto GreaterThan5
+ Print "a is equal to 5"
+ Goto AllDone
+#LessThan5
+ Print "a is less than 5"
+ Goto AllDone
+#GreaterThan5
+ Print "a is greater than 5"
+#AllDone
+Next
+}}
+
++Data, Read and Restore
+
+Data, Read and Restore are supported but have been renamed to #DefData, #ReadData and #RestoreData. Data labels must also be prefixed with a ~# character.
+
++Object handles
+
+BlitzMax allows objects to be assigned to integer variables, and integer variables to be passed to functions expecting objects. This is mainly for the benefit of beginners, as it reduces the size and complexity of code, but is also great for lazy pro's! For example:
+{{
+Graphics 640,480
+image=LoadImage( "an_image.png" ) 'returned object is converted to an integer handle
+DrawImage image,0,0 'integer image parameter is converted back to an object
+Flip
+WaitKey
+}}
+This is achieved using an %{object handle} system, and such handles should be released using the #Release command when they are no longer needed. For example:
+{{
+Graphics 640,480
+image=LoadImage( "an_image.png" ) 'returned object is converted to an integer handle
+DrawImage image,0,0 'integer image parameter is converted back to an object
+Release image 'image no longer needed - release it
+Flip
+WaitKey
+}}
+Failing to release an object handle will result in memory leaks. However, all objects are released at program exit anyway, so for quick 'n' dirty jobs you don't have to bother.
+
++Type tag shortcuts
+
+When declaring variables and function return types, BlitzMax allows you to use BASIC style 'type tags'. These are as follows:
+
+[ @{Type tag} | @{Equivalent type}
+* ~% | Int
+* ~# | Float
+* ~! | Double
+* ~$ | String
+]
+For example, a string variable can be declared in two ways:
+{{
+Local a_string:String
+Local another_string$
+}}
+Mac users whose keyboards do not feature the ~# character should use 'Alt 3'.
--- /dev/null
+
++Collections
+
+BlitzMax offers simple support for managing %collections of objects, and for visiting each object in a %collections using a special form of For/Next loop.
+
+The simplest kind of collection is an array:
+{{
+Local a[]=[1,2,3,4,5]
+For Local k=EachIn a
+ Print k
+Next
+}}
+Each iteration of such a loop will assign the next array element (starting with element 0) to the index variable before executing the body of the loop. This allows you to 'visit' each array element in turn.
+
+It is also possible to create your own kind of collection with user defined types.
+
+To do this, you must create a user defined type with a method named @ObjectEnumerator which takes no parameters and returns an object. The object returned by this method must itself have the following methods:
+{{
+Method HasNext:Int() 'returns true if there's a next object
+Method NextObject:Object() 'returns the next object
+}}
+You can then use the object in a For/Next loop:
+{{
+Local list:TList=New TList
+list.AddLast "Hello"
+list.AddLast "World!"
+For Local t$=EachIn list
+ Print t
+Next
+}}
--- /dev/null
+
++Comments
+
+Comments are chunks of text in your program code that are ignored by the compiler, but are there to remind you how the code works.
+
+BlitzMax support single line comments using the @' character - for example:
+{{
+Print "Comment Test" 'Everything from the apostrophe (') character to the end of line is ignored.
+}}
+
+Multiline comments are also supported, using @Rem and @{End Rem} - for example:
+{{
+Rem
+Blitzmax rocks!
+An example of a multiline comment...
+Multiline comments are useful for documenting and maintaining your code
+End Rem
+}}
--- /dev/null
+
++Conditional compiling
+
+Conditional compiling allows you to turn compiling on or off from within your program depending on the environment the program is being compiled for.
+
+Conditional compiling works a bit like an @If statement, but takes the form:
+{
+@{?}%Identifier
+}
+
+The @? must appear at the start of a new line, and %Identifier should be one of the following:
+
+[ @Name | @Meaning
+* Debug | True if program is being compiled in debug mode.
+* Threaded | True if program is being compiled in threaded mode.
+* Win32 | True if program is being compiled for the Windows operating system.
+* MacOS | True if program is being compiled for the MacOS operating system.
+* Linux | True if program is being compiled for the Linux operating system.
+* X86 | True if program is being compiled for the Intel CPU.
+* PPC | True if program is being compiled for the PowerPC CPU.
+* MacOSX86 | True if program is being compiled for an Intel Mac.
+* MacOSPPC | True if program is being compiled for a PowerPC Mac.
+* BigEndian | True if program is being compiled for a big endian CPU.
+* LittleEndian | True if program is being compiled for a little endian CPU.
+]
+
+%Identifier may also be preceded by @Not to invert the result.
+
+An @? on its own always turns compiling on.
+
+For example:
+{{
+?Debug
+ 'Any code here is only compiled in debug mode.
+?Not Debug
+ 'Any code here is only compiled in release mode.
+?
+ 'Code here is always compiled.
+}}
--- /dev/null
+
++Constants
+
+Constants can be used to store values that don't change during the execution of your program.
+
+Constants must be declared in your program before use with the #Const command. Declaring a constant means defining a name, type and initial value for it.
+
+The general syntax for declaring a constant is:
+{
+@Const %Identifier @: %Type @= %ConstantExpression
+}
+
+For example:
+{{
+Const STARTUP_SIZE=1000
+Const SCREEN_WIDTH=640,SCREEN_HEIGHT=480
+Const SCREEN_AREA=SCREEN_WIDTH*SCREEN_HEIGHT
+Const SCALE_FACTOR:Float=1.5
+Const DEFAULT_TITLE:String="Mark Sibly"
+}}
+Multiple constants may be declared per <font class=token>Const</font> statement using the comma separator.
+
+If no type is provided for a constant, the constant defaults to being of type #Int.
+
+The initial value for a constant may be an expression, but the expression must itself be constant - it may only use other constants or literals and may not use any variables.
--- /dev/null
+
++Types
+
+All constants, variables, functions and expressions have an associated type. BlitzMax supports the following types:
+
+[ @Description | @Syntax | @{Minimum value} | @{Maximum value}
+* 8 bit unsigned integer | Byte | 0 | 255
+* 16 bit unsigned integer | Short | 0 | 65535
+* 32 bit signed integer | Int | -2^31 | +2^31-1
+* 64 bit signed integer | Long | -2^63 | +2^63-1
+* 32 bit floating point | Float | (+/-)10^-38 | (+/-)10^38
+* 64 bit floating point | Double | (+/-)10^-308 | (+/-)10^308
+* 16 bit unicode string | String | - | -
+* Object | %Typename | - | -
+* Array | %ElementType [ ] | - | -
+* Function | %ReturnType ( %Parameters ) | - | -
+* Pointer | %ValueType Ptr | - | -
+* Variable | %VariableType Var | - | -
+]
+
+Integers are used to store simple numeric data without any fractional part. Unsigned integers can only store positive values, while signed integers can store both positive and negative values.
+
+Floating point values are used to store numeric data which may have a fractional part.
+
+Strings are used to store sequences of characters: letters, punctuation, digits and so on. Use strings for storing non-numeric data such as names.
+
+Arrays are used to store sequences of variables. A variable within an array is accessed by 'indexing' the array with an integer offset. Please refer to the arrays sections for more information on arrays.
+
+Objects are instances of user-defined types. Please refer to the user-defined types section.
+
++Type conversions
+
+The following type conversions are performed automatically by BlitzMax when necessary - for example, when assigning an expression to a variable, or when passing an expression to a function:
+
+[ @{Source type} | @{Target type}
+* Integer | Floating point, String
+* Floating point | Integer, String
+]
+
+You can also convert types explicitly using a %cast operation. This takes the form of a type specifier followed by an expression in brackets.
+
+Explicit casting allows you to perform the following extra conversions:
+
+[ @{Source type} | @{Target type}
+* String | Integer, Floating point
+]
+
+For example:
+{{
+Local n:Int=10
+Local t:String="20"
+Print Int( t )
+Print String( n )
+}}
+
++Type balancing
+
+When performing arithmetic operations such as addition or multiplication, it is possible to provide mismatched argument types. For example, the addition operator may be used to add an integer value to a floating point value. But what type should the result be?
+
+BlitzMax decides the result type by %balancing the argument types. Both arguments are then converted to the result type before the operator is applied.
+
+The rules governing type balancing are:
+
+[ If either argument is @Double, then result is @Double
+* else if either argument is @Float, then result is @Float
+* else if either argument is @Long, then result is @Long
+* else result is @Int
+]
--- /dev/null
+
++Debugging
+
+BlitzMax provides several commands to help with debugging your programs:
+
+[ #DebugStop - In debug mode, causes the program to stop executing and activates the debugger. In release mode, no effect.
+
+* #DebugLog %StringExpression - In debug mode, causes %StringExpression to be printed to the debugger output window. In release mode, no effect.
+
+* #RuntimeError %StringExpression - Causes a runtime error exception (see: #exceptions) to be thrown with the specified string.
+
+* #Assert %Expression @Else %StringExpression - In debug mode, causes a @RuntimeError if %Expression evaluates to false. No effect in release mode.
+]
+
+@Assert is particularly useful for validating function arguments. For example:
+{{
+Function SetAlpha( alpha# )
+ Assert alpha>=0 And alpha<=1 Else "Alpha value out of range"
+ 'rest of function here...
+End Function
+}}
+However, since asserts are taken out in release mode, be careful that your asserts don't have any 'side effects' - code that may affect the execution of the program.
--- /dev/null
+
++Exceptions
+
+BlitzMax provides a mechanism for handling runtime errors known as %{exception handling}
+
+An exception is actually just an object. You can %throw and %catch exceptions using the #Throw command and a #Try / #Catch block. Here is a simple example:
+{{
+Function ExTest()
+ Throw "Bingo!"
+End Function
+
+Try
+ ExTest()
+Catch ex:Object
+ Print ex.ToString()
+End Try
+}}
+Throwing an exception causes the program to jump to the most recent #Catch block. You can provide multiple catch blocks for catching exceptions of different types. If there is no appropriate #Catch block for the exception, then the program jumps to the %next most recent #Catch block. If no catch block can be found to deal with the exception, the program will end.
+
+BlitzMax has several built-in exception types, all of which extend type TBlitzException. These are:
+
+[ @Exception | @Cause
+* TNullMethodException | Thrown when a program attempts to call an abstract method.
+* TNullFunctionException | Thrown when a program attempts to call a null function.
+* TNullObjectException | Thrown when a program attempts to access a null object (only thrown in debug mode).
+* TArrayBoundsException | Thrown when a program attempts to access an array element outside of an array's bounds (only thrown in debug mode).
+* TRuntimeException | Thrown by the #RuntimeError or #Assert commands.
+]
--- /dev/null
+
++Expressions
+
++Operators
+
+BlitzMax supports the following operators. Operators are grouped into levels of precedence, starting with the highest precedence operators:
+
+[ @Operator | @Syntax
+* Sub expression | @( %Expression @)
+* New object | @New %Typename
+* Literal | %Value
+* Identifier | %Value
+* Self object | @Self
+* Super object | @Super
+* Null value | @Null
+* Pi | @Pi
+* True | @True
+* False | @False
+* Minumum | @Min @( %Expression1 @, %Expression2 @)
+* Maximum | @Max @( %Expression1 @, %Expression2 @)
+*
+*
+* Member | %Expression @{.} %Identifier
+* Index | %Expression @[ %IndexExpressions @]
+* Call | %Expression @( %Parameters @)
+*
+*
+* Negate | @- %Expression
+* Posate | @+ %Expression
+* Bitwise complement | @{~~} %Expression
+* Boolean not | @Not %Expression
+* Absolute value | @Abs %Expression
+* Sign | @Sgn %Expression
+* Value byte size | @SizeOf %Expression
+* Variable address | @Varptr %Variable
+* Convert type expression | %Type %Expression
+*
+*
+* Power | %Expression @^ %Expression
+*
+*
+* Multiply | %Expression @* %Expression
+* Divide | %Expression @/ %Expression
+* Remainder | %Expression @Mod %Expression
+* Bitwise shift left | %Expression @Shl %Expression
+* Bitwise shift right | %Expression @Shr %Expression
+* Arithmetic shift right | %Expression @Sar %Expression
+*
+*
+* Add | %Expression @+ %Expression
+* Subtract | %Expression @- %Expression
+*
+*
+* Bitwise and | %Expression @& %Expression
+* Bitwise or | %Expression @| Expression
+* Bitwise exclusive or | %Expression @{~~} %Expression
+*
+*
+* Equal | %Expression @= %Expression
+* Not equal | %Expression @{~<~>} %Expression
+* Less than | %Expression @{~<} %Expression
+* Greater than | %Expression @{~>} %Expression
+* Less than or equal | %Expression @{~<=} %Expression
+* Greater than or equal | %Expression @{~>=} %Expression
+*
+*
+* Conditional and | %Expression @And %Expression
+* Conditional or | %Expression @Or %Expression
+]
+
+In addition, the following built in functions are also supported:
+[ @Function | @Syntax
+* Character code | @Asc @( %Expression @)
+* Character | @Chr @( %Expression @)
+* Value length | @Len @( %Expression @)
+]
+
+#Null returns 0, an empty string, an empty array, the null object or a pointer to 0 depending on context.
+
+#True and #False are integer constants with the values 1 and 0, respectively.
+
+The index operator can be used on either arrays or strings. If used on an array, the element at the specified index is returned. If used on a string, the character code of the character at the specified index is returned.
+
+The #Not operator 'inverts' the logic of a boolean expression. If the expression evaluates to true, #Not returns false and vice versa.
+
+#Asc returns the character value of the first character of a string, or -1 if the length of the string is 0.
+
+#Chr constructs a 1 character string with the specified character value.
+
+#Len can be used with either a string or array. When used with a string, #Len returns the number of characters in the string. When used with an array, #Len returns the number of elements in the array. In the case of multidimensional arrays, #Len returns the total number of elements.
+
++Boolean expressions
+
+It is frequently necessary to consider an expression as 'true' or 'false', for example, for use with an #If statement.
+
+The rules for determining whether an expression is true or false are:
+
+[ @{Expression Type} | @{Truth condition}
+* Numeric | True if value is not equal to 0
+* Object | True if object is not equal to #Null
+* String | True if length is not equal to 0
+* Array | True if length is not equal to 0
+]
--- /dev/null
+
++Functions
+
+A function is a self contained block of code that can be called from multiple points in your program.
+
+Functions are declared using the syntax:
+{
+@Function %Identifier @: %ReturnType @( %Parameters @)\
+ %{Function statements...}\
+@{End Function}
+}
+
+If %ReturnType is omitted, the function defaults to returning an #Int.
+
+%Parameters is a comma separated list of parameters for the function. The syntax of each parameter is similar to a variable declaration: %Identifier @: %Type. Function parameters may be used inside a function in the same way as local variables.
+
+The #Return statement is used to return a value from a function.
+
+Here is an example of a simple function that adds 2 integers and returns their sum:
+{{
+Function AddInts:Int( x:Int,y:Int )
+ Return x+y
+End Function
+}}
+This function can then be called by other code:
+{{
+Print AddInts( 10,20 ) 'prints 30!
+}}
+Function parameters can be assigned constant 'default values' using syntax similar to initializing a variable: %Identifier @: %Type @= %ConstantExpression.
+
+Default parameters can then be optionally omitted when the function is called:
+{{
+Function IncInt:Int( n:Int,p:Int=1 )
+ Return n+p
+End Function
+Print IncInt( 1 ) 'Prints 2
+Print IncInt( 1,3 ) 'Prints 4
+}}
--- /dev/null
+
++Identifiers
+
+Identifiers are used to name constants, variables, functions and user defined types.
+
+Identifiers start with a letter or underscore and can be followed by any combination of letters, digits or underscores. For example, the following are all valid identifiers:
+{{
+player1_up
+your_name
+_hello_world_
+}}
+Identifiers in BlitzMax are case-insensitive. This means that the identifiers @hello, @Hello and @HELLO are all treated as the same identifier.
+
+The following identifiers are reserved for use by the BlitzMax language, and can not be used as general purpose identifiers:
+{{
+Strict Module ModuleInfo Framework
+End Return Continue Exit Assert
+Public Private
+True False Pi Null Self Super
+Byte Short Int Long Float Double Object String
+Var Ptr VarPtr Chr Len Asc SizeOf Sgn Abs Min Max Mod
+Shl Shr Sar Not And Or
+New Release Delete
+Incbin IncbinPtr IncbinLen
+Include Import Extern EndExtern
+Function EndFunction
+Type EndType Extends
+Method EndMethod
+Local Global Const Field
+Abstract Final
+Rem EndRem
+If Then Else ElseIf EndIf
+For To Next Step EachIn
+While Wend
+Repeat Until Forever
+Select Case Default EndSelect
+Try Catch EndTry Throw
+Goto DefData ReadData RestoreData
+Alias
+}}
--- /dev/null
+
++Literals
+
+Literals are simple numeric or string values.
+
++Integer literals
+
+Integer literals may be in either decimal, hexadecimal or binary format. To specify a hexadecimal literal, prepend it with the @$ character. To specify a binary literal, prepend it with the @{~%} character. Here are some examples of integer literals:
+{{
+100 'decimal literal
+$CAFEBABE 'hexadecimal (base 16) literal
+%10101010 'binary (base 2) literal
+}}
+
++Floating point literals
+
+Floating point literals are numeric values with a fractional part. The fractional part is specified using a decimal point. Floating point literals may also be extended using 'e notation'. For example:
+{{
+.5 'one half
+10.0 'ten point zero
+1e6 '1 times (10 to the power of 6)
+1.5e-6 '1.5 times (10 to the power of -6)
+}}
+
++String literals
+
+A string literal is a sequence of characters enclosed in quotation marks. For example:
+{{
+"Hello World"
+"" 'empty string
+}}
+
+String literals can also contain %{escape sequences}. An escape sequence is a special sequence of characters used to represent another character. This is useful for including 'untypable' characters and quotation marks in strings. Escape sequences always start with the @{~~} character. The following escape sequences are supported:
+
+[ @{Escape sequence} | @{Equivalent character}
+* ~~0 | Null character (ascii code 0)
+* ~~t | Tab character (ascii code 9)
+* ~~r | Return character (ascii code 13)
+* ~~n | Newline character (ascii code 10)
+* ~~q | Quote character (ascii code 34)
+* ~~ | Tilde character (ascii code 126)
+]
+
+For example:
+{{
+Print "And then Mark said, ~qescape sequences rule!~q"
+Print "Line1~nLine2~nLine3~nLine4~nLine5"
+}}
+
+The type of a literal may also be modified by appending @:%TypeName to the literal. For example:
+{{
+$8000000000000000:Long
+10:Double
+}}
--- /dev/null
+
++Modules
+
+A module is a precompiled collection of constants, globals, functions and user defined types, that may be used by applications or other modules.
+
++Creating modules
+
+Modules live in the 'mod' directory within the main BlitzMax directory. To create your own module, you must add a new subdirectory to 'mod' with the following format:
+{{
+/mod/modscope.mod/modname.mod
+}}
+Modscope should be a unique name (for example, the name of your organization or company) and is used to group together modules provided by a common source. Both modscope and modname should be valid identifiers. Also, to prevent issues with case sensitive filesystems such as Linux's, it is recommended that modscope and modname be lowercase.
+
+You will also need to create a main module source file inside the module directory. This file must have the same name as ModuleName:
+{{
+/mod/modscope.mod/modname.mod/modname.bmx
+}}
+Finally, your source file must include a #Module statement at the top:
+{{
+Module modscope.modname
+}}
+Once your module is setup, #BMK can be used to build it:
+{{
+bmk makemods modscope.modname
+}}
+Or, to build all modules in the same scope:
+{{
+bmk makemods modscope
+}}
+
++Using modules within modules
+
+To use a module within another module, you simply import it with the @Import command:
+{{
+Import modscope.modname
+}}
+This will import both the specified module %and any modules imported by that module. In other words, @Import is recursive.
+
++Using modules within applications
+
+By default, BlitzMax imports %every module it finds in the 'brl' and 'pub' module scopes when compiling applications. However, this can result in bulky executables. You can override this default behaviour by using the @Framework command:
+{
+@Framework %modscope.modname
+}
+@Framework should appear at the top of your main application source file.
+
+Specifying an application framework prevents BlitzMax from importing every module under the sun. Only the framework module and any explicitly imported modules are imported into your application.
+
+For example, to create a 'stripped down' BASIC application, you can use the BRL.Basic framework:
+{{
+Framework BRL.Basic 'create a stripped down app
+
+Print "Hello World!"
+}}
+When a building a multifile application, the framework (if any) found in the main source file is automatically passed to all 'child' files in the application. However, if you change this 'default' framework, you will need to 'rebuild all' for the change to affect other files.
--- /dev/null
+
++Objects
+
+Strings, arrays and instances of user defined types are all different kinds of %objects.
+
+Objects are handled %{by reference}. This means that the actual memory used by an object to store its data is shared between all the variables that refer to that object.
+
+This makes objects very efficient to deal with, as assigning an object to a variable simply involves assigning a reference to the object - not an entire object. Passing objects to functions and returning objects from functions is also very efficient as again only references need to be copied.
+
+BlitzMax uses a technique known as %{reference counting} to keep track of objects that are in use by your program.
+
+The basic idea behind reference counting is that each object includes a counter reflecting the number of variables referencing that object. When an object's counter reaches 0, the object is no longer in use and its memory can be returned to the system.
+
+The process of returning unused objects to the system is called 'garbage collection' and, by default, is performed automatically. However, it may be desirable to 'force' a garbage collection (for example, to check for memory leaks) and this can be done using the #GCCollect command.
+
+Objects can also have %methods - function-like operations associated with the object. All objects, including strings and arrays, provide at least the following methods:
+
+[ @Method | @Description
+* ToString:String() | Convert object to a string representation.
+* Compare:Int( withObject:Object ) | Returns a value less than 0 if an object is less than another object, a value greater than 0 if an object is greater than another object or the value 0 if an object equals another object.
+* SendMessage:Object( message:Object,context:Object ) | Used to send a generic message to an object.
+]
+
+The default implementation of the @ToString method converts the address of the object to hexadecimal and returns this value as a string. String objects override this behaviour to the return the object itself.
+
+The default implementation of the @Compare method subtracts object addresses. String objects override this behaviour to return the result of a character-by-character comparison.
+
+The @SendMessage method provides a simple, generic messaging system available to all objects. The default implementation of @SendMessage simply returns null.
+
+Note that the built-in equals and not equals operators do not actually use the compare method (with one exception). Instead, these operators compare memory addresses, allowing you to determine if 2 object references actually refer to the same object. The exception to this rule is when comparisons are performed on strings, in which case a character-by-character comparison is performed instead.
+
+To access an object's methods, use the member access operator. For example:
+{{
+Print "Hello".Compare( "Goodbye" )
+}}
--- /dev/null
+
++Program flow
+
+This section covers command that affect the flow of program execution.
+
++While/Wend loops
+
+A While/Wend loop continues executing while an expression evaluates to true:
+{
+@While %Expression\
+ %Statements\
+@Wend
+}
+
++Repeat/Until loops
+
+A Repeat/Until loop continues executing until an expression evaluates to true:
+{
+@Repeat\
+ %Statements\
+@Until %Expression
+}
+The statements within a Repeat/Until loop will always execute at least once, since the terminating expression is only evaluated at the bottom of the loop.
+
++Repeat/Forever loops
+
+A Repeat/Forever loop will simply continue executing forever:
+{
+@Repeat\
+ %Statements\
+@Forever
+}
+
++For/To/Next loops
+
+A For/To/Next loop will continue executing until the value of a numeric index variable goes beyond an exit value. The index variable is automatically updated every loop iteration by adding a step value. Note that the exit value is inclusive - the loop will typically execute once with the index variable equal to the exit value before terminating:
+{
+@For %IndexVariable @{=} %FirstValue @To %LastValue @Step %StepValue\
+ %Statements\
+@Next
+}
+The 'Step' part is optional, in which case the index variable will step in increments of 1. The step value must also be constant.
+
+The exit value is only evaluated once at the start of the loop. This means it is safe to use complex or 'slow' code as an exit value.
+
+You may also declare a new local variable to be used as the index variable, by preceding the index variable with the #Local keyword. Such local variables will not be visible outside of the loop when it terminates.
+
++For/Until/Next loops
+
+A For/Until/Next loop operates in a similar manner to a For/To/Next loop, except that the loop will terminate when the index variables becomes equal to the last value - in other words, the exit value is exclusive. This can be useful when you need to count 'up to' a value, without actually including that value:
+{
+@For %IndexVariable @{=} %FirstValue @Until %LastValue @Step %StepValue\
+ %statements\
+@Next
+}
+The 'Step' part is optional, in which case the index variable will step in increments of 1. The step value must also be constant.
+
+The exit value is only evaluated once at the start of the loop. This means it is safe to use complex or 'slow' code as an exit value.
+
+You may also declare a new local variable to be used as the index variable, by preceding the index variable with the #Local keyword. Such local variables will not be visible outside of the loop when it terminates.
+
++Exit and Continue
+
+The @Exit command can be used to exit from a @While, @Repeat or @For loop. The loop will be terminated, and program flow will be transferred to the first command after the loop.
+
+The @Continue command can be used to force a @While, @Repeat or @For loop to resume execution from the 'top' of the loop, skipping any statements remaining in the loop.
+
+Both @Exit and @Continue may be followed by an optional identifier. This identifer must match a previously declared %{loop label}, which allows you to exit or continue a specific loop, not necessarily the 'nearest' loop.
+
+To declare a loop label, use the syntax ~#Identifier immediately preceding a @While, @Repeat or @For loop. For example, this program will exit both loops when k and j both equal 5:
+{{
+Strict
+Local k,j
+#Label1 'loop label
+For k=1 To 4
+ #Label2 'another loop label (unused in this example)
+ For j=1 To 4
+ Print k+","+j
+ If k=3 And j=3 Exit Label1
+ Next
+Next
+}}
+Note that loop labels are only available in strict mode. In non-strict mode, use <font class=token>Goto</font> instead.
+
++If/Then blocks
+
+BlitzMax provides both the classic BASIC 'one liner' style of If/Then statement...
+{
+@If %Expression @Then %Statements @Else %Statements
+}
+...and the more modern block equivalent...
+{
+@If %Expression\
+ %Statements\
+@{Else If} %Expression\
+ %Statements\
+@Else\
+ %Statements\
+@EndIf
+}
+In both forms, the @Then keyword is optional.
+
++Select/Case blocks
+
+A Select/Case block allows you to simplify complex conditional tests. The select expression is compared with each of the case expressions and, if found to be equal, the program code within the appropriate case block is executed. If no matching case is found, the program code within the optional default block is executed:
+{
+@Select %Expression\
+@Case %Expressions\
+ %Statements\
+@Default\
+ %Statements\
+@{End Select}
+}
+The @Default section is optional.
+
+The selected value is only evaluated once, before each case is checked.
+
+Multiple expressions for each case may be used by providing a comma separated sequence of expressions.
--- /dev/null
+
++Project management
+
++Importing source files
+
+The #Import statement provides an efficient way to split your project up into multiple files. The syntax for import is:
+{
+@Import %Filename
+}
+%Filename must be a quote enclosed string literal with a recognized source file extension such as 'bmx'.
+
+Importing a file makes all the globals, consts, functions and user defined types declared in that file available to the file being currently compiled.
+
+Imported files can be %precompiled. This means that if you have a project split into multiple source files, only the files that are actually modified (and files those modifications affect) need to be recompiled. For example, say you have a project split into 2 source files:
+{{
+'file1.bmx
+Import "file2.bmx"
+Print Test()
+
+'file2.bmx
+Function Test:String()
+ Return "This is a test!"
+End Function
+}}
+If file2.bmx is then modified, both files need to be recompiled because not only has file2.bmx changed, but its changes may also affect file1.bmx.
+
+However, if only file1.bmx is modified there is no need to recompile file2.bmx. BlitzMax's #BMK utility takes care of all this for you.
+
+One important limitation of @Import is that you cannot create 'cycles' of imports.
+
++Including source files
+
+@Include is another way to split a project up into multiple files. The syntax for @Include is the same as that for @Import, however the included file is simply inserted 'verbatim' into the including file, instead of being separately compiled.
+
+Depending on the platform and project, @Include may be faster than @Import. It also allows you to get around the 'no cycles' restriction of @Import.
+
++Including binary files
+
+The @Incbin statement allows you to include binary files with your programs. The syntax for @Incbin is the same as that for @Import, however any kind of file may be specified, not just 'bmx' files.
+
+You can access the binary data contained in an incbined file using @IncbinPtr (which returns a Byte Ptr) and @IncbinLen (which returns an Int). Both @IncbinPtr and @IncbinLen require a filename parameter. For example:
+{{
+Incbin "data.bin"
+Local p:Byte Ptr=IncbinPtr( "data.bin" )
+Local n:Int=IncbinLen( "data.bin" )
+For Local i=0 Until n
+ Print "Byte "+i+":"+p[i]
+Next
+}}
--- /dev/null
+
++Slices
+
+Slices are sequences of characters or elements within a string or array.
+
+You can extract slices using the general syntax:
+{
+%StringOrArray @[ %StartIndex @{..} %EndIndex @]
+}
+The length of the returned slice is always ( %EndIndex - %StartIndex ) elements long, even if %StartIndex is less than 0 or %EndIndex is greater than the length of the string or array. 'Missing' elements are initialized to null in the case of arrays, or the space character in the case of strings.
+
+Either index may be omitted. If %StartIndex is omitted, it defaults to 0. If %EndIndex is omitted, it defaults to the length of the string or array.
+
+This flexibility allows you to use slices to resize or copy arrays. For example:
+{{
+Local a[200] 'initialize a[] to 200 elements
+a=a[50..150] 'extract middle 100 elements of a[]
+a=a[..50] 'extract first 50 elements of a[]
+a=a[25..] 'extract elements starting from index 25 of a[]
+a=a[..] 'copy all elements of a[]
+a=a[..200] 'resize a[] to 200 elements
+}}
--- /dev/null
+
++Strings
+
+Strings are used to store sequences of characters.
+
+Strings are actually objects, so can be used where ever an object is expected. Strings provide the following methods:
+
+[ @Method | @Description
+
+* Find:Int( subString:String,startIndex=0 ) | Finds first occurance of a sub string. Returns -1 if @subString not found.
+
+* FindLast:Int( subString:String,startIndex=0 ) | Finds last occurance of a sub string. Returns -1 if @subString not found.
+
+* Trim:String() | Removes leading and trailing non-printable characters from a string.
+
+* Replace:String( subString:String,withString:String ) | Replaces all occurances of @subString with @withString.
+
+* StartsWith:Int( subString:String ) | Returns true if string starts with @subString.
+
+* EndsWith:Int( subString:String ) | Returns true if string ends with @subString.
+
+* Contains:Int( subString:String ) | Returns true if string contains @subString.
+
+* Join:String( bits:String[] ) | Joins @bits together by inserting this string between each bit.
+
+* Split:String[]( separator$[] ) | Splits this string into bits delimited by @separator.
+
+* ToLower:String() | Converts string to lowercase.
+
+* ToUpper:String() | Converts string to uppercase.
+
+* ToInt:Int() | Converts string to an integer.
+
+* ToLong:Long() | Converts string to a long.
+
+* ToFloat:Float() | Converts string to a float.
+
+* ToDouble:Double() | Converts string to a double.
+
+* ToCString:Byte Ptr() | Converts string to a null terminated sequence of 8 bit bytes. The returned memory must eventually be freed with a call to #MemFree.
+
+* ToWString:Short Ptr() | Converts string to a null terminated sequence of 16 bit shorts. The returned memory must eventually be freed with a call to #MemFree.
+]
+
+Strings also provide a read-only @length field.
+
+Here is an example of using string methods:
+{{
+Local t:String="***** HELLO *****"
+
+Print t.length 'return length of string: 17
+Print t.Find( "HE" ) 'returns index of substring "HE": 6
+Print t.Replace( "*","!" ) 'replaces all "*" with "!"
+Print t.ToLower() 'coverts string to lowercase
+Print ":".Join( ["Hello","World"] ) 'returns "Hello:World"
+}}
+String also provide the following functions to help with the creation of strings:
+
+[ @Function | @Description
+
+* FromInt:String( value:Int ) | Creates a string from an integer.
+
+* FromLong:String( value:Long ) | Creates a string from a long.
+
+* FromFloat:String( value:Float ) | Creates a string from a float.
+
+* FromDouble:String( value:Double) | Creates a string from a double.
+
+* FromCString:String( cString:Byte Ptr ) | Creates a string from a null terminated sequence of 8 bit bytes.
+
+* FromWString:String( wString:Short Ptr ) | Creates a string from a null terminated sequence of 16 bit shorts.
+
+* FromBytes:String( bytes:Byte Ptr,length ) | Creates a string from a sequence of @length 8 bit bytes.
+
+* FromShorts:String( shorts:Short Ptr,length ) | Creates a string from a sequence of @length 16 bit shorts.
+]
+
+To call a string function, use: @String.}%Function - for example:
+{{
+Print String.FromInt( 10 )
+}}
--- /dev/null
+
++User defined types
+
++defined types allow you to group related data and program code together into a single entity known as an %object.
+
+The general syntax for declaring a user defined type is:
+{
+@Type %Typename @Extends %Typename
+}
+@Typename must be a valid identifier.
+
+The @Extends part is optional. If omitted, the user defined type extends the built in @Object type.
+
+Once declared, you can create %instances of such types using the @New operator.
+
+Within a user defined type, you can declare the following:
+
+[ Fields:
+Fields are variables associated with each instance of a user defined type. Fields are declared in the same way as local or global variables, only using the @Field keyword. To access the fields of an object, use the @{.} operator.
+* Methods:
+Methods are function-like operations associated with each instance of a user defined type. Methods are declared in the same way as functions, only using the @Method keyword. To access the methods of an object, use the @{.} operator. Program code within a method can access other fields, methods, functions, consts and globals within the same object simply by referring to them by name.
+* Functions:
+These are declared in the same way as 'normal' functions, and can be accessed using the @{.} operator. Unlike methods, functions within a type are %not associated with instances of the type, but with the type itself. This means such functions can be used regardless of whether or not any instances of the type have been created yet. Functions within a type can access other functions, consts or globals within the same type by referring to them by name.
+* Consts and Globals
+These are declared in the same way as 'normal' consts and globals, and be accessed using the @{.} operator. As with type functions, these are not associated with instances of the type, but with the type itself.
+]
+Here is an example of a user defined type:
+{{
+Type MyType
+ Const INC=1
+ Global Counter
+ Field x,y,z
+
+ Method Sum()
+ Counter=Counter+INC
+ Return x+y+z
+ End Method
+
+ Function Create:MyType()
+ Return New MyType
+ End Function
+End Type
+
+Local MyObject:MyType=MyType.Create()
+
+MyObject.x=10
+MyObject.y=20
+MyObject.z=30
+
+Print MyObject.Sum()
+Print MyType.Counter
+}}
+Note that the object is created indirectly by calling MyType's @Create function instead of @New. This is a frequently used technique that allows you to perform (possibly complex) initialization of an object before it is returned to the user.
+
++Inheritance and polymorphism
+
+User defined types can %extend other user defined types using the @Extends keyword. Extending a type means adding more functionality to an existing type. The type being extended is often referred to as the %base type, while the resulting, extended type is often referred to as the %derived type:
+{{
+Type BaseType
+ Field x,y,z
+
+ Method Sum()
+ Return x+y+z
+ End Method
+End Type
+
+Type DerivedType Extends BaseType
+ Field p,q,r
+
+ Method Sum()
+ Return x+y+z+p+q+r
+ End Method
+End Type
+}}
+This technique is also known as %inheritance, as the derived type is inheriting functionality from the base type (although no one had to die in the process!). Note that DerivedType actually has 6 fields - x,y,z,p,q and r. It inherits x,y,z from BaseType and adds its own fields p,q,r.
+
+BlitzMax allows you to use a derived type object anywhere a base type object is expected. This works because a derived type object %is a base type object - only with some 'extras'. For example, you can assign a derived type object to a base type variable, or pass a derived type object to a function expecting a base type parameter. This is really the whole point of inheritance - its not just a technique to save typing.
+
+This behaviour allows for a very useful technique known as %polymorphism. This means the ability of an object to behave in different ways depending on its type. This is achieved in Blitzmax by %overriding methods.
+
+Notice in the above example that the method 'Sum' has the same signature (parameters and return type) in both the base type and the derived type. This is not just a coincidence - it is required by the language. Whenever you add a method to a derived type with the same name as an existing method in a base type, it must have the same signature as the method in the base type.
+
+But now we have 2 versions of 'Sum' - which gets called? This depends on the %{runtime type} of an object. For example:
+{{
+Type BaseType
+ Method Test:String()
+ Return "BaseType.Test"
+ End Method
+End Type
+
+Type DerivedType Extends BaseType
+ Method Test:String()
+ Return "DerivedType.Test"
+ End Method
+End Type
+
+Local x:BaseType=New BaseType
+Local y:BaseType=New DerivedType
+
+Print x.Test() 'prints "BaseType.Test" - x's runtime type is BaseType
+Print y.Test() 'prints "DerivedType.Test" - as y's runtime type is DerivedType
+}}
+Note that when the variable y is initialized, it is assigned a DerivedType object, even though y is a BaseType varible. This is legal because derived types can be used in place of base types. However, this means the runtime type of y is actually DerivedType. Therefore, when y.Test() is called, the DerivedType method Test() is called.
+
++Self and Super
+Program code inside a method can access two special variables named @Self and @Super.
+
+@Self refers to the object associated with the method, and its type is that of the user defined type the method is declared in.
+
+@Super also refers to the object associated with the method, however its type is that of the user defined type being extended. This can be very useful if you need to call the base type version of the currently executing method:
+{{
+Type BaseType
+ Method Test()
+ Print "BaseType.Test"
+ End Method
+End Type
+
+Type DerivedType Extends BaseType
+ Method Test()
+ Super.Test 'calls BaseType's Test() method first!
+ Print "DerivedType.Test"
+ End Method
+End Type
+
+Local x:BaseType=New DerivedType
+
+x.Test
+}}
+
++New and Delete
+
+User defined types can optionally declare two special methods named @New and @Delete. Both methods must take no arguments, and any returned value is ignored.
+
+The @New method is called when an object is first created with the @New operator. This allows you to perform extra initialization code.
+
+The @Delete method is called when an object is discarded by the memory manager. Note that critical shutdown operations such as closing files etc should not be placed in the @Delete, as you can't always be sure when @Delete will be called.
+
++Abstract and Final
+
+User defined types and methods can also be declared %abstract or %final by adding @Abstract or @Final to the appropriate declaration:
+{{
+Type AbstractType Abstract
+ Method AbstractMethod() Abstract
+End Type
+
+Type FinalType Final
+ Method FinalMethod() Final
+ Print "FinalType.FinalMethod"
+ End Method
+End Type
+}}
+Declaring a user defined type abstract means that you can not create instances of it using @New. However, it is still possible to extend such types and create instances of these derived types. Declaring a method abstract means that the method has no implementation and must be implemented by a derived type. Any user defined type with at least one abstract method is itself abstract.
+
+Declaring a user defined type final means that it can not be extended. Declaring a method final means that derived types can not override the method. All methods of a final user defined type are themselves final.
+
+Abstract types and methods are mostly used to create 'template' types and methods that leave implementation details up to derived types.
+
+Final types and methods are mostly used to prevent modification to a type's behaviour.
--- /dev/null
+
++Variables
+
+Variables are used to store values that change during the execution of your program.
+
+Variables should be declared in your program before use. Declaring a variable means defining a name and type for the variable and, optionally, an initial value.
+
+The general syntax for declaring a variable is:
+{
+%Declaration @Identifier @: %Type @= %Expression
+}
+Multiple variables may be declared in one statement using the comma separator.
+
+If the type of a variable is omitted, the variable defaults to being of type @Int. If the initial value expression is omitted, the variable is assigned an initial value of @Null.
+
+There are 3 kinds of variable, each of which differs by how and where the variable is stored:
+
++Local Variables
+
+Local variables are used to store temporary values that will eventually be discarded. Local variables are associated with the block of code they are declared in, and are only visible to code within that block. A block of code is represented by one of the following:
+[ The body of a function or loop
+* The body of an if/then/else statement
+* The body of a case or default statement
+]
+
+To declare a local variable, use a @Local declaration:
+{{
+Local int_var
+Local string_var:String="Str",float_var:Float=10.5
+}}
+
++Global Variables
+
+Global variables are variables that exist for the entire lifetime of a program.
+
+To declare a global variable, use a @Global declaration:
+{{
+Global int_var
+Global string_var:String="Str",float_var:Float=10.5
+}}
+
++Field Variables
+
+Field variables are declared within user-defined types using a @Field declaration:
+{{
+Field int_var
+Field string_var:String="Str",float_var:Float=10.5
+}}
+
+See the user-defined types section for more on field variables.
+
++Assigning variables
+
+Once declared, a variable's value may be changed using an assignment statement:
+{
+%Variable @= %Expression
+}
+You can also perform 'modifying' assignments, which are shorthand for %Variable @= %Variable %Operator %Expression. The syntax for modifying assignments is:
+[ @Syntax | @Operator
+* :+ | Addition
+* :- | Subtraction
+* :* | Multiplication
+* :/ | Division
+* :Mod | Remainder
+* :& | Bitwise and
+* :~| | Bitwise or
+* :~~ | Bitwise exclusive or
+* :Shl | Bitwise shift left
+* :Shr | Bitwise shift right
+* :Sar | Arithmetic shift right
+]
+For example, the code %{my_var:+1} can be used in place of %{my_var=my_var+1}.
--- /dev/null
+
++BlitzMax language reference
+
+Welcome to the BlitzMax language reference.
+
+This document describes the core BlitzMax programming language.
+
+For users who already have BASIC programming experience, the #{BASIC compatibility} section highlights the major differences between BlitzMax and other BASIC dialects.
+
+For general command reference, please see the #modules documentation.
--- /dev/null
+<!DOCTYPE>
+<html>
+<body>
+<pre>
+
+Blitz Shared Source Code License
+--------------------------------
+
+This source code is the property of Blitz Research Ltd.
+
+This software is provided 'as-is', without any express
+or implied warranty. In no event will the authors be held
+liable for any damages arising from the use of this
+software.
+
+You may distribute executable applications built from
+this source code under your own licensing terms. You may
+not distribute static or dynamic library files based in
+whole or in part on this source code.
+
+You may modify this source code for your own purposes and
+can choose to publish such modifications to the <b>BlitzMax
+Community</b> page at <b>http://www.blitzbasic.com</b>. You
+may not publish this source code or any modified
+version of it elsewhere.
+
+By publishing modifications to http://www.blitzbasic.com, you
+agree that other members of the Blitz community are free to
+use those modifications in their own projects, and that
+Blitz Research Ltd are free to include your modifications
+in future source code releases.
+
+</pre>
+</body>
+</html>
--- /dev/null
+<html>
+<body>
+<pre>
+
+ The FreeType Project LICENSE
+ ----------------------------
+
+ 2000-Feb-08
+
+ Copyright 1996-2000 by
+ David Turner, Robert Wilhelm, and Werner Lemberg
+
+
+
+Introduction
+============
+
+ The FreeType Project is distributed in several archive packages;
+ some of them may contain, in addition to the FreeType font engine,
+ various tools and contributions which rely on, or relate to, the
+ FreeType Project.
+
+ This license applies to all files found in such packages, and
+ which do not fall under their own explicit license. The license
+ affects thus the FreeType font engine, the test programs,
+ documentation and makefiles, at the very least.
+
+ This license was inspired by the BSD, Artistic, and IJG
+ (Independent JPEG Group) licenses, which all encourage inclusion
+ and use of free software in commercial and freeware products
+ alike. As a consequence, its main points are that:
+
+ o We don't promise that this software works. However, we will be
+ interested in any kind of bug reports. (`as is' distribution)
+
+ o You can use this software for whatever you want, in parts or
+ full form, without having to pay us. (`royalty-free' usage)
+
+ o You may not pretend that you wrote this software. If you use
+ it, or only parts of it, in a program, you must acknowledge
+ somewhere in your documentation that you have used the
+ FreeType code. (`credits')
+
+ We specifically permit and encourage the inclusion of this
+ software, with or without modifications, in commercial products.
+ We disclaim all warranties covering The FreeType Project and
+ assume no liability related to The FreeType Project.
+
+
+Legal Terms
+===========
+
+0. Definitions
+--------------
+
+ Throughout this license, the terms `package', `FreeType Project',
+ and `FreeType archive' refer to the set of files originally
+ distributed by the authors (David Turner, Robert Wilhelm, and
+ Werner Lemberg) as the `FreeType Project', be they named as alpha,
+ beta or final release.
+
+ `You' refers to the licensee, or person using the project, where
+ `using' is a generic term including compiling the project's source
+ code as well as linking it to form a `program' or `executable'.
+ This program is referred to as `a program using the FreeType
+ engine'.
+
+ This license applies to all files distributed in the original
+ FreeType Project, including all source code, binaries and
+ documentation, unless otherwise stated in the file in its
+ original, unmodified form as distributed in the original archive.
+ If you are unsure whether or not a particular file is covered by
+ this license, you must contact us to verify this.
+
+ The FreeType Project is copyright (C) 1996-2000 by David Turner,
+ Robert Wilhelm, and Werner Lemberg. All rights reserved except as
+ specified below.
+
+1. No Warranty
+--------------
+
+ THE FREETYPE PROJECT IS PROVIDED `AS IS' WITHOUT WARRANTY OF ANY
+ KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ PURPOSE. IN NO EVENT WILL ANY OF THE AUTHORS OR COPYRIGHT HOLDERS
+ BE LIABLE FOR ANY DAMAGES CAUSED BY THE USE OR THE INABILITY TO
+ USE, OF THE FREETYPE PROJECT.
+
+2. Redistribution
+-----------------
+
+ This license grants a worldwide, royalty-free, perpetual and
+ irrevocable right and license to use, execute, perform, compile,
+ display, copy, create derivative works of, distribute and
+ sublicense the FreeType Project (in both source and object code
+ forms) and derivative works thereof for any purpose; and to
+ authorize others to exercise some or all of the rights granted
+ herein, subject to the following conditions:
+
+ o Redistribution of source code must retain this license file
+ (`LICENSE.TXT') unaltered; any additions, deletions or changes
+ to the original files must be clearly indicated in
+ accompanying documentation. The copyright notices of the
+ unaltered, original files must be preserved in all copies of
+ source files.
+
+ o Redistribution in binary form must provide a disclaimer that
+ states that the software is based in part of the work of the
+ FreeType Team, in the distribution documentation. We also
+ encourage you to put an URL to the FreeType web page in your
+ documentation, though this isn't mandatory.
+
+ These conditions apply to any software derived from or based on
+ the FreeType Project, not just the unmodified files. If you use
+ our work, you must acknowledge us. However, no fee need be paid
+ to us.
+
+3. Advertising
+--------------
+
+ Neither the FreeType authors and contributors nor you shall use
+ the name of the other for commercial, advertising, or promotional
+ purposes without specific prior written permission.
+
+ We suggest, but do not require, that you use one or more of the
+ following phrases to refer to this software in your documentation
+ or advertising materials: `FreeType Project', `FreeType Engine',
+ `FreeType library', or `FreeType Distribution'.
+
+ As you have not signed this license, you are not required to
+ accept it. However, as the FreeType Project is copyrighted
+ material, only this license, or another one contracted with the
+ authors, grants you the right to use, distribute, and modify it.
+ Therefore, by using, distributing, or modifying the FreeType
+ Project, you indicate that you understand and accept all the terms
+ of this license.
+
+4. Contacts
+-----------
+
+ There are two mailing lists related to FreeType:
+
+ o freetype@freetype.org
+
+ Discusses general use and applications of FreeType, as well as
+ future and wanted additions to the library and distribution.
+ If you are looking for support, start in this list if you
+ haven't found anything to help you in the documentation.
+
+ o devel@freetype.org
+
+ Discusses bugs, as well as engine internals, design issues,
+ specific licenses, porting, etc.
+
+ o http://www.freetype.org
+
+ Holds the current FreeType web page, which will allow you to
+ download our latest development version and read online
+ documentation.
+
+ You can also contact us individually at:
+
+ David Turner <david.turner@freetype.org>
+ Robert Wilhelm <robert.wilhelm@freetype.org>
+ Werner Lemberg <werner.lemberg@freetype.org>
+
+
+--- end of LICENSE.TXT ---
+</pre>
+</body>
+</html>
\ No newline at end of file
--- /dev/null
+GLX PUBLIC LICENSE (Version 1.0 (2/11/99)) ("License")
+
+Subject to any third party claims, Silicon Graphics, Inc. ("SGI") hereby
+grants permission to Recipient (defined below), under Recipient's
+copyrights in the Original Software (defined below), to use, copy,
+modify, merge, publish, distribute, sublicense and/or sell copies of
+Subject Software (defined below), and to permit persons to whom the
+Subject Software is furnished in accordance with this License to do the
+same, subject to all of the following terms and conditions, which
+Recipient accepts by engaging in any such use, copying, modifying,
+merging, publishing, distributing, sublicensing or selling:
+
+1. Definitions.
+
+ (a) "Original Software" means source code of computer software code
+ which is described in Exhibit A as Original Software.
+
+ (b) "Modifications" means any addition to or deletion from the
+ substance or structure of either the Original Software or any
+ previous Modifications. When Subject Software is released as a
+ series of files, a Modification means (i) any addition to or
+ deletion from the contents of a file containing Original Software or
+ previous Modifications and (ii) any new file that contains any part
+ of the Original Code or previous Modifications.
+
+ (c) "Subject Software" means the Original Software or Modifications
+ or the combination of the Original Software and Modifications, or
+ portions of any of the foregoing.
+
+ (d) "Recipient" means an individual or a legal entity exercising
+ rights under, and complying with all of the terms of, this License.
+ For legal entities, "Recipient" includes any entity which controls,
+ is controlled by, or is under common control with Recipient. For
+ purposes of this definition, "control" of an entity means (a) the
+ power, direct or indirect, to direct or manage such entity, or (b)
+ ownership of fifty percent (50%) or more of the outstanding shares
+ or beneficial ownership of such entity.
+
+2. Redistribution of Source Code Subject to These Terms. Redistributions
+of Subject Software in source code form must retain the notice set forth
+in Exhibit A, below, in every file. A copy of this License must be
+included in any documentation for such Subject Software where the
+recipients' rights relating to Subject Software are described. Recipient
+may distribute the source code version of Subject Software under a
+license of Recipient's choice, which may contain terms different from
+this License, provided that (i) Recipient is in compliance with the
+terms of this License, and (ii) the license terms include this Section 2
+and Sections 3, 4, 7, 8, 10, 12 and 13 of this License, which terms may
+not be modified or superseded by any other terms of such license. If
+Recipient distributes the source code version under a different license
+Recipient must make it absolutely clear that any terms which differ from
+this License are offered by Recipient alone, not by SGI. Recipient
+hereby agrees to indemnify SGI for any liability incurred by SGI as a
+result of any such terms Recipient offers.
+
+3. Redistribution in Executable Form. The notice set forth in Exhibit A
+must be conspicuously included in any notice in an executable version of
+Subject Software, related documentation or collateral in which Recipient
+describes the user's rights relating to the Subject Software. Recipient
+may distribute the executable version of Subject Software under a
+license of Recipient's choice, which may contain terms different from
+this License, provided that (i) Recipient is in compliance with the
+terms of this License, and (ii) the license terms include this Section 3
+and Sections 4, 7, 8, 10, 12 and 13 of this License, which terms may not
+be modified or superseded by any other terms of such license. If
+Recipient distributes the executable version under a different license
+Recipient must make it absolutely clear that any terms which differ from
+this License are offered by Recipient alone, not by SGI. Recipient
+hereby agrees to indemnify SGI for any liability incurred by SGI as a
+result of any such terms Recipient offers.
+
+4. Termination. This License and the rights granted hereunder will
+terminate automatically if Recipient fails to comply with terms herein
+and fails to cure such breach within 30 days of the breach. Any
+sublicense to the Subject Software which is properly granted shall
+survive any termination of this License absent termination by the terms
+of such sublicense. Provisions which, by their nature, must remain in
+effect beyond the termination of this License shall survive.
+
+5. No Trademark Rights. This License does not grant any rights to use
+any trade name, trademark or service mark whatsoever. No trade name,
+trademark or service mark of SGI may be used to endorse or promote
+products derived from the Subject Software without prior written
+permission of SGI.
+
+6. No Other Rights. This License does not grant any rights with respect
+to the OpenGL API or to any software or hardware implementation thereof
+or to any other software whatsoever, nor shall any other rights or
+licenses not expressly granted hereunder arise by implication, estoppel
+or otherwise with respect to the Subject Software. Title to and
+ownership of the Original Software at all times remains with SGI. All
+rights in the Original Software not expressly granted under this License
+are reserved.
+
+7. Compliance with Laws; Non-Infringement. Recipient shall comply with
+all applicable laws and regulations in connection with use and
+distribution of the Subject Software, including but not limited to, all
+export and import control laws and regulations of the U.S. government
+and other countries. Recipient may not distribute Subject Software that
+(i) in any way infringes (directly or contributorily) the rights
+(including patent, copyright, trade secret, trademark or other
+intellectual property rights of any kind) of any other person or entity
+or (ii) breaches any representation or warranty, express, implied or
+statutory, which under any applicable law it might be deemed to have
+been distributed.
+
+8. Claims of Infringement. If Recipient at any time has knowledge of any
+one or more third party claims that reproduction, modification, use,
+distribution, import or sale of Subject Software (including particular
+functionality or code incorporated in Subject Software) infringes the
+third party's intellectual property rights, Recipient must place in a
+well-identified web page bearing the title "LEGAL" a description of each
+such claim and a description of the party making each such claim in
+sufficient detail that a user of the Subject Software will know whom to
+contact regarding the claim. Also, upon gaining such knowledge of any
+such claim, Recipient must conspicuously include the URL for such web
+page in the Exhibit A notice required under Sections 2 and 3, above, and
+in the text of any related documentation, license agreement or
+collateral in which Recipient describes end user's rights relating to
+the Subject Software. If Recipient obtains such knowledge after it makes
+Subject Software available to any other person or entity, Recipient
+shall take other steps (such as notifying appropriate mailing lists or
+newsgroups) reasonably calculated to inform those who received the
+Subject Software that new knowledge has been obtained.
+
+9. DISCLAIMER OF WARRANTY. SUBJECT SOFTWARE IS PROVIDED ON AN "AS IS"
+BASIS, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
+INCLUDING, WITHOUT LIMITATION, WARRANTIES THAT THE SUBJECT SOFTWARE IS
+FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE OR NON-
+INFRINGING. SGI ASSUMES NO RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+SOFTWARE. SHOULD ANY SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, SGI
+ASSUMES NO COST OR LIABILITY FOR ANY SERVICING, REPAIR OR CORRECTION.
+THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+LICENSE. NO USE OF ANY SUBJECT SOFTWARE IS AUTHORIZED HEREUNDER EXCEPT
+UNDER THIS DISCLAIMER.
+
+10. LIMITATION OF LIABILITY. UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL
+THEORY, WHETHER TORT (INCLUDING, WITHOUT LIMITATION, NEGLIGENCE OR
+STRICT LIABILITY), CONTRACT, OR OTHERWISE, SHALL SGI OR ANY SGI LICENSOR
+BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR
+CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION,
+DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, LOSS OF DATA, COMPUTER
+FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR
+LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY
+OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO
+LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SGI's NEGLIGENCE
+TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME
+JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR
+CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO
+RECIPIENT.
+
+11. Indemnity. Recipient shall be solely responsible for damages
+arising, directly or indirectly, out of its utilization of rights under
+this License. Recipient will defend, indemnify and hold harmless Silicon
+Graphics, Inc. from and against any loss, liability, damages, costs or
+expenses (including the payment of reasonable attorneys fees) arising
+out of Recipient's use, modification, reproduction and distribution of
+the Subject Software or out of any representation or warranty made by
+Recipient.
+
+12. U.S. Government End Users. The Subject Software is a "commercial
+item" consisting of "commercial computer software" as such terms are
+defined in title 48 of the Code of Federal Regulations and all U.S.
+Government End Users acquire only the rights set forth in this License
+and are subject to the terms of this License.
+
+13. Miscellaneous. This License represents the complete agreement
+concerning subject matter hereof. If any provision of this License is
+held to be unenforceable, such provision shall be reformed so as to
+achieve as nearly as possible the same economic effect as the original
+provision and the remainder of this License will remain in effect. This
+License shall be governed by and construed in accordance with the laws
+of the United States and the State of California as applied to
+agreements entered into and to be performed entirely within California
+between California residents. Any litigation relating to this License
+shall be subject to the exclusive jurisdiction of the Federal Courts of
+the Northern District of California (or, absent subject matter
+jurisdiction in such courts, the courts of the State of California),
+with venue lying exclusively in Santa Clara County, California, with the
+losing party responsible for costs, including without limitation, court
+costs and reasonable attorneys fees and expenses. The application of the
+United Nations Convention on Contracts for the International Sale of
+Goods is expressly excluded. Any law or regulation which provides that
+the language of a contract shall be construed against the drafter shall
+not apply to this License.
+
+Exhibit A
+
+The contents of this file are subject to Sections 2, 3, 4, 7, 8, 10, 12
+and 13 of the GLX Public License Version 1.0 (the "License"). You may
+not use this file except in compliance with those sections of the
+License. You may obtain a copy of the License at Silicon Graphics, Inc.,
+attn: Legal Services, 2011 N. Shoreline Blvd., Mountain View, CA 94043
+or at http://www.sgi.com/software/opensource/glx/license.html.
+
+Software distributed under the License is distributed on an "AS IS"
+basis. ALL WARRANTIES ARE DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY
+IMPLIED WARRANTIES OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR
+PURPOSE OR OF NON- INFRINGEMENT. See the License for the specific
+language governing rights and limitations under the License.
+
+The Original Software is GLX version 1.2 source code, released February,
+1999. The developer of the Original Software is Silicon Graphics, Inc.
+Those portions of the Subject Software created by Silicon Graphics, Inc.
+are Copyright (c) 1991-9 Silicon Graphics, Inc. All Rights Reserved.
+
--- /dev/null
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang='en' xml:lang='en'>
+<head>
+ <meta http-equiv='content-type' content='text/html; charset=UTF-8'/>
+ <title>Sample Xiph.Org Variant of the BSD License</title>
+ <style type='text/css'>
+ html {
+ font: 90% Optima, "Trebuchet MS", sans-serif;
+ }
+ </style>
+</head>
+<body>
+ <p>
+ Please note that this is only a sample license;
+ authoritative license terms are included with each
+ software bundle.
+ </p>
+ <blockquote>
+ <p>© <var>year</var>, Xiph.Org Foundation</p>
+ <p>
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ </p>
+ <ul>
+ <li>
+ Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ </li>
+
+ <li>
+ Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ </li>
+
+ <li>
+ Neither the name of the Xiph.org Foundation nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+ </li>
+ </ul>
+
+ <p style='text-transform: uppercase;'>
+This software is provided by the copyright holders and contributors
+“as is” and any express or implied warranties, including, but not
+limited to, the implied warranties of merchantability and fitness for
+a particular purpose are disclaimed. In no event shall the foundation
+or contributors be liable for any direct, indirect, incidental,
+special, exemplary, or consequential damages (including, but not
+limited to, procurement of substitute goods or services; loss of use,
+data, or profits; or business interruption) however caused and on any
+theory of liability, whether in contract, strict liability, or tort
+(including negligence or otherwise) arising in any way out of the use
+of this software, even if advised of the possibility of such damage.
+ </p>
+ </blockquote>
+</body>
+</html>
+
--- /dev/null
+SGI FREE SOFTWARE LICENSE B (Version 1.1 [02/22/2000])
+1. Definitions.
+1.1. "Additional Notice Provisions" means such additional provisions as appear in the Notice in Original Code under the heading "Additional Notice Provisions."
+1.2. "Covered Code" means the Original Code or Modifications, or any combination thereof.
+1.3. "Hardware" means any physical device that accepts input, processes input, stores the results of processing, and/or provides output.
+1.4. "Larger Work" means a work that combines Covered Code or portions thereof with code not governed by the terms of this License.
+1.5. "Licensable" means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.
+1.6. "License" means this document.
+1.7. "Licensed Patents" means patent claims Licensable by SGI that are infringed by the use or sale of Original Code or any Modifications provided by SGI, or any combination thereof.
+1.8. "Modifications" means any addition to or deletion from the substance or structure of the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:
+A. Any addition to the contents of a file containing Original Code and/or addition to or deletion from the contents of a file containing previous Modifications.
+B. Any new file that contains any part of the Original Code or previous Modifications.
+1.9. "Notice" means any notice in Original Code or Covered Code, as required by and in compliance with this License.
+1.10. "Original Code" means source code of computer software code that is described in the source code Notice required by Exhibit A as Original Code, and updates and error corrections specifically thereto.
+1.11. "Recipient" means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 8. For legal entities, "Recipient" includes any entity that controls, is controlled by, or is under common control with Recipient. For purposes of this definition, "control" of an entity means (a) the power, direct or indirect, to direct or manage such entity, or (b) ownership of fifty percent (50%) or more of the outstanding shares or beneficial ownership of such entity.
+1.12. "Recipient Patents" means patent claims Licensable by a Recipient that are infringed by the use or sale of Original Code or any Modifications provided by SGI, or any combination thereof.
+1.13. "SGI" means Silicon Graphics, Inc.
+1.14. "SGI Patents" means patent claims Licensable by SGI other than the Licensed Patents.
+2. License Grant and Restrictions.
+2.1. SGI License Grant. Subject to the terms of this License and any third party intellectual property claims, for the duration of intellectual property protections inherent in the Original Code, SGI hereby grants Recipient a worldwide, royalty-free, non-exclusive license, to do the following: (i) under copyrights Licensable by SGI, to reproduce, distribute, create derivative works from, and, to the extent applicable, display and perform the Original Code and/or any Modifications provided by SGI alone and/or as part of a Larger Work; and (ii) under any Licensable Patents, to make, have made, use, sell, offer for sale, import and/or otherwise transfer the Original Code and/or any Modifications provided by SGI. Recipient accepts the terms and conditions of this License by undertaking any of the aforementioned actions. The patent license shall apply to the Covered Code if, at the time any related Modification is added, such addition of the Modification causes such combination to be covered by the Licensed Patents. The patent license in Section 2.1(ii) shall not apply to any other combinations that include the Modification. No patent license is provided under SGI Patents for infringements of SGI Patents by Modifications not provided by SGI or combinations of Original Code and Modifications not provided by SGI.
+2.2. Recipient License Grant. Subject to the terms of this License and any third party intellectual property claims, Recipient hereby grants SGI and any other Recipients a worldwide, royalty-free, non-exclusive license, under any Recipient Patents, to make, have made, use, sell, offer for sale, import and/or otherwise transfer the Original Code and/or any Modifications provided by SGI.
+2.3. No License For Hardware Implementations. The licenses granted in Section 2.1 and 2.2 are not applicable to implementation in Hardware of the algorithms embodied in the Original Code or any Modifications provided by SGI .
+3. Redistributions.
+3.1. Retention of Notice/Copy of License. The Notice set forth in Exhibit A, below, must be conspicuously retained or included in any and all redistributions of Covered Code. For distributions of the Covered Code in source code form, the Notice must appear in every file that can include a text comments field; in executable form, the Notice and a copy of this License must appear in related documentation or collateral where the Recipient's rights relating to Covered Code are described. Any Additional Notice Provisions which actually appears in the Original Code must also be retained or included in any and all redistributions of Covered Code.
+3.2. Alternative License. Provided that Recipient is in compliance with the terms of this License, Recipient may, so long as without derogation of any of SGI's rights in and to the Original Code, distribute the source code and/or executable version(s) of Covered Code under (1) this License; (2) a license identical to this License but for only such changes as are necessary in order to clarify Recipient's role as licensor of Modifications; and/or (3) a license of Recipient's choosing, containing terms different from this License, provided that the license terms include this Section 3 and Sections 4, 6, 7, 10, 12, and 13, which terms may not be modified or superseded by any other terms of such license. If Recipient elects to use any license other than this License, Recipient must make it absolutely clear that any of its terms which differ from this License are offered by Recipient alone, and not by SGI. It is emphasized that this License is a limited license, and, regardless of the license form employed by Recipient in accordance with this Section 3.2, Recipient may relicense only such rights, in Original Code and Modifications by SGI, as it has actually been granted by SGI in this License.
+3.3. Indemnity. Recipient hereby agrees to indemnify SGI for any liability incurred by SGI as a result of any such alternative license terms Recipient offers.
+4. Termination. This License and the rights granted hereunder will terminate automatically if Recipient breaches any term herein and fails to cure such breach within 30 days thereof. Any sublicense to the Covered Code that is properly granted shall survive any termination of this License, absent termination by the terms of such sublicense. Provisions that, by their nature, must remain in effect beyond the termination of this License, shall survive.
+5. No Trademark Or Other Rights. This License does not grant any rights to: (i) any software apart from the Covered Code, nor shall any other rights or licenses not expressly granted hereunder arise by implication, estoppel or otherwise with respect to the Covered Code; (ii) any trade name, trademark or service mark whatsoever, including without limitation any related right for purposes of endorsement or promotion of products derived from the Covered Code, without prior written permission of SGI; or (iii) any title to or ownership of the Original Code, which shall at all times remains with SGI. All rights in the Original Code not expressly granted under this License are reserved.
+6. Compliance with Laws; Non-Infringement. There are various worldwide laws, regulations, and executive orders applicable to dispositions of Covered Code, including without limitation export, re-export, and import control laws, regulations, and executive orders, of the U.S. government and other countries, and Recipient is reminded it is obliged to obey such laws, regulations, and executive orders. Recipient may not distribute Covered Code that (i) in any way infringes (directly or contributorily) any intellectual property rights of any kind of any other person or entity or (ii) breaches any representation or warranty, express, implied or statutory, to which, under any applicable law, it might be deemed to have been subject.
+7. Claims of Infringement. If Recipient learns of any third party claim that any disposition of Covered Code and/or functionality wholly or partially infringes the third party's intellectual property rights, Recipient will promptly notify SGI of such claim.
+8. Versions of the License. SGI may publish revised and/or new versions of the License from time to time, each with a distinguishing version number. Once Covered Code has been published under a particular version of the License, Recipient may, for the duration of the license, continue to use it under the terms of that version, or choose to use such Covered Code under the terms of any subsequent version published by SGI. Subject to the provisions of Sections 3 and 4 of this License, only SGI may modify the terms applicable to Covered Code created under this License.
+9. DISCLAIMER OF WARRANTY. COVERED CODE IS PROVIDED "AS IS." ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS ARE DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. SGI ASSUMES NO RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE. SHOULD THE SOFTWARE PROVE DEFECTIVE IN ANY RESPECT, SGI ASSUMES NO COST OR LIABILITY FOR SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY IS AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT SUBJECT TO THIS DISCLAIMER.
+10. LIMITATION OF LIABILITY. UNDER NO CIRCUMSTANCES NOR LEGAL THEORY, WHETHER TORT (INCLUDING, WITHOUT LIMITATION, NEGLIGENCE OR STRICT LIABILITY), CONTRACT, OR OTHERWISE, SHALL SGI OR ANY SGI LICENSOR BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, LOSS OF DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SGI's NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THAT EXCLUSION AND LIMITATION MAY NOT APPLY TO RECIPIENT.
+11. Indemnity. Recipient shall be solely responsible for damages arising, directly or indirectly, out of its utilization of rights under this License. Recipient will defend, indemnify and hold harmless Silicon Graphics, Inc. from and against any loss, liability, damages, costs or expenses (including the payment of reasonable attorneys fees) arising out of Recipient's use, modification, reproduction and distribution of the Covered Code or out of any representation or warranty made by Recipient.
+12. U.S. Government End Users. The Covered Code is a "commercial item" consisting of "commercial computer software" as such terms are defined in title 48 of the Code of Federal Regulations and all U.S. Government End Users acquire only the rights set forth in this License and are subject to the terms of this License.
+13. Miscellaneous. This License represents the complete agreement concerning the its subject matter. If any provision of this License is held to be unenforceable, such provision shall be reformed so as to achieve as nearly as possible the same legal and economic effect as the original provision and the remainder of this License will remain in effect. This License shall be governed by and construed in accordance with the laws of the United States and the State of California as applied to agreements entered into and to be performed entirely within California between California residents. Any litigation relating to this License shall be subject to the exclusive jurisdiction of the Federal Courts of the Northern District of California (or, absent subject matter jurisdiction in such courts, the courts of the State of California), with venue lying exclusively in Santa Clara County, California, with the losing party responsible for costs, including without limitation, court costs and reasonable attorneys fees and expenses. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any law or regulation that provides that the language of a contract shall be construed against the drafter shall not apply to this License.
+Exhibit A
+License Applicability. Except to the extent portions of this file are made subject to an alternative license as permitted in the SGI Free Software License B, Version 1.1 (the "License"), the contents of this file are subject only to the provisions of the License. You may not use this file except in compliance with the License. You may obtain a copy of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+http://oss.sgi.com/projects/FreeB
+Note that, as provided in the License, the Software is distributed on an "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+Original Code. The Original Code is: [name of software, version number, and release date], developed by Silicon Graphics, Inc. The Original Code is Copyright (c) [dates of first publication, as appearing in the Notice in the Original Code] Silicon Graphics, Inc. Copyright in any portions created by third parties is as indicated elsewhere herein. All Rights Reserved.
+Additional Notice Provisions: [such additional provisions, if any, as appear in the Notice in the Original Code under the heading "Additional Notice Provisions"]
--- /dev/null
+<html>
+<body>
+
+<h1>The zlib/libpng License</h1>
+
+<tt>
+
+<p>Copyright (c) <year> <copyright holders></p>
+
+ <p>This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.</p>
+
+ <p>Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:</p>
+
+<blockquote>
+
+ <p>1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.</p>
+
+ <p>2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.</p>
+
+ <p>3. This notice may not be removed or altered from any source
+ distribution.</p>
+
+</blockquote>
+
+</tt>
+</body>
+</html>
\ No newline at end of file
--- /dev/null
+<html>
+<head>
+<title></title>
+<link rel="styleSheet" href="style.css" type="text/css">
+</head>
+<body>
+
+<h1>BlitzMax tutorials and articles</h1>
+
+<ul>
+<li><a href=#memory>BlitzMax Memory management</a><br>
+<br>
+<li><a href=#oointro>Introduction to OO programming</a><br>
+<br>
+<li><a href=#nehetuts>The first 5 'Nehe' OpenGL tutorials</a><br>
+<br>
+<li><a href=#streams>Writing custom stream handlers (advanced)</a><br>
+</ul>
+
+<hr>
+
+<div id=memory>
+<h1>BlitzMax Memory management - or, "where did Delete go?!?"</h1>
+
+As many users from a Blitz3D or BlitzPlus background have noticed, BlitzMax does not include a 'Delete' command.<br>
+<br>
+This appears to have caused a great deal of bemusement and head scratching in the Blitz community, which this tutorial will attempt to clear up.<br>
+<br>
+Note that any references to Blitz3D in the rest of this document also apply to BlitzPlus.<br>
+<br>
+<h2>The BASICs</h2>
+
+First up, let's have a look at what Blitz3D's Delete command actually does. It really serves 2 purposes:
+<ol>
+<li>The object is removed from its 'type list'.
+<li>The memory used by the object is returned to the system - this is called 'deallocating' the object.
+</ol>
+Step 1 is necessary due to Blitz3D's type list system, which automatically adds all New-ed objects to an internal global type list.<br>
+<br>
+Step 2 is necessary to prevent memory leaks. A memory leak is when your program has allocated a chunk of memory, used it for something, and then forgotten to deallocate it when it is no longer useful. Since computers have a finite amount of memory, this will eventually cause problems if it happens often enough!<br>
+<br>
+The first thing about these 2 steps to note is that the global type list system is no longer present in BlitzMax, so step 1 is now completely up to the user - if you have added an object to a linked list (or lists), it is up to you to remove it.<br>
+<br>
+If all you are wanting to achieve is a system similar to Blitz3D's type list system, then this is as simple as using ListAddLast immediately after you have created an object using New, and using ListRemove immediately before deleting it using Delete - oops, there is no Delete! Ok, using ListRemove *instead* of Delete!<br>
+<br>
+This still leaves the question of deallocating the object's memory, and this is done in BlitzMax using a 'garbage collector'. A garbage collector
+automatically scans for 'dead objects' every now and then and releases the memory they occupied.<br>
+<br>
+Note that the issue of deallocating objects is completely separate from the issue of type lists. Yes, if you forget to remove an object from a list it will remain 'live', but this is the same as forgetting to delete an object in Blitz3D!<br>
+<br>
+One final complicating issue: BlitzMax includes a feature that allows you to assign objects to integers. This feature exists mainly to simplify things for beginners so, instead of...
+<pre class=code>
+Local image:TImage=LoadImage( "somepic.png" ) 'normal object to object assignment...
+</pre>
+...you can just go...
+<pre class=code>
+Local image=LoadImage( "somepic.png" ) 'assigning an object to an int! What gives?
+</pre>
+However, if you are using this feature in your programs, you *must* later 'free' the object yourself using Release...
+<pre class=code>
+Release image
+</pre>
+You can therefore think of Release as being similar to Blitz3D's FreeImage (or FreeSound, FreeThis, FreeThat etc).<br>
+<br>
+All-in-all, it's probably best to avoid object-to-int assignments altogther if you are concerned about memory leaks.<br>
+<br>
+And that's it! Well, not quite, but the above should be enough information for you to be able to write leak-free programs with. I'll go into some of the nitty gritty details below...<br>
+<br>
+<h2>The nitty gritty part 1 : dead objects </h2>
+
+Ok, lets have a look at the question of 'what exactly is a dead object'? Well, a dead object is an object that is no longer referred to by any live objects. In other words, dead objects are objects your program can no longer 'see' - they are therefore completely useless to your program and can be safely deallocated.<br>
+<br>
+Here are a few examples of when objects become 'dead':<br>
+<pre class=code>
+'example 1
+Local p:MyType=New MyType 'allocate object 1
+p=Null 'object 1 is now dead
+
+'example 2
+Local p:MyType=New MyType 'allocate object 1
+Local q:MyType=New MyType 'allocate object 2
+p=q 'object 1 is now dead, object 2 is still alive
+
+'example 3
+Local p:MyType[1] 'allocate object 1 (an array object)
+p[0]=New MyType 'allocate object 2
+p=Null 'object 1 and object 2 both now dead
+
+'example 4
+Local p:MyType=New MyType 'allocate object 1
+p.my_type=New MyType 'allocate object 2
+p.my_type=New MyType 'allocate object 3 - object 2 now dead
+Local q:MyType=p.my_type
+p=Null 'object 1 and object 2 dead, object 3 still alive thanks to the q assignment above
+</pre>
+After seeing this sort of thing, there is a tendancy for people to stick '=Null' code all over the place in an attempt to 'force' objects to become dead - but this is generally not necessary.<br>
+<br>
+Sooner or later, all variables will either be overwritten by new values, or (in the case of Locals and Fields) simply go out of scope. Both of these actions are enough to ensure that dead objects will be correctly detected and deallocated.<br>
+<br>
+Probably the only good reason to use '=Null' is in the case of global variables, when you know that a global variable will not be modified for a long time, but it also happens to be keeping a large chunk of memory alive that is no longer useful to your program. In this case, an '=Null' is probably the right choice.<br>
+<br>
+BlitzMax also provides the GCMemAlloced() function to determine the amount of memory currently used by your program.<br>
+</div>
+<br>
+<hr>
+
+<div id=oointro>
+<h1>Crash course in OO programming for Blitz coders</h1>
+
+Welcome to a crash course in OO programming for Blitz coders!<br>
+<br>
+OO stands for 'Object Oriented'. OO is a programming paradigm or 'way of thinking' that has taken on almost mythical proportions over the years yet, somewhat unusually for the world of computing, is actually quite useful!<br>
+<br>
+*Disclaimer* - OO coding means different things to different people. This article is strongly swayed by my own experience with OO coding and what I like and find useful about it. The actual 'meaning' of OO is almost as fun to argue about as whether the universe is infinite or not.<br>
+<br>
+First up, OO coding has spawned a bunch of initially confusing but actually quite sensible buzzwords, including such gems as:<br>
+<br>
+Inheritance<br>
+Polymorphism<br>
+Virtual<br>
+Abstract<br>
+Concrete<br>
+Type<br>
+Class<br>
+Object<br>
+Instance<br>
+Base Class<br>
+Derived Class<br>
+Super Class<br>
+Sub Class<br>
+<br>
+Scary stuff!<br>
+<br>
+Well, not really. Never forget that behind the scenes its all just a bunch of bits and bytes and Ifs and Adds and Gotos.<br>
+<br>
+As always, its easier than the guys who get paid megabucks to do it would have us think.<br>
+<br>
+<h2>Part 1 : Inheritance</h2>
+
+Inheritance is a way of 'composing' objects from other objects.<br>
+<br>
+This is already possible in procedural Blitz. Consider the following code...
+<pre class=code>
+Type Part1
+Field x,y,z
+End Type
+
+Type Part2
+Field p1.Part1
+Field p,q,r
+End Type
+
+Function UpdatePart1( t:Part1 )
+'Do something clever with a Part1.
+End Function
+</pre>
+This is one way of composing objects. Part2 'contains' a Part1, via the p1 field.<br>
+<br>
+If you've got a Part2 object and want to call UpdatePart1(), you can grab the p1 field and use it in the function call, for example:
+<pre class=code>
+Local t:Part2=New Part2
+t.p1=New Part1 'need to create it!
+UpdatePart1 t.p1
+</pre>
+OO inheritance provides a different (not always better!) way to do this:
+<pre class=code>
+Type Base
+Field x,y,z
+End Type
+
+Type Derived Extends Base
+Field p,q,r
+End Type
+
+Function UpdateBase( t:Base )
+'Do something clever with a Base object.
+End Function
+</pre>
+Ok, we've already hit our first OO buzzwords - Base and Derived. These are not special keywords, they are just names I chose for these types. Bear with me and hopefully you'll get some idea of why I chose them.<br>
+<br>
+First up, The Base type is just the same as the procedural Part1 type - no problem there.<br>
+<br>
+The Derived type, however, introduces us to the Extends keyword, which is used to indicate inheritance.<br>
+<br>
+Extends always appears after 'Type whatever', and means that the type you are describing extends a different, existing type. So the type you are describing is composed not only of the fields and stuff you declare, but also the fields and stuff of the type you are extending!<br>
+<br>
+This means that the Derived type above actually has the additional fields x,y,z - these have been 'inherited' from the Base type. It is then perfectly legal for you to code up something like:
+<pre class=code>
+Local t:Derived=New Derived
+
+t.x=100 'x inherited from Base - thanks Base, you rock!
+</pre>
+Another way to think of it is the Derived type 'is a' Base type, but with some extra stuff. In fact, in OO terminology 'IsA' is often used to indicate inheritance or inheritance-like properties.<br>
+<br>
+Now it gets a bit interesting. Since our Derived type 'is a' Base type, its perfectly legal to use it where ever a Base type is expected - for example, the UpdateBase() function:
+<pre class=code>
+Local MyDerived:Derived=New Derived 'fine...
+UpdateBase MyDerived 'What?!?
+</pre>
+Initially, this looks *wrong* - 'Type mismatch error' looms! But in OO code its fine. Since Derived extends Base, its OK to use a Derived where ever a Base is expected - even in assignments:
+<pre class=code>
+Local MyBase:Base=New Derived 'Okay, because Derived extends (or 'Is a') Base.
+</pre>
+In addition, there could be many types extending Base, and each of these could be used interchangeably with Base.<br>
+<br>
+Hopefully the terms 'Base' and 'Derived' now mean something. The Derived type is derived from, or 'comes from', the Base type.<br>
+<br>
+Remember that Base and Derived are just names I chose for this example. In real world coding, you'd use useful names, for example:
+<pre class=code>
+Type Actor
+Field x,y,z
+End Type
+
+Type Player Extends Actor
+Field lives,score
+End Type
+</pre>
+But still, you can think of Actor as the base type, and Player as the derived type - a Player is derived from an Actor.<br>
+<br>
+Its also perfectly legal (and very useful!) to extend extended types, for example:
+<pre class=code>
+Type Actor
+Field x,y,z
+End Type
+
+Type Player Extends Actor
+Field lives,score
+End Type
+
+Type Enemy Extends Actor
+Field mood
+End Type
+
+Type Troll Extends Enemy
+Field grudge_quotient
+End Type
+
+Type Ghoul Extends Enemy
+Field lust_for_life
+End Type
+</pre>
+So, if you've got a function like UpdateActor( t:Actor ), you can pass it any of the above types as they are all ultimately derived from Actor.<br>
+<br>
+Similarly, a RethinkMood( t:Enemy ) function could be used with any of the bad guys (Enemy, Troll or Ghoul) - but not with players, as Player is not derived from Enemy.<br>
+<br>
+This is what is known as a 'class hierarchy' - a 'tree' of types.<br>
+<br>
+Stay tuned for part 2...!
+</div>
+<br>
+<hr>
+
+<div id=nehetuts>
+
+<h1>The Nehe OpenGL tutorials</h1>
+The NeHe tutorials are a popular collection of OpenGL programming tutorials.<br>
+<br>
+Here are the first 5 NeHe tutorials converted to BlitzMax:
+<ul>
+<li><a href="../nehe_01.bmx">Nehe_01</a>
+<li><a href="../nehe_02.bmx">Nehe_02</a>
+<li><a href="../nehe_03.bmx">Nehe_03</a>
+<li><a href="../nehe_04.bmx">Nehe_04</a>
+<li><a href="../nehe_05.bmx">Nehe_05</a>
+</ul>
+For more information on these tutorials and to learn lots about OpenGL, check out the Nehe website at
+<a href=http://nege.gamedev.net target=_blank>http://nehe.gamedev.net</a>.
+
+</div>
+<br>
+<hr>
+
+<div id=streams>
+
+<h1>Writing custom stream handlers</h1>
+
+BlitzMax's OO design allows you to add your own kinds of streams to the system.<br>
+<br>
+In this tutorial we will concentrate on creating a custom stream that simply converts any text written to or read from the stream to uppercase. Not very useful, but a good starting point for your own experiments!<br>
+<br>
+The source code for this tutorial can be found <a href=upperstream.bmx>here</a>.<br>
+<br>
+To create a custom stream, you will need to create a new user type that extends the TStream type. Your type will also need to implement at least the following methods:
+<pre class=code>
+Type TMyStream extends TStream
+ Method Eof()
+ 'code to return end-of-file status here...
+ End Method
+
+ Method Pos()
+ 'code to return current stream position here...
+ End Method
+
+ Method Size()
+ 'code to return size of stream here...
+ End Method
+
+ Method Seek( pos )
+ 'code to seek to a position in a stream here...
+ End Method
+
+ Method Flush()
+ 'code to flush stream output here...
+ End Method
+
+ Method Close()
+ 'code to close stream here...
+ End Method
+
+ Method Read( buf:Byte Ptr,count )
+ 'code to read from stream here...
+ End Method
+
+ Method Write( buf:Byte Ptr,count )
+ 'code to write to a stream here...
+ End Method
+End Type
+</pre>
+Whew, that's a fair bit of work! Fortunately, BlitzMax can simplify things a bit for us in this case.<br>
+<br>
+Many types of stream really just modify the behaviour of an existing stream. For example, the BlitzMax <a href=../../mod/brl.mod/endianstream.mod/doc/commands.html>endian stream</a> works by modifying the behaviour of an existing stream - in a sense, it 'wraps' an existing stream. Our goal of creating an 'uppercase' stream also applies here.<br>
+<br>
+BlitzMax provides the TStreamWrapper type for exactly this situtation. TStreamWrapper extends TStream, but also maintains an internal 'underlying' stream. Whenever you call a method of TStreamWrapper, it will simply 'forward' the method call to the underlying stream.<br>
+<br>
+This is ideal for situations where you only want to modify the behaviour of a few of the stream methods. In our case, we want to modify the Read and Write methods to convert text to uppercase - and here's how it's done:
+<pre class=code>
+Type TUpperStream Extends TStreamWrapper
+
+ Method Read( buf:Byte Ptr,count )
+ 'Read data from the underlying stream
+ count=Super.Read( buf,count )
+ 'Convert the data to uppercase
+ For Local i=0 Until count
+ If buf[i]>=Asc("a") And Buf[i]<=Asc("z")
+ buf[i]=buf[i]-Asc("a")+Asc("A")
+ EndIf
+ Next
+ 'Done!
+ Return count
+ End Method
+
+ Method Write( buf:Byte Ptr,count )
+ 'Copy the data to a new buffer, converting to uppercase as we go
+ Local tmp:Byte[count]
+ For Local i=0 Until count
+ If buf[i]>=Asc("a") And buf[i]<=Asc("z")
+ tmp[i]=buf[i]-Asc("a")+Asc("A")
+ Else
+ tmp[i]=buf[i]
+ EndIf
+ Next
+ 'Write the data to the underlying stream
+ Return Super.Write( tmp,count )
+ End Method
+
+ Function Create:TUpperStream( stream:TStream )
+ Local t:TUpperStream=New TUpperStream
+ 'SetStream is a TStreamWrapper method that sets the underlying stream.
+ t.SetStream stream
+ Return t
+ End Function
+
+End Type
+</pre>
+One important note: The Read method modifies the data 'in place'. However, the Write method makes a copy of the data. This is because, although we know it's safe to modify the read buffer - in fact, it will already be modified by the time we get to it - we can't be sure it's safe to modify the write buffer. The caller of 'Write' may well be expecting the contents of the buffer to remain unchanged.<br>
+<br>
+Now let's see it in action:
+<pre>
+'Create a tmp file and write some text to it.
+Local tmp:TStream=WriteStream( "tmp" )
+tmp.WriteLine "A little example..."
+tmp.WriteLine "of our cool TUpperStream!"
+tmp.Close
+
+'Open tmp file again, and wrap it with a TUpperStream
+tmp:TStream=ReadStream( "tmp" )
+Local upperizer:TUpperStream=TUpperStream.Create( tmp )
+
+'Dump file contents
+While Not upperizer.Eof()
+ Print upperizer.ReadLine()
+Wend
+
+'Close files
+upperizer.Close
+tmp.Close
+</pre>
+This demo creates a text file and reads it back through a TUpperStream, which converts the file contents to uppercase while it's being read. If you inspect the tmp file, it's still actually in mixed case - but it's just as easy to write through the TUpperCase stream and end up with an uppercase file.<br>
+<br>
+Finally, the icing on the cake: adding our TUpperStream to the system so that it can be used transparently:
+<pre class=code>
+Type TUpperStreamFactory Extends TStreamFactory
+
+ Method CreateStream:TUpperStream( url:Object,proto$,path$,readable,writeable )
+ If proto$<>"uppercase" Return
+ Local stream:TStream=OpenStream( path,readable,writeable )
+ If stream Return TUpperStream.Create( stream )
+ End Method
+
+End Type
+
+New TUpperStreamFactory
+</pre>
+And a demo...
+<pre>
+'Open a TUpperStream tmp file using WriteStream
+Local tmp2:TStream=WriteStream( "uppercase::tmp" )
+tmp2.WriteLine "Another little example..."
+tmp2.WriteLine "of our even cooler TUpperStream!"
+tmp2.Close
+
+'Read back and dump tmp file
+tmp2:TStream=ReadStream( "tmp" )
+While Not tmp2.Eof()
+ Print tmp2.ReadLine()
+Wend
+tmp2.Close
+</pre>
+</div>
+
+</body>
+</html>
\ No newline at end of file
--- /dev/null
+<html>
+<head>
+<title></title>
+<link rel="styleSheet" href="../bmxstyle.css" type="text/css">
+</head>
+<body>
+<h1>MaxGUI Overview</h1>
+
+<ul>
+<li>Introduction
+<li>Getting Started
+<li>Gadget Layout
+<li>Crossplatform Issues
+<li>Using an EventHook
+<li>Using a Canvas
+<li>Event Hook based Rendering
+<li>Porting from BlitzPlus
+<li>The New Modules
+<li>Under the Hood
+<li>Extending MaxGui
+</ul>
+
+<hr>
+
+<h3>Introduction</h3>
+
+The MaxGui module provides commands to build user interfaces
+for applications programmed in BlitzMax.
+<p>
+The command set originates from the original BlitzPlus "Gadget"
+based names providing a healthy amount of backward
+compatability for users wishing to port code developed in
+BlitzPlus.
+
+
+<h3>Getting Started</h3>
+
+
+The following program opens a small window on the desktop
+that ends when the window is closed.
+<p>
+The code beginning at "While True" is the main event loop
+of the program, it repeats forever waiting for an Event
+to happen, printing the event's details to the output window
+and ending if the event has the ID of EVENT_WINDOWCLOSE.
+<pre class=code>
+' createwindow.bmx
+
+Strict
+
+Import MaxGUI.Drivers
+
+Local window:TGadget
+
+window=CreateWindow("My Window",40,40,320,240)
+
+While True
+ WaitEvent
+ Print CurrentEvent.ToString()
+ Select EventID()
+ Case EVENT_WINDOWCLOSE
+ End
+ End Select
+Wend
+</pre>
+Try moving and sizing the window while the program is running
+and you will see the details of the events that occur printed
+in the debug window of BlitzMax.
+<p>
+Try also modifying the "window=" line in the program with:
+<pre class=code>
+window=CreateWindow("My Window",40,40,320,240,Null,WINDOW_TITLEBAR)
+</pre>
+which will create a Window with only a title bar and no status or
+menu bars. See the documentation for CreateWindow for more details
+of the Window styles supported by MaxGui.
+<p>
+The MaxGui documentation contains working examples for each of
+commands that create gadgets including CreateButton, CreateCanvas,
+CreateComboBox, CreateHTMLView, CreateLabel, CreateListBox,
+CreateMenu, CreatePanel, CreateProgBar, CreateSlider, CreateTabber,
+CreateTextField, CreateToolBar and CreateTreeView.
+<p>
+
+<h3>Gadget Layout</h3>
+<p>
+A Gadget in MaxGui is given pixel coordinates when it is created
+that positions it in it's parent's client area. The client area of
+a Window gadget is inside the window's borders not including the
+space used by any Status or Menu bars.
+<p>
+If a Window is resized MaxGui uses any children's layout settings
+to reposition them within the new size of it's client area.
+<p>
+The SetGadgetLayout is used to control how the Gadget is repositioned
+when it's parent is resized.
+<p>
+By considering each edge of the Gadget independently, the MaxGui
+layout engine repositions each gadget according to each edge's
+rule where the rule is
+<p>
+EDGE_CENTERED - The edge remains a fixed distance from the center of the parent<br>
+EDGE_ALIGNED - The edge is a locked distance away from it's parent's corresponding edge<br>
+EDGE_RELATIVE - The edge remains a proportional distance from the parent's 2 edges<br>
+<p>
+The following code demonstrates a common case of creating a panel
+in a window the size of the window's client area and locking the
+distance of each edge to the correspong edge of the parent window
+(EDGE_ALIGNED rule). The result is that the panel is automatically sized by
+MaxGui when the window is resized filling the entire client area.
+<pre class=code>
+Strict
+
+Import MaxGUI.Drivers
+
+Local window:TGadget
+Local panel:TGadget
+
+window=CreateWindow("My Window",40,40,320,240)
+
+panel=CreatePanel(0,0,ClientWidth(window),ClientHeight(window),window)
+SetGadgetColor panel,200,100,100
+SetGadgetLayout panel,EDGE_ALIGNED,EDGE_ALIGNED,EDGE_ALIGNED,EDGE_ALIGNED
+
+While True
+ WaitEvent
+ Print CurrentEvent.ToString()
+ Select EventID()
+ Case EVENT_WINDOWCLOSE
+ End
+ End Select
+Wend
+</pre>
+By removing the line of code with the SetGadetLayout command you can view the default
+EDGE_CENTERED rule in effect on all edges with the panel retaining it's size
+due to all it's edges being kept a fixed distance from the center
+of the window.
+<p>
+To view rule EDGE_RELATIVE in effect modify the SetGadgetLayout command to read
+"SetGadgetLayout panel,EDGE_RELATIVE,EDGE_RELATIVE,EDGE_RELATIVE,EDGE_RELATIVE".
+<p>
+But wait, there is no discernable change in the resizing behavior between
+rule EDGE_ALIGNED and rule EDGE_RELATIVE???
+<p>
+Unless the panel is created inset from the window client such as
+the result of the following modification:
+<pre class=code>
+panel=CreatePanel(10,10,ClientWidth(window)-20,ClientHeight(window)-20,window)
+</pre>
+you will note the edges are infact being kept a proportional distance
+from the parent's 2 edges when the window is resized.
+<p>
+The fact is that EDGE_ALIGNED and EDGE_RELATIVE have the same effect on Gadget
+edges when the edges are created on the borders of their parent's client area.
+<p>
+
+<h3>Crossplatform Issues</h3>
+<p>
+In general the MaxGUI module should perform identically on Windows,
+Apple and Linux machines. However some care and attention is required
+when testing in regards to how your application will look on each
+platform.
+<p>
+The following are a few issues that if considered should hopefully
+enable you to publish programs that look and function well on a wide
+variety of systems.
+<p>
+Recomended gadget dimensions.
+<p>
+<ul>
+<li>Buttons and ComboBoxes should be 24 pixels high.
+<p>
+Shorter buttons are possible in Windows but they will become cropped
+on Apple systems so it is recomended that when using the default font
+buttons should be created with a height of 24 pixels.
+<p>
+<li>TextFields should be 20 pixels high and accompanying labels lowered 4 pixels.
+<p>
+Again, using the default font settings, the above rule should produce
+good results on all platforms. Often labels will be placed to the left
+or right of TextFields, in which case they should be set 4 pixels lower
+down the screen in order to correctly align with TextFields.
+<p>
+<li>Separate fields in a form by 30 pixels.
+<p>
+When creating a form with multiple TextField gadgets start each
+row 30 pixels below the y position of the previous gadget's positions.
+</ul>
+<p>
+Use the WINDOW_CLIENTCOORDS flag when dependent on client size.
+<p>
+If you are using a fixed size window specify it's size based on the
+required client area using the WINDOW_CLIENTCOORDS style.
+<p>
+Specifying a window's size in the default frame coordinates will
+result in a client area that may be different on different machines
+due to a number of factors including both the version of the computer's
+operating system and certain user preference outside your control.
+<p>
+<p>
+<h3>Using an EventHook</h3>
+<p>
+As an alternative to developing applications that have a single
+main loop that waits then processes events from an eventqueue
+the AddHook command allows a callback function to be used
+to process events as they happen.
+<p>
+This is important for two type of events.
+<p>
+EVENT_GADGETACTION events produced by Slider gadgets with the
+original SLIDER_SCROLLBAR style and EVENT_WINDOWRESIZE events
+that occur when the user is resizing a Window both require
+a hooked type of event processing for best results.
+In both these situations most OS's go into a "modal"
+loop that means a WaitEvent command will only return once
+the user releases the mouse button but with Event hooks
+the code can be called directly from within the OS's own
+modal loop.
+<p>
+The other type of event is EVENT_GADGETPAINT which is generated
+whenever the operating system needs to redraw a Canvas gadget.
+When hooked, drawing code can be executed at the time of the
+event rather than later when the OS returns control to the
+main program, at which time it may have already drawn other
+content above the Canvas.
+<p>
+
+<h3>Using a Canvas</h3>
+<p>
+The following code is a simple example of using Max2D to
+render dynamically into a Canvas Gadget...
+<pre class=code>
+' createcanvas.bmx
+
+Strict
+
+Import MaxGUI.Drivers
+
+Global GAME_WIDTH=320
+Global GAME_HEIGHT=240
+
+' create a centered window with client size GAME_WIDTH,GAME_HEIGHT
+
+Local wx=(GadgetWidth(Desktop())-GAME_WIDTH)/2
+Local wy=(GadgetHeight(Desktop())-GAME_HEIGHT)/2
+
+Local window:TGadget=CreateWindow("My Canvas",wx,wy,GAME_WIDTH,GAME_HEIGHT,Null,WINDOW_TITLEBAR|WINDOW_CLIENTCOORDS)
+
+' create a canvas for our game
+
+Local canvas:TGadget=CreateCanvas(0,0,320,240,window)
+
+' create an update timer
+
+CreateTimer 60
+
+While WaitEvent()
+ Select EventID()
+ Case EVENT_TIMERTICK
+ RedrawGadget canvas
+
+ Case EVENT_GADGETPAINT
+ Local g=CanvasGraphics(canvas)
+ SetGraphics g
+ SetOrigin 160,120
+ SetLineWidth 5
+ Cls
+ Local t=MilliSecs()
+ DrawLine 0,0,120*Cos(t),120*Sin(t)
+ DrawLine 0,0,80*Cos(t/60),80*Sin(t/60)
+ Flip
+
+ Case EVENT_WINDOWCLOSE
+ FreeGadget canvas
+ End
+
+ Case EVENT_APPTERMINATE
+ End
+ End Select
+Wend
+</pre>
+The above code creates a timer that causes an event to occur
+at 60hz (ticks per second).
+<p>
+Each time an EVENT_TIMERTICK is received by the program's main
+event loop it calls RedrawGadget which tells the system to redraw
+our canvas gadget.
+<p>
+The code following the Case EVENT_GADGETPAINT above is where
+the actual drawing takes place.
+<p>
+- of interest -
+<p>
+If you remove two lines of the above code that contain the
+"RedrawGadget canvas" and "Case EVENT_GADGETPAINT" the program
+still appears to function normally.
+<p>
+This is because MaxGUI infact allows you to draw to a canvas
+when ever you want. Drawing in response to an EVENT_GADGETPAINT
+however is better behavior as no drawing code is executed if
+the canvas is obscured or the application has a low refresh rate
+in which case it will be still asked to redraw itself on the
+event an obscured canvas is revealed by window movement from
+above.
+<p>
+
+<h3>Event Hook based Rendering</h3>
+<p>
+As mentioned above the best way to manage redrawing a Canvas
+gadget is with an EventHook.
+<p>
+The following example uses an EventHook to handle events
+at the time of occurance rather than from the WaitEvent()
+queue. You will notice at the bottom of the program that
+infact the main loop does nothing but WaitEvent and all
+the event handling is done inside the TApplet Type.
+<p>
+<pre class=code>
+' rendering a canvas using an EventHook based Applet Type
+
+Strict
+
+Import MaxGUI.Drivers
+
+Type TApplet
+
+ Field window:TGadget
+ Field canvas:TGadget
+ Field timer:TTimer
+
+ Method Render()
+ Local x,y,width,height,t,i
+ width=GraphicsWidth()
+ height=GraphicsHeight()
+ t=MilliSecs()
+ SetBlend ALPHABLEND
+ SetViewport 0,0,width,height
+ SetClsColor 0,0,0
+ SetOrigin width/2,height/2
+ Cls
+ For x=-width/2 To width/2 Step 2
+ y=Sin(t*0.3+x)*height/2
+ DrawLine 0,0,x,y
+ Next
+ End Method
+
+ Method OnEvent(event:TEvent)
+ Select event.id
+ Case EVENT_WINDOWCLOSE
+ End
+ Case EVENT_TIMERTICK
+ RedrawGadget canvas
+ Case EVENT_GADGETPAINT
+ SetGraphics CanvasGraphics(canvas)
+ Render
+ Flip
+ End Select
+ End Method
+
+ Function eventhook:Object(id,data:Object,context:Object)
+ Local event:TEvent
+ Local app:TApplet
+ event=TEvent(data)
+ app=TApplet(context)
+ app.OnEvent event
+ End Function
+
+ Method Create:TApplet(name$)
+ Local a:TApplet
+ Local w,h
+ window=CreateWindow(name,20,20,512,512)
+ w=ClientWidth(window)
+ h=ClientHeight(window)
+ canvas=CreateCanvas(0,0,w,h,window)
+ canvas.SetLayout 1,1,1,1
+ timer=CreateTimer(100)
+ AddHook EmitEventHook,eventhook,Self
+ Return Self
+ End Method
+
+End Type
+
+AutoMidHandle True
+
+Local applet:TApplet
+
+applet=New TApplet.Create("Render Applet")
+
+While True
+ WaitEvent
+Wend
+</pre>
+<p>
+Unfortunately I have obfiscated (made obscure) the
+function of the event hook by wrapping it in an
+Applet object and I have started using big words in
+my sentences.
+<p>
+To be as concise as possible, the TApplet Type declares
+a Class that features an OnEvent Method that with some
+magic in it's constructor (the Create() Method) provides
+an object oriented way for our program to collect events.
+<p>
+Our TApplet implements the rendering sequence
+as featured in the previous example but because
+it does so based on a Hook responds in a more
+well behaved manner when the OS wishes to redraw the
+desktop when it is made visible by some user action
+or told to refresh with the RedrawGadget command.
+
+<h3>Porting from BlitzPlus</h3>
+<p>
+The following are a few issues that you may encounter when
+porting code from BlitzPlus.
+<p>
+
+<h4>Event Codes</h4>
+<p>
+The codes returned by the WaitEvent and EventID commands
+are not the same as BlitzPlus. See the Event Objects docs
+for a list of the constants used in MaxGUI. Numerical
+values have not been documented in order to encourage
+users to use the correct EVENT_NAMES.
+<p>
+New events in MaxGUI include
+<p>
+EVENT_HOTKEYHIT - see SetHotKeyEvent
+<p>
+EVENT_WINDOWACCEPT - a file has been dragged onto the window
+<p>
+EVENT_GADGETPAINT - a canvas gadget needs redrawing
+<p>
+EVENT_GADGETSELECT - the selected state of a TextArea has changed
+<p>
+EVENT_GADGETMENU - the user has clicked the right button on this gadget
+<p>
+EVENT_GADGETOPEN - a node in a TreeViewNode has been expanded
+<p>
+EVENT_GADGETCLOSE - a node in a TreeViewNode has been collapsed
+<p>
+EVENT_GADGETDONE - an HTMLView has finished loading a page
+<p>
+
+<h4>TextArea filters</h4>
+<p>
+TextAreas no longer generate Key Up, Key Down or Key Stroke events.
+<p>
+Instead the new SetGadgetFilter command can be used to install
+a callback routine that is called each time the user presses
+a key with the callback able to accept or reject each key
+by returning either True or False respectively.
+<p>
+
+<h4>Popup Menus</h4>
+
+There is a new PopupWindowMenu command that can be used
+for implementing context menus commonly activated by the
+right mouse button (reported as an EVENT_GADGETMENU for most
+gadgets).
+
+
+<h3>The New Modules</h3>
+<p>
+The three platform specific modules that ship with MaxGui are
+Win32MaxGui.mod, CocoaMaxGui.mod and FLTKMaxGui.mod which provide
+native implementations of MaxGui for Windows, Apple MacOS and
+Linux platforms respectively.
+<p>
+The new Event.mod and EventQueue.mod modules are extensions
+to the BlitzMax system. BlitzMax events provide the necessary
+mechanics of communicating with a MaxGui based application as well
+as providing all BlitzMax applications with events such as
+EVENT_APPSUSPEND, EVENT_APPRESUME and EVENT_APPTERMINATE.
+<p>
+The commands WaitEvent, PeekEvent and PollEvent are the primary
+commands for receiving Events in BlitzMax programs and PostEvent
+can be used for generating Events.
+<p>
+
+<h3>Under the Hood</h3>
+<p>
+The Type TGadget is used in MaxGui to represent all 18 Gadget
+types including:
+<p>
+GADGET_DESKTOP
+GADGET_WINDOW
+GADGET_BUTTON
+GADGET_PANEL
+GADGET_TEXTFIELD
+GADGET_TEXTAREA
+GADGET_COMBOBOX
+GADGET_LISTBOX
+GADGET_TOOLBAR
+GADGET_TABBER
+GADGET_TREEVIEW
+GADGET_HTMLVIEW
+GADGET_LABEL
+GADGET_SLIDER
+GADGET_PROGBAR
+GADGET_MENUITEM
+GADGET_NODE
+GADGET_CANVAS
+<p>
+The TMaxGUIDriver Type defined in maxgui.driver represents the
+gadget factory which is created at startup to produce platform
+specific versions of TGadget on demand.
+<p>
+The type TGadget is actually an abstract class with TWin32Gadget,
+TCocoaGadget and TFLTKGadget being the actual types produced
+depending on the current TMaxGUIDriver.
+<p>
+The types TIconStrip, TGUIFont and TGadgetItem also provide
+an abstract interface to the platform specific implementations
+meaning that like TGadget itself, they are not intended to be
+extended by the user.
+<p>
+<p>
+
+
+<h3>Crossplatform vs Flexibility</h3>
+<p>
+It is expected that most users wanting to create custom
+gadgets that work well across all platforms will find
+the Panel and Canvas gadgets provide adequate Event reporting
+and rendering functionality from which to produce their
+own uber-gadgets.
+<p>
+The cross platform nature of MaxGUI means there are
+implications for those wishing to extend functionality by
+taking advantage of platform specific features that have
+no logical equivalent on other platforms.
+<p>
+Those wishing to do so are encouraged to implement such
+features in separate modules rather than making modifications
+to the BRL modules which are intended only to support the
+core cross platform MaxGUI functionality.
+<p>
+This of course does not mean the the current specification
+of MaxGUI is set in stone, rather, that those wanting to
+interface at a lower level with the Operating System of
+their choice do so in the privacy of their own modules
+rather than becoming muddied in the source of the lowlevel
+platform specific BRL modules.
+
+</body>
+</html>
--- /dev/null
+
+'Ok, this demo's a little pointless!
+'
+'All it does is show you how to open an OpenGL window
+'
+GLGraphics 640,480
+
+While Not KeyHit( KEY_ESCAPE )
+
+ glClear GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT 'Clear The Screen And The Depth Buffer
+
+ Flip
+
+Wend
\ No newline at end of file
--- /dev/null
+
+GLGraphics 640,480
+
+glEnable GL_DEPTH_TEST 'Enables Depth Testing
+
+glMatrixMode GL_PROJECTION 'Select The Projection Matrix
+glLoadIdentity 'Reset The Projection Matrix
+
+glFrustum -0.1, 0.1,-0.1, 0.1, 0.1, 100.0 'Setup The Projection Matrix Frustum
+
+glMatrixMode GL_MODELVIEW 'Select The ModelView Matrix
+glLoadIdentity 'Reset The ModelView Matrix
+
+While Not KeyHit( KEY_ESCAPE )
+
+ glClear GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT 'Clear The Screen And The Depth Buffer
+
+ glLoadIdentity 'Reset The ModelView Matrix
+ glTranslatef -1.5,0.0,-6.0 'Move Left 1.5 Units And Into The Screen 6.0
+
+ glBegin GL_TRIANGLES 'Drawing Using Triangles
+
+ glVertex3f 0.0, 1.0, 0.0 'Top
+ glVertex3f -1.0,-1.0, 0.0 'Bottom Left
+ glVertex3f 1.0,-1.0, 0.0 'Bottom Right
+
+ glEnd 'Finished Drawing The Triangle
+
+ glTranslatef 3.0,0.0,0.0 'Move Right 3 Units
+
+ glBegin GL_QUADS 'Draw A Quad
+
+ glVertex3f -1.0, 1.0, 0.0 'Top Left
+ glVertex3f 1.0, 1.0, 0.0 'Top Right
+ glVertex3f 1.0,-1.0, 0.0 'Bottom Right
+ glVertex3f-1.0,-1.0,0.0 'Bottom Left
+
+ glEnd 'Finished Drawing The Quad
+
+ Flip
+
+Wend
\ No newline at end of file
--- /dev/null
+
+GLGraphics 640,480
+
+glEnable GL_DEPTH_TEST 'Enables Depth Testing
+
+glMatrixMode GL_PROJECTION 'Select The Projection Matrix
+glLoadIdentity 'Reset The Projection Matrix
+
+glFrustum -0.1, 0.1,-0.1, 0.1, 0.1, 100.0 'Setup The Projection Matrix Frustum
+
+glMatrixMode GL_MODELVIEW 'Select The ModelView Matrix
+glLoadIdentity 'Reset The ModelView Matrix
+
+While Not KeyHit( KEY_ESCAPE )
+
+ glClear GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT 'Clear The Screen And The Depth Buffer
+
+ glLoadIdentity 'Reset The ModelView Matrix
+ glTranslatef -1.5,0.0,-6.0 'Move Left 1.5 Units And Into The Screen 6.0
+
+ glBegin GL_TRIANGLES 'Drawing Using Triangles
+
+ glColor3f 1.0,0.0,0.0 'Set The Color To Red
+ glVertex3f 0.0, 1.0, 0.0 'Top
+ glColor3f 0.0,1.0,0.0 'Set The Color To Green
+ glVertex3f -1.0,-1.0, 0.0 'Bottom Left
+ glColor3f 0.0,0.0,1.0 'Set The Color To Blue
+ glVertex3f 1.0,-1.0, 0.0 'Bottom Right
+
+ glEnd 'Finished Drawing The Triangle
+
+ glTranslatef 3.0,0.0,0.0 'Move Right 3 Units
+
+ glColor3f 0.5,0.5,1.0 'Set The Color To Blue One Time Only
+ glBegin GL_QUADS 'Draw A Quad
+
+ glVertex3f -1.0, 1.0, 0.0 'Top Left
+ glVertex3f 1.0, 1.0, 0.0 'Top Right
+ glVertex3f 1.0,-1.0, 0.0 'Bottom Right
+ glVertex3f-1.0,-1.0,0.0 'Bottom Left
+
+ glEnd 'Finished Drawing The Quad
+
+ Flip
+
+Wend
--- /dev/null
+
+GLGraphics 640,480
+
+glEnable GL_DEPTH_TEST 'Enables Depth Testing
+
+glMatrixMode GL_PROJECTION 'Select The Projection Matrix
+glLoadIdentity 'Reset The Projection Matrix
+
+glFrustum -0.1, 0.1,-0.1, 0.1, 0.1, 100.0 'Setup The Projection Matrix Frustum
+
+glMatrixMode GL_MODELVIEW 'Select The ModelView Matrix
+glLoadIdentity 'Reset The ModelView Matrix
+
+Local rtri:Float 'Angle For The Triangle ( New )
+Local rquad:Float 'Angle For The Quad ( New )
+
+While Not KeyHit( KEY_ESCAPE )
+
+ glClear GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT 'Clear The Screen And The Depth Buffer
+
+ glLoadIdentity 'Reset The ModelView Matrix
+ glTranslatef -1.5,0.0,-6.0 'Move Left 1.5 Units And Into The Screen 6.0
+
+ glRotatef rtri,0.0,1.0,0.0 'Rotate The Triangle On The Y axis ( New )
+
+ glBegin GL_TRIANGLES 'Drawing Using Triangles
+
+ glColor3f 1.0,0.0,0.0 'Set The Color To Red
+ glVertex3f 0.0, 1.0, 0.0 'Top
+ glColor3f 0.0,1.0,0.0 'Set The Color To Green
+ glVertex3f -1.0,-1.0, 0.0 'Bottom Left
+ glColor3f 0.0,0.0,1.0 'Set The Color To Blue
+ glVertex3f 1.0,-1.0, 0.0 'Bottom Right
+
+ glEnd 'Finished Drawing The Triangle
+
+ glLoadIdentity() 'Reset The Current Modelview Matrix
+ glTranslatef 1.5,0.0,-6.0 'Move Right 1.5 Units And Into The Screen 6.0
+ glRotatef rquad,1.0,0.0,0.0 'Rotate The Quad On The X axis ( New )
+
+ glColor3f 0.5,0.5,1.0 'Set The Color To Blue One Time Only
+ glBegin GL_QUADS 'Draw A Quad
+
+ glVertex3f -1.0, 1.0, 0.0 'Top Left
+ glVertex3f 1.0, 1.0, 0.0 'Top Right
+ glVertex3f 1.0,-1.0, 0.0 'Bottom Right
+ glVertex3f-1.0,-1.0,0.0 'Bottom Left
+
+ glEnd 'Finished Drawing The Quad
+
+ rtri:+0.7 'Increase The Rotation Variable For The Triangle ( New )
+ rquad:-0.55 'Decrease The Rotation Variable For The Quad ( New )
+
+ Flip
+
+Wend
--- /dev/null
+
+GLGraphics 640,480
+
+glEnable GL_DEPTH_TEST 'Enables Depth Testing
+
+glMatrixMode GL_PROJECTION 'Select The Projection Matrix
+glLoadIdentity 'Reset The Projection Matrix
+
+glFrustum -0.1, 0.1,-0.1, 0.1, 0.1, 100.0 'Setup The Projection Matrix Frustum
+
+glMatrixMode GL_MODELVIEW 'Select The ModelView Matrix
+glLoadIdentity 'Reset The ModelView Matrix
+
+Local rtri:Float 'Angle For The Triangle ( New )
+Local rquad:Float 'Angle For The Quad ( New )
+
+While Not KeyHit( KEY_ESCAPE )
+
+ glClear GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT 'Clear The Screen And The Depth Buffer
+
+ glLoadIdentity 'Reset The ModelView Matrix
+ glTranslatef -1.5,0.0,-6.0 'Move Left 1.5 Units And Into The Screen 6.0
+
+ glRotatef rtri,0.0,1.0,0.0 'Rotate The Triangle On The Y axis ( New )
+
+ glBegin GL_TRIANGLES 'Drawing Using Triangles
+
+ glColor3f 1.0,0.0,0.0 'Red
+ glVertex3f 0.0, 1.0, 0.0 'Top Of Triangle (Front)
+ glColor3f 0.0,1.0,0.0 'Green
+ glVertex3f -1.0,-1.0, 1.0 'Left Of Triangle (Front)
+ glColor3f 0.0,0.0,1.0 'Blue
+ glVertex3f 1.0,-1.0, 1.0 'Right Of Triangle (Front)
+
+ glColor3f 1.0,0.0,0.0 'Red
+ glVertex3f 0.0, 1.0, 0.0 'Top Of Triangle (Right)
+ glColor3f 0.0,0.0,1.0 'Blue
+ glVertex3f 1.0,-1.0, 1.0 'Left Of Triangle (Right)
+ glColor3f 0.0,1.0,0.0 'Green
+ glVertex3f 1.0,-1.0, -1.0 'Right Of Triangle (Right)
+
+ glColor3f 1.0,0.0,0.0 'Red
+ glVertex3f 0.0, 1.0, 0.0 'Top Of Triangle (Back)
+ glColor3f 0.0,1.0,0.0 'Green
+ glVertex3f 1.0,-1.0, -1.0 'Left Of Triangle (Back)
+ glColor3f 0.0,0.0,1.0 'Blue
+ glVertex3f -1.0,-1.0, -1.0 'Right Of Triangle (Back)
+
+ glColor3f 1.0,0.0,0.0 'Red
+ glVertex3f 0.0, 1.0, 0.0 'Top Of Triangle (Left)
+ glColor3f 0.0,0.0,1.0 'Blue
+ glVertex3f -1.0,-1.0,-1.0 'Left Of Triangle (Left)
+ glColor3f 0.0,1.0,0.0 'Green
+ glVertex3f -1.0,-1.0, 1.0 'Right Of Triangle (Left)
+
+ glEnd 'Finished Drawing The Pyramid
+
+ glLoadIdentity() 'Reset The Current Modelview Matrix
+ glTranslatef 1.5,0.0,-7.0 'Move Right 1.5 Units And Into The Screen 7.0
+ glRotatef rquad,1.0,1.0,1.0 'Rotate The Quad On The X, Y and Z axis ( New )
+
+ glColor3f 0.5,0.5,1.0 'Set The Color To Blue One Time Only
+ glBegin GL_QUADS 'Draw A Quad
+
+ glColor3f 0.0,1.0,0.0 'Set The Color To Green
+ glVertex3f 1.0, 1.0,-1.0 'Top Right Of The Quad (Top)
+ glVertex3f -1.0, 1.0,-1.0 'Top Left Of The Quad (Top)
+ glVertex3f -1.0, 1.0, 1.0 'Bottom Left Of The Quad (Top)
+ glVertex3f 1.0, 1.0, 1.0 'Bottom Right Of The Quad (Top)
+
+ glColor3f 1.0,0.5,0.0 'Set The Color To Orange
+ glVertex3f 1.0,-1.0, 1.0 'Top Right Of The Quad (Bottom)
+ glVertex3f -1.0,-1.0, 1.0 'Top Left Of The Quad (Bottom)
+ glVertex3f -1.0,-1.0,-1.0 'Bottom Left Of The Quad (Bottom)
+ glVertex3f 1.0,-1.0,-1.0 'Bottom Right Of The Quad (Bottom)
+
+ glColor3f 1.0,0.0,0.0 'Set The Color To Red
+ glVertex3f 1.0, 1.0, 1.0 'Top Right Of The Quad (Front)
+ glVertex3f -1.0, 1.0, 1.0 'Top Left Of The Quad (Front)
+ glVertex3f -1.0,-1.0, 1.0 'Bottom Left Of The Quad (Front)
+ glVertex3f 1.0,-1.0, 1.0 'Bottom Right Of The Quad (Front)
+
+ glColor3f 1.0,1.0,0.0 'Set The Color To Yellow
+ glVertex3f 1.0,-1.0,-1.0 'Bottom Left Of The Quad (Back)
+ glVertex3f -1.0,-1.0,-1.0 'Bottom Right Of The Quad (Back)
+ glVertex3f -1.0, 1.0,-1.0 'Top Right Of The Quad (Back)
+ glVertex3f 1.0, 1.0,-1.0 'Top Left Of The Quad (Back)
+
+ glColor3f 0.0,0.0,1.0 'Set The Color To Blue
+ glVertex3f -1.0, 1.0, 1.0 'Top Right Of The Quad (Left)
+ glVertex3f -1.0, 1.0,-1.0 'Top Left Of The Quad (Left)
+ glVertex3f -1.0,-1.0,-1.0 'Bottom Left Of The Quad (Left)
+ glVertex3f -1.0,-1.0, 1.0 'Bottom Right Of The Quad (Left)
+
+ glColor3f 1.0,0.0,1.0 'Set The Color To Violet
+ glVertex3f 1.0, 1.0,-1.0 'Top Right Of The Quad (Right)
+ glVertex3f 1.0, 1.0, 1.0 'Top Left Of The Quad (Right)
+ glVertex3f 1.0,-1.0, 1.0 'Bottom Left Of The Quad (Right)
+ glVertex3f 1.0,-1.0,-1.0 'Bottom Right Of The Quad (Right)
+
+ glEnd 'Finished Drawing The Box
+
+ rtri:+0.6 'Increase The Rotation Variable For The Triangle ( New )
+ rquad:-0.85 'Decrease The Rotation Variable For The Quad ( New )
+
+ Flip
+
+Wend
--- /dev/null
+body{
+ color: #000000;
+ background: #ffffff;
+ font: 9pt helvetica;
+}
+body.navbar{
+ color: #000000;
+ background: #ffffff;
+ font: 10pt helvetica;
+ padding: 2px;
+}
+h1{
+ font: 14pt helvetica;
+ font-weight: bold;
+}
+h2{
+ font: 12pt helvetica;
+ font-weight: bold;
+}
+h3{
+ font: 10pt helvetica;
+ font-weight: bold;
+}
+table{
+ background: #ffffff;
+ font: 10pt helvetica;
+}
+th{
+ padding: 4px;
+ background: #ccddee;
+ border-bottom: 1px solid #bbccdd;
+ text-align: left;
+}
+td{
+ padding: 4px;
+ background: #ddeeff;
+ border-bottom: 1px solid #ccddee;
+}
+td.blank{
+ padding: 0px;
+ background: #ffffff;
+ border: none;
+}
+td.small{
+ padding: 2px;
+ background: #ddeeff;
+ border-bottom: 1px solid #ccddee;
+ font: 8pt helvetica;
+}
+td.doctop{
+ padding: 10px;
+ background: #ccddee;
+ border-bottom: 1px solid #bbccdd;
+ font: 10pt helvetica;
+ vertical-align: text-top;
+ font-weight: bold;
+}
+td.docleft{
+ padding: 10px;
+ background: #ccddee;
+ border-bottom: 1px solid #bbccdd;
+ font: 8pt helvetica;
+ vertical-align: text-top;
+ width: 10%;
+}
+td.docright{
+ padding:10px;
+ background: #ddeeff;
+ border-bottom: 1px solid #ccddee;
+ font: 10pt helvetica;
+ vertical-align: text-top;
+ width: 90%;
+}
+pre{
+ font: 10pt courier;
+ background: #eef8ff;
+ padding: 8px;
+}
+font.token{
+ font-weight: bold;
+}
+font.syntax{
+ color: #005555;
+}
+div.ref{
+ border: 1px solid #000000;
+}
+div.indent{
+ padding-left: 8px;
+}
+div.syntax{
+ color: #005555;
+ padding: 8px;
+}
+a{
+ color: #000088;
+ font: 10pt helvetica;
+ text-decoration: underline;
+}
+a.navbig{
+ color: #000088;
+ font: 9pt helvetica;
+ text-decoration: none;
+}
+a.navsmall{
+ color: #000088;
+ font: 8pt helvetica;
+ text-decoration: none;
+}
+a:hover{
+ color: #000088;
+}
+a.small{
+ color: #000088;
+ font: 8pt helvetica;
+}
+a.token{
+ color: #000088;
+ text-decoration: underline;
+}
+a.null{
+ text-decoration: none;
+}
+div.entries{
+ display: none;
+}
--- /dev/null
+
+Strict
+
+Type TUpperStream Extends TStreamWrapper
+
+ Method Read( buf:Byte Ptr,count )
+ 'Read data from the underlying stream
+ count=Super.Read( buf,count )
+ 'Convert the data to uppercase
+ For Local i=0 Until count
+ If buf[i]>=Asc("a") And Buf[i]<=Asc("z")
+ buf[i]=buf[i]-Asc("a")+Asc("A")
+ EndIf
+ Next
+ 'Done!
+ Return count
+ End Method
+
+ Method Write( buf:Byte Ptr,count )
+ 'Copy the data to a new buffer, converting to uppercase as we go
+ Local tmp:Byte[count]
+ For Local i=0 Until count
+ If buf[i]>=Asc("a") And buf[i]<=Asc("z")
+ tmp[i]=buf[i]-Asc("a")+Asc("A")
+ Else
+ tmp[i]=buf[i]
+ EndIf
+ Next
+ 'Write the data to the underlying stream
+ Return Super.Write( tmp,count )
+ End Method
+
+ Function Create:TUpperStream( stream:TStream )
+ Local t:TUpperStream=New TUpperStream
+ 'SetStream is a TStreamWrapper method that sets the underlying stream.
+ t.SetStream stream
+ Return t
+ End Function
+
+End Type
+
+Type TUpperStreamFactory Extends TStreamFactory
+
+ Method CreateStream:TUpperStream( url:Object,proto$,path$,readable,writeable )
+ If proto$<>"uppercase" Return
+ Local stream:TStream=OpenStream( path,readable,writeable )
+ If stream Return TUpperStream.Create( stream )
+ End Method
+
+End Type
+
+New TUpperStreamFactory
+
+'Exmaple of manually creating a TUpperStream:
+
+'Create a tmp file and write some text to it.
+Local tmp:TStream=WriteStream( "tmp" )
+tmp.WriteLine "A little example..."
+tmp.WriteLine "of our cool TUpperStream!"
+tmp.Close
+
+'Open tmp file again, and wrap it with a TUpperStream
+tmp:TStream=ReadStream( "tmp" )
+Local upperizer:TUpperStream=TUpperStream.Create( tmp )
+
+'Dump file contents
+While Not upperizer.Eof()
+ Print upperizer.ReadLine()
+Wend
+
+upperizer.Close
+tmp.Close
+
+'Example of automatically creating a TUpperStream:
+Local tmp2:TStream=WriteStream( "uppercase::tmp" )
+tmp2.WriteLine "Another little example..."
+tmp2.WriteLine "of our even cooler TUpperStream!"
+tmp2.Close
+
+tmp2:TStream=ReadStream( "tmp" )
+While Not tmp2.Eof()
+ Print tmp2.ReadLine()
+Wend
+tmp2.Close
+
+
+
+
+
--- /dev/null
+
++BMK
+
+BMK is a command line tool that drives the BlitzMax compiler and provides other general 'housekeeping' operations.
+
+The general syntax for BMK is:
+{
+@bmk %Operation %Options %Arguments
+}
+
+Where operation is one of @makeapp, @makemods, @zapmod, @unzampmod.
+
++@Makeapp
+
+Makeapp builds an application from a single <i>root</i> source file. Building an application involves compiling source files and linking together the resultant %object files.
+
+Makeapp takes one argument: the root source file to be built.
+
+The root source file is scanned by BMK for #Import, #Include and #Incbin statements, and these files are themselves automatically built as well.
+
+Unless the -a option is used, only source files that have been modified since the last makeapp operation are recompiled. This can vastly improve compile times.
+
+Valid options for makeapp are:
+[ @Option | @Effect
+* @{-d} | Build debug version. This is the default.
+* @{-r} | Build release version. By default, the debug version is built.
+* @{-h} | Build multithreaded version. By default, the single threaded version is built.
+* @{-a} | Recompile all source files regardless of timestamp. By default, only files modified since the last makeapp are recompiled.
+* @{-o} %OutputFile | Specify output file. By default, the output file is placed into the same directory as the root source file.
+* @{-t} %AppType | Specify application type. Should be either 'console' or 'gui' (without single quote!).
+]
+
+Some examples of makeapp in action:
+{{
+bmk makeapp myapp.bmx
+bmk makeapp -a -r -o myapp_release myapp.bmx
+}}
+
+Note that the debug, release, single threaded and multithreaded options allow for 4 'types' of applications:
+
+* Debug, single threaded (this is the default)
+* Debug, multithreaded (use -h option)
+* Release, single threaded (use -r option)
+* Release, multithreaded (use -r and -h options)
+
++Makemods
+
+The makemods operation builds a set of modules.
+
+Makemods takes one optional argument: a module filter. This can be a module scope name (to build a subset of modules) or a fully qualified module name (to build an individual module). If the module filter is omitted, than all module are built.
+
+Valid options for makemods are:
+[ @Option | @Effect
+* @{-d} | Build debug version only. By default, both debug and release versions are built.
+* @{-r} | Build release version only. By default, both debug and release versions are built.
+* @{-h} | Build multithreaded versions. By default, single threaded versions only are built.
+* @{-a} | Build all modules regardless of timestamps. By default, only modules that have been modified are built.
+]
+
+Some examples of makemods in action:
+{{
+bmk makemods mymods
+bmk makemods -a mymods.testmod
+}}
+
++Zapmod
+
+The Zapmod operation compresses a module into a single '.zap' file.
+
+Zapmod takes 2 arguments - the module to zap, and the name of the output file.
+
+For example:
+{{
+bmk zapmod mymods.testmod testmod.zap
+}}
+
++UnzapMod
+
+Unzapmod installs a module previously zapped with 'Zapmod'.
+
+Unzapmod takes 1 argument - the module zap file to unzap. Note that any matching existing module will be overwritten by this operation. For example:
+{{
+bmk unzapmod testmod.zap
+}}
--- /dev/null
+
++Welcome
+
+Welcome to the BlitzMax users guide.
+
+This document will introduce you to some of the concepts behind BlitzMax, and how to actually use it.
+
+BlitzMax is a computer programming language based on the popular BASIC programming language. BASIC stands for @{B}eginners @{A}ll purpose @{S}ymbolic @{I}nstruction @{C}ode. As its name would suggest, BASIC is designed to be easy to use, yet useful for a wide range of purposes.
+
+BlitzMax is a compiler. It takes as input text files containing the source code to a program, and produces as output a program that you can run. The final program consists of low level %{machine code} statements that are interpreted by the CPU.
+
+Blitzmax also includes several advanced features found in more modern programming languages. In particular, BlitzMax supports the %{object oriented} programming techniques known as %inheritance and %polymorphism. However, Blitzmax is designed so that you don't have to learn such techniques until you are ready (if ever!)
+
++How BlitzMax works
+
+BlitzMax takes your program's %{source code} and converts it into %{executable code}. There are 2 main steps involved in this process:
+
+Compiling the source code: This steps involves converting each source code file in your project into a corresponding %{object code} file. An object code file contains actual machine code, but cannot be run on its own. It must first be linked with other object files...
+
+Linking the object code: This step involves %linking all the object code files together in order to produce a program that can actually be run. This step is necessary as object files often require information found in other object files. Linking effectively 'connects up' the object code files to each other.
+
+This process of compiling and linking a project is known as %building a project and must be done whenever you edit a source file or other resource in your project.
+
+There are 2 main ways to build projects: either using #MaxIDE or with the #BMK utility.
+
+MaxIDE is an %{integrated development environment}. It allows you to modify source code files and build projects.
+
+BMK is a lower level command line utility also used for building projects. In fact, the BlitzMax IDE uses BMK 'behind the scenes' to build projects.
--- /dev/null
+
++ The BlitzMax IDE
+
+The BlitzMax IDE is an application used for editing source code files and building projects. IDE stands for 'integrated development environment'.
+
+The BlitzMax IDE operates very much like a text editor or word processor.
+
++ Getting started
+
+Ok, time to compile and run your first program!
+
+First, select @New from the file menu or toolbar. This will create a new, empty source file for you to work with.
+
+Next, enter the following little program:
+{{
+'
+'My first BlitzMax program
+'
+Print "Hello World!"
+}}
+Now, its time to build and run: Select @{Build And Run} from the @Program menu. You should see the following output:
+{{
+Building untitled1
+Compiling:untitled1.bmx
+flat assembler version 1.51
+3 passes, 2417 bytes.
+Linking:untitled1.debug.exe
+Executing:untitled1.debug.exe
+Hello World!
+
+Process complete
+}}
+Congratulations! You've just created your first program!
+
+What happens if there's an error in your program? Create a new source file and try the following program instead:
+{{
+'
+'My first bug!
+'
+rint "Hello World!" 'oops! Forgot a 'p'!
+}}
+This program has an error in it - there is no such command as 'rint' so attempting to build this program will produce the following error:
+{
+<img src=../error1.png>
+}
+
+When you return to the main source code window, the cursor will be placed at the line containing the error, allowing you to fix it.
+
+This type of error is known as a %{compile time} error, because the bug was detected by the compiler before you actually ran the program. However, the compiler cannot catch all possible errors - some errors are not apparent until your program is run. These kinds of errors are known as %runtime errors. Here's an example of a program with a runtime error in it:
+{{
+'
+' My first runtime bug!
+'
+Local an_array[10]
+
+For k=0 To 10
+ Print an_array[k]
+Next
+}}
+If you run this, you should see the following error message:
+{
+<img src=../error2.png>
+}
+Note how the pane on the right has also switched to the 'Debug' pane. This means your program is in 'debug mode',
+and by navigating through the debug pane you can inspect your programs variables.
+
++ The File menu
+[ @{Menu Item} | @Action
+* New | Create a new source file.
+* Open | Open an existing source file.
+* Open Recent | Reopen a recently used source file.
+* Close | Close current source file.
+* Close All | Close all source files.
+*
+*
+* Save | Save current source file.
+* Save As | Save current source file under a different name.
+* Save All | Save all open source files.
+*
+*
+* Next File | Switch to next open source file.
+* Previous File | Switch to previous open source file.
+*
+*
+* IDE Options | Open the IDE options panel.
+* Project Manager | Open the project manager panel.
+* Import BB Project | Import and convert a BlitzPlus or Blitz3D project.
+*
+*
+* Print | Print current souorce file.
+*
+*
+* Exit | Close down and exit the IDE.
+]
+
++ The Edit menu
+[ @{Menu Item} | @Action
+* Undo | Undo most recent source file edit.
+* Redo | Redo most recently undone source file edit.
+*
+*
+* Cut | Cut selected text from current source file.
+* Copy | Copy selected text from current source file.
+* Paste | Paste text into current source file.
+*
+*
+* Select All | Select all text in current source file.
+*
+*
+* Block Indent | Indent the currently highlighted block.
+* Block Outdent | Unindent the currently highlighted block.
+*
+*
+* Find | Find text in the current source file.
+* Find Next | Find next occurance of text.
+* Replace | Find and replace text.
+* Goto Line | Go to a line in the current source file.
+]
+
++ The Program menu
+[ @{Menu Item} | @Action
+* Build | Build the current source file (or locked build file).
+* Build And Run | Build and run the current source file (or locked build file).
+* Command Line | Specify command line options for BlitzMax apps.
+*
+*
+* Step | In debug mode, step over next program statement.
+* Step In | In debug mode, step into next program statement.
+* Step Out | In debug mode, step out of current block or function.
+* Halt | Stop current build or program run.
+* Build Options:Quick Build | Enable or disable quick builds. The quick build feature causes the compiler to only recompile modified files.
+* Build Options:Debug Build | Enable or disable debug builds. Debug builds performing extra error checking at runtime, at the cost of some execution speed.
+* Build Options:Build GUI App | Instructs BlitzMax to build a 'GUI' application. Disable this if you are building a lightweight, text-only applications.
+*
+*
+* Lock Build File | Lock the current source file for future @build and @{build and run} operations. This can be useful if you have a multifile project and are editing several source files but only ever rebuilding one of them.
+* Unlock Build File | Unlock the currently locked build file.
+*
+*
+* Synchronize Modules | Perform an online update of all Blitzmax modules.
+*
+*
+* Build Modules | Build any recently modified modules.
+* Rebuild All Modules | Rebuild all modules from scratch.
+* Document Modules | Rebuild module documentation.
+]
+
++ The Help menu
+[ @{Menu Item} | @Action
+* Home | Go to the help home page.
+* Back | Return to previous help page.
+* Forward | Advance to the next help page.
+* Quick Help | Jump to command reference entry for command nearest cursor.
+* About BlitzMax | Show information about BlitzMax and the IDE.
+]
--- /dev/null
+<html>
+<head>
+<link rel="styleSheet" href="bmxstyle.css" type="text/css">
+</head>
+<body>
+<div align=center>
+<table width=100% class=open>
+<tr>
+<td class=blank align=left width=33%> </td>
+<td class=blank align=center width=33%><img src=bmax120.png></td>
+<td class=blank align=right valign=top width=33%><img src=brllogo.png></td>
+</tr>
+</table>
+</div>
+<div align=center>
+BlitzMax © Blitz Research Ltd<br>
+<br>
+<font color=#000088>Language and Compiler:</font> Mark Sibly<br>
+<br>
+<font color=#000088>Modules:</font> Mark Sibly and Simon Armstrong<br>
+<br>
+<font color=#000088>Documentation:</font> Mark Sibly and Simon Armstrong<br>
+<br>
+<font color=#000088>Beta testers:</font> Richard Betson; David Bird; James Boyd; Jim Brown; Mikkel Fredborg; Garrit Grandberg; Stephen Greener; Simon Harrison; Michael Hense; Rob Hutchinson; Stephen Johnson; Mikkel Lokke; Daniel Lurie; Richard Olpin; Lee Page; Richard Pearson; John Pickford; Michael Reitzenstein; Robin Shackford; Mark Tiffany<br>
+<br>
+<font color=#000088>FASM x86 Assembler:</font>Tomasz Grysztar<br>
+<br>
+<font color=#000088>Extra thanks to:</font> Rod Smith and Mikkel Fredborg for the cool logos and toolbar graphics; Rick, Kay, Robbie and Sarah Keam; Donna, Harley and Danni Adams and all Blitz users around the world!<br>
+<br>
+<font color=#000088>Last but not Least:</font> BlitzMax would not have been possible without the indirect help of the amazing open source community. Libraries such as zlib, libpng, libjpeg, oggvorbis, freetype, FLTK and others are used by many commercial programs such as BlitzMax, and the unselfish contribution the authors of such libraries have made to the software scene is awesome.
+</div>
+</body>
+</html>
--- /dev/null
+<html>
+<head>
+<link rel="styleSheet" href="bmxstyle.css" type="text/css">
+</head>
+<body>
+<div align=center>
+<table width=100% class=open>
+<tr>
+<td class=blank align=left width=33%> </td>
+<td class=blank align=center width=33%><img src=bmax120.png></td>
+<td class=blank align=right valign=top width=33%><img src=brllogo.png></td>
+</tr>
+</table>
+</div>
+Welcome to BlitzMax!<br>
+<br>
+To return to this page at any time, just click the <b>Home</b> icon in the toolbar
+above.<br>
+<ul>
+<li><a href="User Guide/index.html">Users guide</a> - how to create programs in BlitzMax.<br>
+<br>
+<li><a href="Language/index.html">Language reference</a> - how the BlitzMax language works.<br>
+<br>
+<li><a href="Modules/index.html">Module reference</a> - commands contained in BlitzMax modules.<br>
+<br>
+<li><a href="Tutorials/index.html">Tutorials and articles</a> - a collection of informal bits and pieces.<br>
+<br>
+<li><a href="_credits.html">Credits</a> - who did what.<br>
+</ul>
+For more information on BlitzMax, visit the Blitz Research website at <a href=http://www.blitzbasic.com>www.blitzbasic.com</a><br>
+<br>
+If you experience any problems running BlitzMax, please contact <a href="mailto:support@blitzbasic.com">
+support@blitzbasic.com</a><br>
+<br>
+</body>
+</html>
--- /dev/null
+body{
+ color: #000000;
+ background: #ffffff;
+ font: 9pt helvetica;
+}
+body.navbar{
+ color: #000000;
+ background: #ffffff;
+ font: 10pt helvetica;
+ padding: 2px;
+}
+h1{
+ font: 14pt helvetica;
+ font-weight: bold;
+}
+h2{
+ font: 12pt helvetica;
+ font-weight: bold;
+}
+h3{
+ font: 10pt helvetica;
+ font-weight: bold;
+}
+table{
+ background: #ffffff;
+ font: 10pt helvetica;
+}
+th{
+ padding: 4px;
+ background: #ccddee;
+ border-bottom: 1px solid #bbccdd;
+ text-align: left;
+}
+td{
+ padding: 4px;
+ background: #ddeeff;
+ border-bottom: 1px solid #ccddee;
+}
+td.blank{
+ padding: 0px;
+ background: #ffffff;
+ border: none;
+}
+td.small{
+ padding: 2px;
+ background: #ddeeff;
+ border-bottom: 1px solid #ccddee;
+ font: 8pt helvetica;
+}
+td.doctop{
+ padding: 10px;
+ background: #ccddee;
+ border-bottom: 1px solid #bbccdd;
+ font: 10pt helvetica;
+ vertical-align: text-top;
+ font-weight: bold;
+}
+td.docleft{
+ padding: 10px;
+ background: #ccddee;
+ border-bottom: 1px solid #bbccdd;
+ font: 8pt helvetica;
+ vertical-align: text-top;
+ width: 10%;
+}
+td.docright{
+ padding:10px;
+ background: #ddeeff;
+ border-bottom: 1px solid #ccddee;
+ font: 10pt helvetica;
+ vertical-align: text-top;
+ width: 90%;
+}
+pre{
+ font: 10pt courier;
+ background: #eef8ff;
+ padding: 8px;
+}
+blockquote{
+ color: #005555;
+}
+font.token{
+ font-weight: bold;
+}
+font.syntax{
+ color: #005555;
+}
+div.ref{
+ border: 1px solid #000000;
+}
+div.indent{
+ padding-left: 8px;
+}
+div.syntax{
+ color: #005555;
+ padding: 8px;
+}
+a{
+ color: #000088;
+ font: 10pt helvetica;
+ text-decoration: underline;
+}
+a.navbig{
+ color: #000088;
+ font: 9pt helvetica;
+ text-decoration: none;
+}
+a.navsmall{
+ color: #000088;
+ font: 8pt helvetica;
+ text-decoration: none;
+}
+a:hover{
+ color: #000088;
+}
+a.small{
+ color: #000088;
+ font: 8pt helvetica;
+}
+a.token{
+ color: #000088;
+ text-decoration: underline;
+}
+a.null{
+ text-decoration: none;
+}
+div.entries{
+ display: none;
+}
projects / blitzmax.git / commitdiff
