*****************************************************************************
* Implemented *
*****************************************************************************

AS
ASC Function (diff: there's an optional argument to retrieve a char at a specific position, ie: c = asc( "abc", 2 ))
ALIAS
AND Operator
ANY
ATN Function
ABS Function
APPEND
ACCESS

BYVAL
BEEP Statement
BINARY

CALL Statement (diff: function must have being declared already)
CASE
CONST Statement
CDBL Function
CDECL
CSNG Function
CINT Function
CLNG Function
CHR$ Function (diff: accepts multiple arguments too, ie: s$ = chr$( 65, 66, 67, 68 ))
CHAIN Statement
CVD Function
CVI Function
CVL Function
CVS Function
COS Function
COMMAND$ Function (diff: there's an optional parameter that can be used to get a specific argument, ie: argv3$ = command$(3))
COMMON Statement (diff: arrays are always dynamic; no /NAME/; the vars order doesn't matter)
CHDIR Statement
CLS Statement
CSRLIN Function
COLOR Statement (diff: there's no border argument)
CLOSE Statement
CLEAR Statement (diff: completely different mean: used to fill a memory block with some value, args are:
byref dst as any, byval value as integer = 0, byval bytes as integer)

DATA Statement (diff: string literals MUST be enclosed by quotes; Const's are evaluated before storing)
DEFINT Statement
DEFLNG Statement
DEFSNG Statement
DEFSTR Statement
DECLARE Statement
DIM Statement
DO...LOOP Statement
DOUBLE
DEFDBL Statement
$DYNAMIC Metacommand
DATE$ Function
DATE$ Statement (diff: called SETDATE now; syntax is "SETDATE newdate$", not "SETDATE$ = newdate$")
DIR$ Function

ELSE
ELSEIF
END Statement (diff: supports returning an integer result to OS)
ENDIF
EXIT Statement
ERASE Statement
EXP Function
EQV Operator
ERR Function (diff: error numbers are not the same as in QB)
ERROR Statement (diff: same as above )
ENVIRON Statement (diff: called SETENVIRON now)
ENVIRON$ Function
EOF Function

FOR Statement (diff: doesn't support implicity pointers (ie: byref vars) as counters)
FUNCTION Statement
FIX Function
FREEFILE Function
FRE Function (diff: value doesn't matter, always returns the free physical mem available)

GOSUB Statement
GOTO Statement
GET (File) Statement (diff: reads full arrays too, as in VB: "GET #f, , inarray()" )

HEX$ Function

IF...THEN Statement
$INCLUDE Metacommand
INTEGER
IS
IMP Operator
INSTR Function
INT Function
INKEY$ Function (diff: for extended scan-codes, 255 will be returned, not 0; check for chr$(255), not chr$(0))
INPUT$ (Screen) Function
INPUT$ (File) Function
INPUT (Screen) Statement
INPUT (File) Statement

KILL Statement

LET Statement
LBOUND Function
LONG
LOOP
LCASE$ Function
LEFT$ Function
LTRIM$ Function
LOG Function
LEN Function (diff: works with UDT's and types too, ie: len( integer ))
LOCATE Statement (diff: there are no start and stop optional arguments)
LINE INPUT (Screen) Statement
LINE INPUT (File) Statement
LSET Statement (diff: syntax is "LSET dst, src" not "LSET dst = src")
LOCK Statement
LOF Function
LOC Function
LOCAL

MOD
MKL$ Function
MKS$ Function
MKD$ Function
MKI$ Function
MID$ Function
MID$ Statement
MKDIR Statement

NOT Operator
NEXT
NAME Statement (diff: syntax is "NAME oldname, newname" not "NAME oldname AS newname")

OPTION BASE Statement
OR Operator
OCT$ Function
ON ERROR Statement
ON...GOSUB Statement
ON...GOTO Statement
OPEN (File) Statement (diff: PIPE:, SCRN: and KEYB: aren't supported (yet))
OUTPUT

POKE Statement
PEEK Function
POS Function (diff: there's no always-0 argument)
PRINT Statement
PUT (File) Statement (diff: writes full arrays too, as in VB: "PUT #f, , outarray()" )
PRINT (Screen) Statement
PRINT (File) Statement
PRINT (Screen) USING Statement
PRINT (File) USING Statement

RETURN Statement
REDIM Statement
REM Statement
RIGHT$ Function
RTRIM$ Function
RANDOMIZE Statement
RND Function (diff: optional argument < 0 has the same means as if = 0)
RESTORE Statement
READ Statement
RUN Statement (diff: needs the full executable name including extension (.exe))
RESET Statement
RMDIR Statement
RSET Statement (diff: syntax is: "RSET dst, src" not "RSET dst = src")
RANDOM
RESUME Statement (diff: accepts no line numbers or labels; compile with the -ex option)
RESUME NEXT Statement (diff: compile with the -ex option)


STATIC Statement (diff: can be used with arrays too, same way as DIM or REDIM)
$STATIC Metacommand
STEP
SELECT CASE Statement
SHARED Statement (diff: only supported when used with DIM, REDIM or COMMON)
STRING
SINGLE
SUB Statement
SPACE$ Function
SQR Function
SIN Function
STR$ Function (diff: blanks are NOT added for positive signed integers)
STRING$ Function
SADD Function
SGN Function
SWAP Statement
SLEEP Statement (diff: millisecond accuracy, 1 is equal to 1 msec, not 1 sec)
SHELL Statement
SYSTEM Statement
STOP Statement
SPC Function
SEEK Function
SEEK Statement

TO
THEN
TYPE Statement (diff: fields are aligned at dword boundary (use "field=pow2 value" to change))
TAN Function
TIMER Function
TIME$ Function
TIME$ Statement (diff: called SETTIME now; syntax is "SETTIME newtime$", not "SETTIME$ = newtime$")
TAB Function

UBOUND Function
UNTIL
UCASE$ Function
UNLOCK Statement

VARPTR Function
VAL Function
VIEW PRINT Statement (diff: scrolling quirks may not be exactly the same)

WEND
WHILE...WEND Statement
WIDTH Statements (diff: only works for console, no file or printer)
WRITE (Screen) Statement
WRITE (File) Statement

XOR Operator

*****************************************************************************
* Implemented GFX - all details in the docs/gfxlib.txt file *
*****************************************************************************

SCREEN Statement
CIRCLE Statement
DRAW Statement
GET (Graphics) Stmt
LINE (Graphics) Stmt
PCOPY Statement
PUT (Graphics) Stmt
PALETTE Statement
PALETTE USING Stmt
PAINT Statement
POINT Function
PSET Statement
PRESET Statement
PMAP Function
INP Function
OUT Statement
VIEW (Graphics) Stmt
WINDOW Statement
WAIT Statement
BLOAD Statement
BSAVE Statement

*****************************************************************************
* New keywords, statements and functions (the minimal possible) *
*****************************************************************************

#DEFINE
#DEFINE(args) (note: between "#define" and "(", no spaces are allowed, as in C)
#UNDEF
#IFDEF
#IFNDEF
#IF
#ELSE
#ELSEIF
#ENDIF

ALLOCATE Function (function( byval bytes as integer ) as any ptr)
ASM Statement
ACOS Function
ASIN Function
ATAN2 Function

BYTE
BYREF
BIN$
BIT macro (foo = BIT( bar, 10 ) -- same as "foo = (bar and 10 shl 10) > 0")
BITSET macro (foo = BITSET( bar, 5 ) -- same as "foo = bar or (1 shl 5)")
BITRESET macro (foo = BITRESET( bar, 5 ) -- "same as foo = bar and not (1 shl 5)")

CALLOCATE Function (same as ALLOCATE, but clears the contents)
CBYTE Function
CUBYTE Function
CSHORT Function
CUSHORT Function
CUINT Function
CLNGINT Function
CULNGINT Function
CSIGN Function
CUNSG Function
CONTINUE Statement
CURDIR Function
CVLONGINT Function
CVSHORT Function

DEALLOCATE Statement (sub( byval src as any ptr ))
DEFBYTE Statement
DEFUBYTE Statement
DEFSHORT Statement
DEFUSHORT Statement
DEFUINT Statement
DEFINED Function (Pre-processor)

ENUM Statement
EXEPATH Function
EXEC Function (function( program as string, arguments as string ) as integer)
EXTERN Statement (to declare external variables: "EXTERN identifier [ALIAS "name"] [AS type]";
if the variable/array is found COMMON/REDIM/DIM'ed, it will declared as public)

FLIP Statement

GETKEY Function
GETMOUSE Statement

HIBYTE macro (foo = HIBYTE(bar) -- same as "foo = cunsg(bar) shr 8")
HIWORD macro (foo = HIWORD(bar) -- same as "foo = cunsg(bar) shr 16")

IIF()
$INCLIB Directive

LIB
LOBYTE macro (foo = LOBYTE(bar) -- same as "foo = bar and &h000000ff")
LOWORD macro (foo = LOWORD(bar) -- same as "foo = bar and &h0000ffff")

MKLONGINT Function
MKSHORT Function
MULTIKEY Function

PRESERVE
POKES Function
POKEI Function
PEEKS Statement
PEEKI Statement
PROCPTR Function
PASCAL
PTR
POINTER
PUBLIC Statement
PRIVATE Statement

REALLOCATE Function (function( byval src as any ptr, byval bytes as integer ) as any ptr)
RGB Function

SCREENCOPY Statement
SCREENINFO Function
SCREENLOCK Statement
SCREENPTR Function
SCREENSET Statement
SCREENUNLOCK Statement
SHORT
STDCALL
SHL
SHR
STRPTR Function (returns the pointer to string data, not to descriptor as VARPTR will with var-len strings)
SIZEOF Function (returns the size of a variable or data type (with strings it will return the descriptor size,
with fixed-len and zstring's it will be the allocated size )

STRCAT, STRCHR,
STRCMP, STRCPY,
STRLEN, STRNCAT,
STRNCMP, STRNCPY,
STRRCHR, STRSTR (C string functions, can operate on byte ptr's and on ordinary FB strings)

TRIM$ Function

UNION Statement
UNSIGNED
UBYTE
USHORT
UINTEGER

VA_FIRST() macro (returns a pointer to the first variable-argument)
VA_ARG(a,t) macro (returns the current var-arg, a= argument, t= argument type)
VA_NEXT(a,t) macro (returns a pointer to the next var-arg, a= current argument, t= current argument type)
VAL64() (converts a string to a long integer (64 bits))
VALINT() (converts a string to an integer (32 bits))

WINDOWTITLE Statement
WITH..END WITH (compound statement -- won't work with field dereference "->")

ZSTRING (a null-terminated string with a fixed size (known or not) that can be concatenated,
comparated against or assigned to/from other strings and also comparated and assigned
to/from numeric types, making it really powerful if proper used -- btw, if the size
is known as compile time (that is, the zstring is not a pointer), zstrings are
safer than char strings in C, as the max size won't ever be overflowed)

*****************************************************************************
* Unsupported (won't be implemented unless someone else does that...) *
*****************************************************************************

CALL ABSOLUTE Stmt (reason: use inline ASM instead, much easier)
COM Statement (reason: user mode apps can't access IO ports directly)
CALL INTERRUPT Stmt (reason: services are not the same; not needed with shared libs)
CVDMBF Function (reason: old and useless proprietary format)
CVSMBF Function (reason: old and useless proprietary format)
CALLS Statement (reason: same as CALL)

DEF FN Statement (reason: use real functions instead, or macros when implemented)
DEF SEG Statement (reason: segments are not needed in 32-bit flat mode)

ERDEV Function (reason: )
ERDEV$ Function
ERL Function (reason: can't store line numbers, use a debugger instead)

FILEATTR Function (reason: depends on internal tables)
FILES Statement (reason: use dir$ instead)
FIELD Statement (reason: most hacked stmt ever, use records instead)

IOCTL Statement (reason: devices aren't accessed so simply by 32-bit apps)
IOCTL$ Function (reason: ditto)

KEY(n) Statement (reason: no "faked" events)
KEY Statement (reason: ditto)

LIST
LPOS Function (reason: no direct printing, use proper API's instead)
LPRINT Statements (reason: ditto)

MKSMBF$ Function (reason: old and useless proprietary format)
MKDMBF$ Function (reason: ditto)

ON UEVENT Statement (reason: no "faked" events)
OFF (reason: ditto)
ON (but GOSUB/GOTO) (reason: ditto)
ON COM(n) Statement (reason: ditto)
OPEN COM Statement (reason: user mode apps can't access IO ports directly)
ON event Statements (reason: no "faked" events)
ON KEY(n) Statement (reason: ditto)
ON PEN Statement (reason: ditto)
ON PLAY(n) Statement (reason: ditto)
ON STRIG(n) Statement (reason: no "faked" events)
ON TIMER(n) Statement (reason: ditto)

PEN Function (reason: can't access devices directly)
PEN Statement (reason: ditto)
PLAY(n) Function (reason: use real sound libraries instead)
PLAY (Music) Stmt (reason: ditto)
PLAY (Event Trapping) (reason: no "faked" events)

STICK Function (reason: can't access devices directly)
SETMEM Function (reason: un-needed, there are plenty of free mem to use)
STRIG Function (reason: can't access devices directly)
STRIG Statements (reason: ditto)
SIGNAL (reason: seldom if ever used)
SOUND Statement (reason: use real sound libraries instead)
SEG (reason: segments are not needed in 32-bit flat mode)

TIMER Statement (reason: no "faked" events)
TROFF Statement (reason: use a real debugger)
TRON Statement (reason: ditto)

UEVENT Statement (reason: no "faked" events)

VARSEG Function (reason: segments are not needed in 32-bit flat mode)
VARPTR$ Function (reason: no PLAY, not needed)