BRL.Blitz: | Globals | Functions | Keywords | Source |
AppDir | Application directory |
AppFile | Application file name |
AppTitle | Application title |
AppArgs | Arguments passed to the application at startup |
LaunchDir | Directory from which application was launched |
RuntimeError | Generate a runtime error |
DebugStop | Stop program execution and enter debugger |
DebugLog | Write a string to debug log |
OnEnd | Add a function to be called when the program ends |
ReadStdin | Read a string from stdin |
WriteStdout | Write a string to stdout |
WriteStderr | Write a string to stderr |
Delay | Wait for a given number of milliseconds |
MilliSecs | Get millisecond counter |
MemAlloc | Allocate memory |
MemFree | Free allocated memory |
MemExtend | Extend a block of memory |
MemClear | Clear a block of memory to 0 |
MemCopy | Copy a non-overlapping block of memory |
MemMove | Copy a potentially overlapping block of memory |
GCSetMode | Set garbage collector mode |
GCSuspend | Suspend garbage collector |
GCResume | Resume garbage collector |
GCCollect | Run garbage collector |
GCMemAlloced | Memory allocated by application |
GCEnter | Private: do not use |
GCLeave | Private: do not use |
HandleFromObject | Convert object to integer handle |
HandleToObject | Convert integer handle to object |
Strict | Set strict mode |
SuperStrict | Set SuperStrict mode |
End | End program execution |
Rem | Begin a remark block |
EndRem | End a remark block |
True | Constant integer of value 1 |
False | Constant integer of value 0 |
Pi | Constant Pi value: 3.1415926535897932384626433832795 |
Null | Get Default Null value |
Byte | Unsigned 8 bit integer Type |
Short | Unsigned 16 bit integer Type |
Int | Signed 32 bit integer Type |
Long | Signed 64 bit integer Type |
Float | 32 bit Floating point Type |
Double | 64 bit floating point Type |
String | String Type |
Object | Object Type |
Var | Composite Type specifier for 'by reference' types |
Ptr | Composite Type specifier for pointer types |
If | Begin a conditional block. |
Then | Optional separator between the condition and associated code in an If statement. |
Else | Else provides the ability For an If Then construct to execute a second block of code when the If condition is False. |
ElseIf | ElseIf provides the ability to test and execute a section of code if the initial condition failed. |
EndIf | Marks the End of an If Then block. |
For | Marks the start of a loop that uses an iterator to execute a section of code repeatedly. |
To | Followed by a constant which is used to calculate when to exit a For..Next loop. |
Step | Specifies an optional constant that is used to increment the For iterator. |
Next | End a For block |
EachIn | Iterate through an array or collection |
While | Execute a block of code While a condition is True |
Wend | End a While block |
EndWhile | End a While block |
Repeat | Execute a block of code Until a termination condition is met, or Forever |
Until | Conditionally continue a Repeat block |
Forever | Continue a Repeat block Forever |
Select | Begin a Select block |
EndSelect | End a Select block |
Case | Conditional code inside a Select block |
Default | Default code inside a Select block |
Exit | Exit enclosing loop |
Continue | Continue execution of enclosing loop |
Const | Declare a constant |
Local | Declare a Local variable |
Global | Declare a Global variable |
Field | Declare a Field variable |
Function | Begin a Function declaration |
EndFunction | End a Function declaration |
Return | Return from a Function |
Type | Begin a user defined Type declaration |
EndType | End a user defined Type declaration |
Extends | Specify user defined Type supertype |
Method | Begin a Method declaration |
EndMethod | End a Method declaration |
Abstract | Denote a Type or Method as Abstract |
Final | Denote a Type or Method as Final |
New | Create an instance of a user defined Type |
Self | Reference to this Method's Object instance |
Super | Reference to the Super Type Object instance |
Delete | Reserved for future expansion |
Release | Release an integer Object handle |
Public | Public makes a Constant, Global variable or Function accessible from outside the current source file (Default) |
Private | Private makes a Constant, Global variable or Function only accessible from within the current source file |
Extern | Extern marks the beginning of an external list of Function declarations |
EndExtern | EndExtern marks the End of an Extern section |
Module | Declare Module scope and identifier |
ModuleInfo | Define Module properties |
Incbin | Embed a data file |
IncbinPtr | Get start address of embedded data file |
IncbinLen | Get length of embedded data file |
Include | Include effectively 'inserts' the specified file into the file being compiled. |
Framework | Framework builds the BlitzMax application with only the Module specified rather than all modules installed. |
Import | Import declarations from a Module or source file |
Assert | Throw a RuntimeError if a condition is False |
Goto | Transfer program flow to specified label |
Try | Begin declaration of a Try block |
EndTry | End declaration of a Try block |
Catch | Catch an exception Object in a Try block |
Throw | Throw an exception Object to the enclosing Try block |
DefData | Define class BASIC style data |
ReadData | Read classic BASIC style data |
RestoreData | Restore classic BASIC style data |
And | Conditional 'And' binary operator |
Or | Conditional 'Or' binary operator |
Not | Conditional 'Not' binary operator |
Shl | Bitwise 'Shift left' binary operator |
Shr | Bitwise 'Shift right' binary operator |
Sar | Bitwise 'Shift arithmetic right' binary operator |
Len | Number of characters in a String or elements in an array |
Abs | Numeric 'absolute value' unary operator |
Mod | Numeric 'modulus' or 'remainder' binary operator |
Sgn | Numeric 'sign' unary operator |
Min | Numeric 'minimum' builtin function |
Max | Numeric 'maximum' builtin function |
Varptr | Find the address of a variable |
SizeOf | Size, in bytes, occupied by a variable, string, array or object |
Asc | Get character value of the first character of a string |
Chr | Create a string of length 1 with a character code |
Global AppDir$="bbAppDir" | |
Description | Application directory |
Information | The AppDir global variable contains the fully qualified directory of the currently executing application. An application's initial current directory is also set to AppDir when an application starts. |
Example | ' appdir.bmx ' requests the user to select a file from the application's directory Print "Application Directory="+AppDir$ file$=RequestFile("Select File to Open","",False,AppDir$) Print "file selected was :"+file |
Global AppFile$="bbAppFile" | |
Description | Application file name |
Information | The AppFile global variable contains the fully qualified file name of the currently executing application. |
Example | ' appfile.bmx Print "This program's executable is located at "+AppFile$ |
Global AppTitle$="bbAppTitle" | |
Description | Application title |
Information | The AppTitle global variable is used by various commands when a
default application title is required - for example, when opening simple
windows or requesters. Initially, AppTitle is set the value "BlitzMax Application". However, you may change AppTitle at any time with a simple assignment. |
Global AppArgs$[]="bbAppArgs" | |
Description | Arguments passed to the application at startup |
Information | The AppArgs global array contains the command line parameters sent to an application when it was started. The first element of AppArgs always contains the name of the application. However, the format of the name may change depending on how the application was launched. Use AppDir or AppFile for consistent information about the applications name or directory. |
Example | ' appargs.bmx ' print the command line arguments passed to the program at runtime Print "Number of arguments = "+AppArgs.length For a$=EachIn AppArgs Print a$ Next |
Global LaunchDir$="bbLaunchDir" | |
Description | Directory from which application was launched |
Information | The LaunchDir global variable contains the current directory at the time the application was launched. This is mostly of use to command line tools which may need to access the 'shell' current directory as opposed to the application directory. |
Example | ' launchdir.bmx Print "This program was launched from "+LaunchDir$ |
Function RuntimeError( message$ ) | |
Description | Generate a runtime error |
Information | Throws a TRuntimeException. |
Example | ' runtimeerror.bmx If a=0 RuntimeError "This program has failed badly." |
Function DebugStop() | |
Description | Stop program execution and enter debugger |
Information | If there is no debugger present, this command is ignored. |
Function DebugLog( message$ ) | |
Description | Write a string to debug log |
Information | If there is no debugger present, this command is ignored. |
Function OnEnd( fun() ) | |
Description | Add a function to be called when the program ends |
Information | OnEnd allows you to specify a function to be called when the program ends. OnEnd functions are called in the reverse order to that in which they were added. |
Example | ' onend.bmx Function cleanup() Print "cleaning up" End Function OnEnd cleanup Print "program running" End 'the cleanup function will be called at this time |
Function ReadStdin$() | |
Returns | A string read from stdin. The newline terminator, if any, is included in the returned string. |
Description | Read a string from stdin |
Function WriteStdout( str$ ) | |
Description | Write a string to stdout |
Information | Writes str to stdout and flushes stdout. |
Function WriteStderr( str$ ) | |
Description | Write a string to stderr |
Information | Writes str to stderr and flushes stderr. |
Function Delay( millis ) | |
Description | Wait for a given number of milliseconds |
Information |
Delay suspends program execution for at least millis milliseconds. A millisecond is one thousandth of a second. |
Function MilliSecs() | |
Returns | Milliseconds since computer turned on. |
Description | Get millisecond counter |
Information |
MilliSecs returns the number of milliseconds elapsed since the computer
was turned on. A millisecond is one thousandth of a second. |
Function MemAlloc:Byte Ptr( size ) | |
Returns | A new block of memory size bytes long |
Description | Allocate memory |
Function MemFree( mem:Byte Ptr ) | |
Description | Free allocated memory |
Information | The memory specified by mem must have been previously allocated by MemAlloc or MemExtend. |
Function MemExtend:Byte Ptr( mem:Byte Ptr,size,new_size ) | |
Returns | A new block of memory new_size bytes long |
Description | Extend a block of memory |
Information | An existing block of memory specified by mem and size is copied into a new block of memory new_size bytes long. The existing block is released and the new block is returned. |
Function MemClear( mem:Byte Ptr,size ) | |
Description | Clear a block of memory to 0 |
Function MemCopy( dst:Byte Ptr,src:Byte Ptr,size ) | |
Description | Copy a non-overlapping block of memory |
Function MemMove( dst:Byte Ptr,src:Byte Ptr,size ) | |
Description | Copy a potentially overlapping block of memory |
Function GCSetMode( mode ) | |
Description | Set garbage collector mode |
Information |
mode can be one of the following: 1 : automatic GC - memory will be automatically garbage collected 2 : manual GC - no memory will be collected until a call to GCCollect is made The default GC mode is automatic GC. |
Function GCSuspend() | |
Description | Suspend garbage collector |
Information |
GCSuspend temporarily suspends the garbage collector. No garbage
collection will be performed following a call to GCSuspend. Use GCResume to resume the garbage collector. Note that GCSuspend and GCResume 'nest', meaning that each call to GCSuspend must be matched by a call to GCResume. |
Function GCResume() | |
Description | Resume garbage collector |
Information |
GCResume resumes garbage collection following a call to GCSuspend. See GCSuspend for more details. |
Function GCCollect() | |
Returns | The amount of memory, in bytes, collected. |
Description | Run garbage collector |
Information | This function will have no effect if the garbage collector has been suspended due to GCSuspend. |
Function GCMemAlloced() | |
Returns | The amount of memory, in bytes, currently allocated by the application |
Description | Memory allocated by application |
Information | This function only returns 'managed memory'. This includes all objects, strings and arrays in use by the application. |
Function GCEnter() | |
Description | Private: do not use |
Function GCLeave() | |
Description | Private: do not use |
Function HandleFromObject( obj:Object ) | |
Returns | An integer object handle |
Description | Convert object to integer handle |
Information | After converting an object to an integer handle, you must later release it using the Release command. |
Function HandleToObject:Object( handle ) | |
Returns | The object associated with the integer handle |
Description | Convert integer handle to object |
Strict | |
Description | Set strict mode |
Information | See the BlitzMax Language Reference for more information on Strict mode programming. |
Example | Rem Strict advises the BlitzMax compiler to report as errors all auto defined variables. End Rem Strict local a=10 b=20 'compiler error, strict mode means variables must be declared b4 use |
SuperStrict | |
Description | Set SuperStrict mode |
End | |
Description | End program execution |
Example | Rem The End command causes a program to exit immediately. End Rem Print "Hello!" End Print "This line will never be printed as the program has already been ended." |
Rem | |
Description | Begin a remark block |
Example | Rem My Rem Example First created 9th August, 2004 (C)2050 Blitz Intergalactic Software Corporation End Rem Print "This program has no useful function" Rem Remarks are useful for making your program easily readable. You can leave details explaining the function of your program in a remarks section so that you and any other programmers that work with your code can more easily understand the workings of your program End Rem Print "Sorry." End |
EndRem | |
Description | End a remark block |
Example | Rem All code between Rem and EndRem is ignored by the BlitzMax compiler. Print "hello" End Rem Print "goodbye" |
True | |
Description | Constant integer of value 1 |
Example | Rem True is a Constant Integer assigned the value 1. End Rem Print "True="+True If True Print "This line will always be executed" EndIf If Not True Print "This line will never be executed" EndIf |
False | |
Description | Constant integer of value 0 |
Example | Rem False is a Constant Integer assigned the value 0. End Rem Print "False="+False If False Print "This code will never be executed" Endif |
Pi | |
Description | Constant Pi value: 3.1415926535897932384626433832795 |
Example | Rem Pi is a Constant Double assigned the value 3.1415926535897932384626433832795 End Rem Print "Pi="+Pi |
Null | |
Description | Get Default Null value |
Example | Rem Null is a BlitzMax Constant representing an empty Object reference. End Rem Type mytype Field atypevariable End Type Global a:mytype if a=null Print "a is uninitialized" a=new mytype if a<>null Print "a is initialized" |
Byte | |
Description | Unsigned 8 bit integer Type |
Example | Rem Byte is an unsigned 8 bit integer BlitzMax primitive type. End Rem Local a:byte a=512;print "a="+a 'prints 0 a=-1;print "a="+a 'prints 255 |
Short | |
Description | Unsigned 16 bit integer Type |
Example | Rem Short is an unsigned 16 bit integer BlitzMax primitive type. End Rem Local a:short a=65536;print "a="+a 'prints 0 a=-1;print "a="+a 'prints 65535 |
Int | |
Description | Signed 32 bit integer Type |
Example | Rem Int is a signed 32 bit integer BlitzMax primitive type. End Rem Local a:Int ' the following values all print 0 as BlitzMax "rounds to zero" ' when converting from floating point to integer a=0.1;print a a=0.9;print a a=-0.1;print a a=-0.9;print a |
Long | |
Description | Signed 64 bit integer Type |
Example | Rem Long is a signed 64 bit integer BlitzMax primitive type. End Rem Const MAXLONG:Long=$7fffffffffffffff:Long Const MINLONG:Long=$8000000000000000:Long Print "A long can have the maximum value of:"+MAXLONG Print "A long can have the minimum value of:"+MINLONG |
Float | |
Description | 32 bit Floating point Type |
Example | Rem Float is a 32 bit floating point BlitzMax primitive type. End Rem Local a:float a=1 for i=1 to 8 print a a=a*0.1 next for i=1 to 8 a=a*10 print a next |
Double | |
Description | 64 bit floating point Type |
Example | Rem Double is a 64 bit floating point BlitzMax primitive type. End Rem Local speedoflight:Double Local distance:Double Local seconds:Double speedoflight=299792458:Double 'meters per second distance=149597890000:Double 'average distance in meters from earth sun seconds=distance/speedoflight Print "Number of seconds for light to travel from earth to sun="+seconds |
String | |
Description | String Type |
Example | Rem String is a BlitzMax container type containing a sequence of unicode characters. End Rem quote:String=Chr(34) Print quote+"Hello World!"+quote |
Object | |
Description | Object Type |
Example | Rem Object is the base class of all BlitzMax types. The following function attempts to cast from any object to the custom type TImage and returns true if the given object is an instance of TImage or an instance of a &Type derived from TImage. End Rem Function IsImage(obj:Object) If TImage(obj) return True Return False End Function |
Var | |
Description | Composite Type specifier for 'by reference' types |
Example | Rem Var is a composite type containing a reference to a variable of the specified Type. End Rem ' the following illustrates parsing function parameters by reference Function ReturnMultiplevalues(a Var,b Var,c Var) a=10 b=20 c=30 Return End Function Local x,y,z ReturnMultipleValues(x,y,z) Print "x="+x '10 Print "y="+y '20 Print "z="+z '30 |
Ptr | |
Description | Composite Type specifier for pointer types |
Example | Rem Ptr is a composite type containing a pointer to a variable of the specified Type. End Rem ' the following illustrates the use of traditional c style pointers Local c[]=[1,2,3,4] Local p:Int Ptr p=c Print "pointer 'p' points to:"+p[0] '1 p:+1 Print "pointer 'p' points to:"+p[0] '2 p:+1 Print "pointer 'p' points to:"+p[0] '3 p:+1 Print "pointer 'p' points to:"+p[0] '4 |
If | |
Description | Begin a conditional block. |
Example | Rem If begins a conditional block. End Rem If 3<5 Print "3<5" 'single line if If 5<7 'if block Print "5<7" EndIf |
Then | |
Description | Optional separator between the condition and associated code in an If statement. |
Example | Rem Then is an optional separator between the condition and the block of code following an If statement. End Rem If 3<5 Then Print "3<5" |
Else | |
Description | Else provides the ability For an If Then construct to execute a second block of code when the If condition is False. |
Example | Rem Else provides the ability for an If Then construct to execute a second block of code when the If condition is false. End Rem i=3 If i<5 Print "i<5" Else Print "i>=5" ' single line If Else If i<5 'block style If Else Print "i<5" Else Print "i>=5" EndIf |
ElseIf | |
Description | ElseIf provides the ability to test and execute a section of code if the initial condition failed. |
Example | Rem ElseIf provides the ability to test and execute a section of code if the initial condition failed. End Rem age=Int( Input("How old Are You?") ) If age<13 Print "You are young" ElseIf age<20 Print "You are a teen!" Else Print "You are neither young nor a teen" EndIf |
EndIf | |
Description | Marks the End of an If Then block. |
Example | Rem EndIf marks the end of an If Then block. End Rem i=5 If i<10 Print "i<10" EndIf |
For | |
Description | Marks the start of a loop that uses an iterator to execute a section of code repeatedly. |
Example | Rem For marks the start of a loop that uses an iterator to execute a section of code repeatedly. End Rem ' print 5 times table For i=1 to 12 Print "5*"+i+"="+5*i Next |
To | |
Description | Followed by a constant which is used to calculate when to exit a For..Next loop. |
Example | Rem Followed by a constant which is used to calculate when to exit a For..Next loop. End Rem For i=1 To 5 print i Next |
Step | |
Description | Specifies an optional constant that is used to increment the For iterator. |
Example | Rem Specifies an optional constant that is used to increment the For iterator. End Rem ' count backwards from 10 to 0 For i=10 to 0 step -1 Print i Next |
Next | |
Description | End a For block |
Example | Rem Marks the end of a For section. End Rem For i=1 to 5;print i;Next |
EachIn | |
Description | Iterate through an array or collection |
Example | Rem Specifies a BlitzMax collection type whose values are assigned sequentially to the For iterator. End Rem Local a[]=[0,5,12,13,20] for b=eachin a print b next |
While | |
Description | Execute a block of code While a condition is True |
Example | Rem While executes the following section of code repeatedly while a given condition is true. End Rem Graphics 640,480 While Not KeyHit(KEY_ESCAPE) 'loop until escape key is pressed Cls For i=1 to 200 DrawLine rnd(640),rnd(480),rnd(640),rnd(480) Next Flip Wend |
Wend | |
Description | End a While block |
Example | Rem Wend marks the end of a While section. End Rem While i<5 print i i:+1 Wend |
EndWhile | |
Description | End a While block |
Repeat | |
Description | Execute a block of code Until a termination condition is met, or Forever |
Example | Rem Repeat executes the following section of code until a terminating condition is true. End Rem Repeat print i i:+1 Until i=5 |
Until | |
Description | Conditionally continue a Repeat block |
Example | Rem Until marks the end of a Repeat block and is followed by a terminating condition. End Rem i=2 Repeat print i i:*2 Until i>1000000 |
Forever | |
Description | Continue a Repeat block Forever |
Example | Rem Forever is an alternate ending to a Repeat block that will cause the loop to always repeat. End Rem Repeat Print i+" Ctrl-C to End!" i:+1 Forever |
Select | |
Description | Begin a Select block |
Example | Rem Select begins a block featuring a sequence of multiple comparisons with a single value. End Rem a=Int( Input("Enter Your Country Code ") ) Select a Case 1 Print "You are from America" Case 44 Print "You are from the United Kingdom" Case 62 Print "You are from Australia" Case 64 Print "You are from New Zealand" Default Print "I cannot tell which country you are from" End Select |
EndSelect | |
Description | End a Select block |
Example | Rem EndSelect marks the end of a Select block. End Rem SeedRnd MilliSecs() a=Rand(5) Select a Case 1 Print "one" Case 2 Print "two" Case 3 Print "three" Case 4 Print "four" Case 5 Print "five" Default Print "Program Error" End Select |
Case | |
Description | Conditional code inside a Select block |
Example | ' case.bmx ' Case performs a comparison with the preceeding value(s) and that ' listed in the enclosing Select statement: a=Int( Input("Enter a number between 1 and 5 ") ) Select a Case 1 Print "You think small" Case 2 Print "You are even tempered" Case 3,4 Print "You are middle of the road" Case 5 Print "You think big" Default Print "You are unable to follow instructions" End Select |
Default | |
Description | Default code inside a Select block |
Example | Rem Default is used in a Select block to mark a code section that is executed if all prior Case statements fail. End Rem a$=Input("What is your favorite color?") a$=lower(a$) 'make sure the answer is lower case Select a$ case "yellow" Print "You a bright and breezy" case "blue" Print "You are a typical boy" case "pink" Print "You are a typical girl" default Print "You are quite unique!" End Select |
Exit | |
Description | Exit enclosing loop |
Example | Rem Exit causes program flow to exit the enclosing While, Repeat or For loop. End Rem Repeat Print n n:+1 If n=5 Exit Forever |
Continue | |
Description | Continue execution of enclosing loop |
Example | Rem Continue causes program flow to return to the start of the enclosing While, Repeat or For program loop End Rem For i=1 To 20 If i Mod 2 Continue Print i Next |
Const | |
Description | Declare a constant |
Example | Rem Const defines the preceeding variable declaration as constant. End Rem Const ON=TRUE Const OFF=FALSE Const TWOPI#=2*PI print TWOPI |
Local | |
Description | Declare a Local variable |
Example | Rem Local defines a variable as local to the Method or Function it is defined meaning it is automatically released when the function returns. End Rem Function TestLocal() Local a a=20 print "a="+a Return End Function TestLocal print "a="+a 'prints 0 or if in Strict mode is an error as a is only local to the TestLocal function |
Global | |
Description | Declare a Global variable |
Example | Rem Global defines a variable as Global allowing it be accessed from within Methods and Functions. End Rem Global a=20 Function TestGlobal() print "a="+a End Function TestGlobal print "a="+a |
Field | |
Description | Declare a Field variable |
Example | Rem Field is used to declare the member variable(s) of a type. End Rem Type TVector Field x,y,z End Type Local a:TVector=new TVector a.x=10 a.y=20 a.z=30 |
Function | |
Description | Begin a Function declaration |
Example | Rem Function marks the beginning of a BlitzMax function declaration. When a function does not return a value the use of brackets when calling the function is optional. End Rem Function NextArg(a$) Local p p=instr(a$,",") if p NextArg a$[p..] print a$[..p-1] else print a$ endif End Function NextArg("one,two,three,four") NextArg "22,25,20" 'look ma, no brackets |
EndFunction | |
Description | End a Function declaration |
Example | Rem Function marks the end of a BlitzMax function declaration. End Rem Function RandomName$() local a$[]=["Bob","Joe","Bill"] Return a[Rnd(Len a)] End Function For i=1 To 5 Print RandomName$() Next |
Return | |
Description | Return from a Function |
Example | Rem Return exits a BlitzMax function or method with an optional value. The type of return value is dictated by the type of the function. End Rem Function CrossProduct#(x0#,y0#,z0#,x1#,y1#,z1#) Return x0*x1+y0*y1+z0*z1 End Function Print "(0,1,2)x(2,3,4)="+CrossProduct(0,1,2,2,3,4) Function LongRand:long() Return (rand($80000000,$7fffffff) shl 32)|(rand($80000000,$7fffffff)) End Function Print "LongRand()="+LongRand() Print "LongRand()="+LongRand() |
Type | |
Description | Begin a user defined Type declaration |
Example | Rem Type marks the beginning of a BlitzMax custom type. Standard BlitzMax types use a preceeding "T" naming convention to differentiate themselves from standard BlitzMax variable names. End Rem Type TVector Field x,y,z End Type Local a:TVector=new TVector a.x=10 a.y=20 a.z=30 |
EndType | |
Description | End a user defined Type declaration |
Example | Rem EndType marks the end of a BlitzMax custom type. End Rem Type TVector Field x,y,z End Type Local a:TVector=new TVector a.x=10 a.y=20 a.z=30 |
Extends | |
Description | Specify user defined Type supertype |
Example | Rem Extends is used in a BlitzMax Type declaration to derive the Type from a specified base class. End Rem Type TShape Field xpos,ypos Method Draw() Abstract End Type Type TCircle extends TShape Field radius Function Create:TCircle(x,y,r) local c:TCircle=new TCircle c.xpos=x;c.ypos=y;c.radius=r return c End Function Method Draw() DrawOval xpos,ypos,radius,radius End Method End Type Type TRect extends TShape Field width,height Function Create:TRect(x,y,w,h) local r:TRect=new TRect r.xpos=x;r.ypos=y;r.width=w;r.height=h return r End Function Method Draw() DrawRect xpos,ypos,width,height End Method End Type local shapelist:TShape[4] local shape:TShape shapelist[0]=TCircle.Create(200,50,50) shapelist[1]=TRect.Create(300,50,40,40) shapelist[2]=TCircle.Create(400,50,50) shapelist[3]=TRect.Create(200,180,250,20) graphics 640,480 while not keyhit(KEY_ESCAPE) cls for shape=eachin shapelist shape.draw next flip wend end |
Method | |
Description | Begin a Method declaration |
Example | Rem Method marks the beginning of a BlitzMax custom type member function. End Rem Type TPoint field x,y Method ToString$() return x+","+y End Method End Type a:TPoint=new TPoint print a.ToString() |
EndMethod | |
Description | End a Method declaration |
Example | Rem EndMethod marks the end of a BlitzMax Method declaration. End Rem Type TPoint field x,y Method ToString$() return x+","+y End Method End Type a:TPoint=new TPoint print a.ToString() |
Abstract | |
Description | Denote a Type or Method as Abstract |
Example | Rem A BlitzMax type that contains Abstract methods becomes abstract itself. Abstract types are used to define interfaces that extending types must implement before they can be used to create new instances. In the following code TShape is an abstract type in that you can not create a TShape but anything extending a TShape must implement a Draw() method. End Rem Type TShape Field xpos,ypos Method Draw() Abstract End Type Type TCircle extends TShape Field radius Function Create:TCircle(x,y,r) local c:TCircle=new TCircle c.xpos=x;c.ypos=y;c.radius=r return c End Function Method Draw() DrawOval xpos,ypos,radius,radius End Method End Type Type TRect extends TShape Field width,height Function Create:TRect(x,y,w,h) local r:TRect=new TRect r.xpos=x;r.ypos=y;r.width=w;r.height=h return r End Function Method Draw() DrawRect xpos,ypos,width,height End Method End Type local shapelist:TShape[4] local shape:TShape shapelist[0]=TCircle.Create(200,50,50) shapelist[1]=TRect.Create(300,50,40,40) shapelist[2]=TCircle.Create(400,50,50) shapelist[3]=TRect.Create(200,180,250,20) graphics 640,480 while not keyhit(KEY_ESCAPE) cls for shape=eachin shapelist shape.draw next flip wend end |
Final | |
Description | Denote a Type or Method as Final |
Example | Rem Final stops methods from being redefined in super classes. End Rem Type T1 Method ToString$() Final return "T1" end method End Type Type T2 extends T1 method ToString$() 'compile time error "Final methods cannot be overridden" return "T2" end method End Type |
New | |
Description | Create an instance of a user defined Type |
Example | Rem New creates a BlitzMax variable of the Type specified. End Rem Type MyType Field a,b,c End Type Local t:MyType t=New MyType t.a=20 print t.a ' if a new method is defined for the type it will also be called Type MyClass Field a,b,c Method New() print "Constructor invoked!" a=10 End Method End Type Local c:MyClass c=new MyClass print c.a |
Self | |
Description | Reference to this Method's Object instance |
Example | Rem Self is used in BlitzMax Methods to reference the invoking variable. End Rem Type MyClass Global count Field id Method new() id=count count:+1 ClassList.AddLast(self) 'adds this new instance to a global list End Method End Type Global ClassList:TList classlist=new TList local c:MyClass c=new MyClass c=new MyClass c=new MyClass for c=eachin ClassList print c.id next |
Super | |
Description | Reference to the Super Type Object instance |
Example | Rem Super evaluates to Self cast to the method's immediate base class. End Rem Type TypeA Method Report() print "TypeA reporting" End Method End Type Type TypeB extends TypeA Method Report() Print "TypeB Reporting" super.Report() End Method End Type b:TypeB=new TypeB b.Report() |
Delete | |
Description | Reserved for future expansion |
Example | Rem Reserved for future expansions. End Rem |
Release | |
Description | Release an integer Object handle |
Example | Rem Release removes the internal reference caused by creating an integer handle to a type. End Rem Type MyType Field bigmap[1024*1024] End Type GCCollect Print GCMemAlloced() a=New MyType GCCollect Print GCMemAlloced() Release a GCCollect Print GCMemAlloced() |
Public | |
Description | Public makes a Constant, Global variable or Function accessible from outside the current source file (Default) |
Example | Rem Public makes a variable, function or method accessible from outside the current source file (default). End Rem Public Global Score,Lives,Health Private Global posx,posy,posz |
Private | |
Description | Private makes a Constant, Global variable or Function only accessible from within the current source file |
Example | Rem Private makes a variable, function or method only accessible from within the current source file. End Rem Public Global Score,Lives,Health Private Global posx,posy,posz |
Extern | |
Description | Extern marks the beginning of an external list of Function declarations |
Example | Rem Extern marks the beginning of an external list of function declarations. End Rem Extern Function puts( str$z ) Function my_puts( str$z )="puts" End Extern puts "Using clib's put string!" my_puts "Also using clib's put string!" |
EndExtern | |
Description | EndExtern marks the End of an Extern section |
Example | Rem EndExtern marks the end of an Extern section. End Rem Extern Function puts( str$z ) End Extern puts "Using clib's put string!" |
Module | |
Description | Declare Module scope and identifier |
Information | See the BlitzMax Language Reference for more information on BlitzMax Modules. |
Example | Rem The Module keyword advises the BlitzMax program maker BMK to create a code module from the source file. End Rem Module PUB.Sequencer ModuleInfo "Framework: Audio Sequencer for use with FreeAudio" ModuleInfo "Copyright: Blitz Research Ltd" ModuleInfo "Author: Simon Armstrong" ModuleInfo "Version: 1.00" |
ModuleInfo | |
Description | Define Module properties |
Example | Rem ModuleInfo allows properties such as Author and Copyright to be included in a module file. End Rem Module PUB.Sequencer ModuleInfo "Framework: Audio Sequencer for use with FreeAudio" ModuleInfo "Copyright: Blitz Research Ltd" ModuleInfo "Author: Simon Armstrong" ModuleInfo "Version: 1.00" |
Incbin | |
Description | Embed a data file |
Example | Rem IncBin embeds an external data file in a BlitzMax program that can then be read using the "incbin::" device name. End Rem ' code snippet from demos/firepaint/firepaint.bmx Incbin "stars.png" Local stars=LoadImage( "incbin::stars.png" ) |
IncbinPtr | |
Description | Get start address of embedded data file |
Example | Rem IncBinPtr returns a byte pointer to the specified embedded binary file. End Rem Incbin "incbinptr.bmx" Local p:Byte Ptr=IncbinPtr("incbinptr.bmx") Local bytes=IncbinLen("incbinptr.bmx") Local s$=String.FromBytes(p,bytes) Print "StringFromBytes(p,bytes)="+s$ |
IncbinLen | |
Description | Get length of embedded data file |
Example | Rem IncBinLen returns the size in bytes of the specified embedded binary file. End Rem incbin "incbinlen.bmx" local p:byte ptr=IncBinPtr("incbinlen.bmx") local bytes=incbinlen("incbinlen.bmx") local s$=StringFromBytes(p,bytes) Print "StringFromBytes(p,bytes)="+s$ |
Include | |
Description | Include effectively 'inserts' the specified file into the file being compiled. |
Framework | |
Description | Framework builds the BlitzMax application with only the Module specified rather than all modules installed. |
Import | |
Description | Import declarations from a Module or source file |
Example | Rem :Import specifies the external BlitzMax modules and source files used by the program. End Rem Framework BRL.GlMax2D Import BRL.System Graphics 640,480,32 While Not KeyHit(KEY_ESCAPE) Cls DrawText "Minimal 2D App!",0,0 Flip Wend |
Assert | |
Description | Throw a RuntimeError if a condition is False |
Example | Rem Assert generates a BlitzMax runtime error if the specified condition is false. End Rem a=LoadImage("nonexistant image file") Assert a,"Image Failed to Load" |
Goto | |
Description | Transfer program flow to specified label |
Example | Rem Causes program execution to jump to the #label specified. End Rem Print "one" Goto here Print "two" #here Print "three" |
Try | |
Description | Begin declaration of a Try block |
Example | Rem Begin declaration of a Try block. End Rem Try repeat a:+1 print a if a>20 throw "chunks" forever Catch a$ print "caught exception "+a$ EndTry |
EndTry | |
Description | End declaration of a Try block |
Example | Rem EndTry EndTry marks the end of a Try block. End Rem |
Catch | |
Description | Catch an exception Object in a Try block |
Example | Rem Catch defines an exception handler following a Try..EndTry Block. End Rem Try repeat a:+1 print a if a>20 throw "chunks" forever Catch a$ print "caught exception "+a$ EndTry |
Throw | |
Description | Throw an exception Object to the enclosing Try block |
Example | Rem Throw generates a BlitzMax exception. End Rem Try repeat a:+1 print a if a>20 throw "chunks" forever Catch a$ print "caught exception "+a$ EndTry |
DefData | |
Description | Define class BASIC style data |
Example | ' defdata.bmx ReadData name$ ReadData age,skill Print "name="+name+" age="+age+" skill="+skill DefData "Simon",37,5000 |
ReadData | |
Description | Read classic BASIC style data |
RestoreData | |
Description | Restore classic BASIC style data |
Example | ' restoredata.bmx For i=1 To 5 RestoreData mydata 'reset the data pointer everly loop so we don't read past the end ReadData name$,age,skill Print "name="+name+" age="+age+" skill="+skill Next #mydata 'program label that can be used with the RestoreData command DefData "Simon",37,5000 |
And | |
Description | Conditional 'And' binary operator |
Example | Rem And is a boolean operator that performs the AND function. End Rem For i=1 To 10 If i>3 And i<6 Print "!" Else Print i Next |
Or | |
Description | Conditional 'Or' binary operator |
Example | Rem Or is a boolean operator that performs the OR function. End Rem For i=1 To 5 If i=2 Or i=4 Print "!" Else Print i Next |
Not | |
Description | Conditional 'Not' binary operator |
Example | Rem Not is a boolean unary operator that performs the NOT function. End Rem Print Not 0 'prints 1 (TRUE) Print Not 20 'prints 0 (FALSE) |
Shl | |
Description | Bitwise 'Shift left' binary operator |
Example | Rem Shl is a binary operator that performs the shift to left function. End Rem b=1 for i=1 to 32 print bin(b) b=b shl 1 next |
Shr | |
Description | Bitwise 'Shift right' binary operator |
Example | Rem Shr is a binary operator that performs the shift to right function. End Rem b=-1 for i=1 to 32 print bin(b) b=b shr 1 next |
Sar | |
Description | Bitwise 'Shift arithmetic right' binary operator |
Example | Rem Sar is a binary operator that performs the arithmetic shift to right function. End Rem b=$f0f0f0f0 for i=1 to 32 print bin(b) b=b sar 1 next |
Len | |
Description | Number of characters in a String or elements in an array |
Example | Rem Len is a BlitzMax operator that returns the number of elements in a container Type. End Rem a$="BlitzMax Rocks" Print Len a$ 'prints 14 Local b[] Print Len b 'prints 0 b=new Int[20] Print Len b 'prints 20 |
Abs | |
Description | Numeric 'absolute value' unary operator |
Example | Rem Abs is a mathematical operator that performs the Absolute function. End Rem For f#=-1 To 1 Step 0.125 Print "Abs "+f+"="+Abs f Next |
Mod | |
Description | Numeric 'modulus' or 'remainder' binary operator |
Example | Rem Mod is a mathematical operator that performs the Modulo function. End Rem For i=6 to -6 Step -1 Print i+" Mod 3="+(i Mod 3) Next |
Sgn | |
Description | Numeric 'sign' unary operator |
Example | Rem Sgn is a mathematical operator that returns the sign of a value. End Rem Print Sgn 50 '1 Print Sgn 0 '0 Print Sgn -50 '-1 |
Min | |
Returns | The lesser of the two numeric arguments |
Description | Numeric 'minimum' builtin function |
Max | |
Returns | The larger of the two numeric arguments |
Description | Numeric 'maximum' builtin function |
Varptr | |
Description | Find the address of a variable |
Example | Rem Varptr returns the address of a variable in system memory. End Rem Local a:int Local p:int ptr a=20 p=varptr a print p[0] |
SizeOf | |
Description | Size, in bytes, occupied by a variable, string, array or object |
Example | Rem SizeOf returns the number of bytes of system memory used to store the variable. End Rem Type MyType Field a,b,c End Type Local t:MyType print sizeof t 'prints 12 Local f! print sizeof f 'prints 8 Local i print sizeof i 'prints 4 Local b:Byte print sizeof b 'prints 1 a$="Hello World" print sizeof a 'prints 22 (unicode characters take 2 bytes each) |
Asc | |
Description | Get character value of the first character of a string |
Example | Rem Asc returns the unicode value of the first character of a string. End Rem print Asc("A") '65 Print "A"[0] '65 - equivalent index style implementation |
Chr | |
Description | Create a string of length 1 with a character code |
Example | Rem Chr returns a String of length 1 containing the unicode character of the value. End Rem print Chr(65) 'A |