*****************************************************************************
* 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; 
                               the current color pair is returned as (backcolor shl 16) or forecolor))
  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
  DAY
  DATESERIAL
  DATEVALUE

  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
  HOUR

  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
  LOCK Statement
  LOF Function
  LOC Function
  LOCAL
  LPOS Function         (diff: tries very hard to map a LPTx to a printer)
  LPRINT Statements     (diff: tries very hard to map a LPTx to a printer)

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

  NOT Operator
  NEXT
  NAME Statement
  NOW

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

  POKE Statement
  PEEK Function
  POS Function
  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;
			       the input buffer is not cleared when using multi-threading version of the run-time library)
  SHELL Statement
  SYSTEM Statement
  STOP Statement
  SPC Function
  SEEK Function
  SEEK Statement
  SECOND

  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
  TIMESERIAL
  TIMEVALUE

  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: the current dimensions are returned as: (width or (height shl 16)))
  WRITE (Screen) Statement
  WRITE (File) Statement
  WEEKDAY

  XOR Operator
  
  YEAR

*****************************************************************************
* 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 name(args)    (note: between "name" 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
  ASSERT macro		(only emitted when debugging (-g) is used)
  ASSERTWARN macro	(ditto, but won't end the application, just shows a warning message)

  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
  CONDCREATE Function
  CONDDESTROY Statement
  CONDBROADCAST Statement
  CONDSIGNAL Statement
  CONDWAIT Statement
  CONTINUE Statement
  CURDIR Function
  CVLONGINT Function
  CVSHORT Function
  CPTR			(used to do pointer type-casting: 
			 cptr(type, expression) (where "type" is a pointer type))
  CONSTRUCTOR

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

  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
  GETJOYSTICK 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
  MUTEXCREATE Function
  MUTEXDESTROY Statement
  MUTEXLOCK Statement
  MUTEXUNLOCK Statement

  OVERLOAD

  PRESERVE
  POKES Function
  POKEI Function
  PEEKS Statement
  PEEKI Statement
  PROCPTR Function
  PASCAL
  PTR					(type-modifier)
  POINTER				(same as PTR)
  PUBLIC Statement
  PRIVATE Statement

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

  SCREENCOPY Statement
  SCREENINFO Function
  SCREENLOCK Statement
  SCREENPTR Function
  SCREENRES Statement
  SCREENSET Statement
  SCREENUNLOCK Statement
  SETMOUSE 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))
  
  THREADCREATE Function
  THREADWAIT Statement
  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, 
                         compared against or assigned to/from other strings and also compared 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)
  DEF SEG Statement     (reason: segments are not needed in 32-bit flat mode)

  ERDEV Function        (reason: )
  ERDEV$ Function
  
  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

  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)
