䡿Erase
顿
﷨Erase ( array As Any [, ... ] )
䡿LBound
顿άȵ
﷨DeclareLBoundLBoundarrayAsAnyByValdimension AsInteger= 1AsInteger
䡿ReDim
顿ɱ䳤ĴС
﷨һ̬飺
ReDim [ Shared ] symbolname ([subscript [, ...]]) As datatype [, ...]
 ReDim [ Shared ] As datatype symbolname ([subscript [, ...]]) [, ...]

 ̬ĴС
 ReDim [ Preserve ] symbolname ([subscript [, ...]]) [, ...]
䡿Preserve
顿ReDimһʹԱݽĴС
﷨ReDim Preserve array (...) [As datatype]
䡿UBound
顿άȵ
﷨DeclareUBoundarrayAsAnyByValdimension AsInteger= 1AsInteger
䡿Bit
顿ȡֵиλ״̬
﷨#define Bit( value , bit_number ) (((value ) And (Cast(TypeOf(value ), 1) Shl (bit_number ))) <> 0)
䡿BitReset
顿ȡָλֵ
﷨#define BitReset( value , bit_number ) ((value ) And Not (Cast(TypeOf(Value ), 1) Shl (bit_number )))
䡿BitSet
顿ȡָλֵ
﷨#define BitSet( value , bit_number ) ((value ) Or (Cast(TypeOf(Value ), 1) Shl (bit_number )))
䡿HiByte
顿ȡĵڶֽڡ
﷨#define HiByte( expr ) ((Cast(UInteger, expr ) And &h0000FF00) Shr 8)
䡿HiWord
顿ȡĵڶ16λ֡
﷨#define HiWord( expr ) ((Cast(UInteger, expr ) and &hFFFF0000) Shr 16)
䡿LoByte
顿ȡֽڡ
﷨#define LoByte( expr ) (Cast(UInteger, expr ) And &h000000FF)
䡿LoWord
顿ò͵16λ֡
﷨#define LoWord( expr ) (Cast(UInteger, expr ) And &h0000FFFF)
䡿Byte
顿׼ͣ8λз
﷨Dim variable As Byte
䡿As
顿ָ͵Ŀѡָ֣ļĴһ֡
﷨symbolname As datatype

 Open ... As #filenumber
 Type ... As datatype
䡿Dim
顿һ
﷨Dim [Shared] name1 As DataType
䡿Const
顿޸ĵı
﷨Const symbolname1 [AS DataType] = value1
䡿Const
顿ָͻָֻġ
﷨... As [Const] datatype [ [Const] Ptr ... ]
䡿Double
顿׼ͣ64λ
﷨Dim variable As Double
䡿Enum
顿ö͡
﷨Enum [typename [ Explicit ] ]
 symbolname [= expression ] [, ...]
 ...
 End Enum
䡿Extends
顿̳ĳࡣ
﷨Type|Union typename Extends base_typename
 ...
 End Type|Union
䡿Integer
顿׼ͣ32λ64λз СSizeOf(Any Ptr)
﷨Dim variable As Integer
 Dim variable As Integer<bits >
䡿Long
顿׼ͣ32λз
﷨Dim variable As Long
䡿LongInt
顿׼ͣ64λз
﷨Dim variable As LongInt
䡿Object
顿ṩʱϢ
﷨Type object
 As fb_BaseVT Ptr vtable_ptr
 Declare Constructor()
 End Type
䡿Scope
顿ʼһµķΧ
﷨Scope
 [statements ]
 End Scope
䡿Shared
顿ָģĿɼԵıη
﷨Dim Shared ...
 ReDim Shared ...
 Common Shared ...
 Static Shared ...
䡿Short
顿׼ͣ16λз
﷨Dim variable As Short
䡿String
顿׼ͣ8λַ
﷨Dim variable As String [ * size ]
䡿Single
顿׼ͣ32λ
﷨Dim variable As Single
䡿Static
顿о̬洢ı
﷨Static symbol1 [ (array-dimensions ) ] As DataType [ = expression ] [, symbol2 [ (array-dimensions ) ] As DataType [ = expression ], ...]
 or
 Static As DataType symbol1 [ (array-dimensions ) ] [ = expression ] [, symbol2 [ (array-dimensions ) ] [ = expression ], ...]

 or

 Sub|Function procedurename ( parameters ) [As DataType] Static
 ...
 End Sub|Function
䡿Type
顿û͡
﷨Type typename
 fieldname1 As DataType
 fieldname2 As DataType
 As DataType fieldname3 , fieldname4
 ...
 End Type

 Type typename [Extends base_typename ] [Field = alignment ]
 [Private:|Public:|Protected:]

 Declare Sub|Function|Constructor|Destructor|Property|Operator ...
 Static variablename As DataType

 fieldname As DataType [= initializer ]
 fieldname (array dimensions ) As DataType [= initializer ]
 fieldname (Any [, Any...]) As DataType
 fieldname : bits As DataType [= initializer ]

 As DataType fieldname [= initializer ], ...
 As DataType fieldname (array dimensions ) [= initializer ], ...
 As DataType fieldname (Any [, Any...])
 As DataType fieldname : bits [= initializer ], ...

 Union
 fieldname As DataType
 Type
 fieldname As DataType
 ...
 End Type
 ...
 End Union

 ...
 End Type
䡿Type
顿Ϊ
﷨Type typename As symbol
䡿Type
顿û͵ʱ
﷨result = Type( initializers , ... )
 or
 result = Type<typename >( initializers , ... )
䡿UByte
顿׼ͣ8λ޷
﷨Dim variable As UByte
䡿UInteger
顿׼ͣ32λ64λ޷ţСSizeOf(Any Ptr)
﷨Dim variable As UInteger
 Dim variable As UInteger<bits >
䡿ULong
顿׼ͣ32λ޷
﷨Dim variable As ULong
䡿ULongInt
顿׼ͣ64λ޷
﷨Dim variable As ULongInt
䡿Union
顿һû͡
﷨Union typename
 fieldname as datatype
 Declare member function declaration ...
 ...
 End Union
䡿Unsigned
顿η
﷨Dim variable As Unsigned {integer-based data type}
䡿UShort
顿׼ͣ16λ޷
﷨Dim variable As UShort
䡿Var
顿һʹӳʼʽ
﷨Var [Shared] symbolname = expression [, symbolname = expression ]
䡿With
顿ʽûͱеֶ
﷨With user_defined_var
 statements
 End With
䡿WString
顿׼ַͣ
﷨Dim variable As WString * size
 Dim variable As WString Ptr
䡿ZString
顿׼ͣ8λַ
﷨Dim variable As ZString * size
 Dim variable As ZString Ptr
䡿Date
顿ַʽصǰϵͳ
﷨Date ( ) As String
䡿DateAdd
顿ָļƫ
﷨DateAdd ( ByRef interval As Const String, ByVal number As Double, ByVal date_serial As Double ) As Double
䡿DateDiff
顿ȡָڵĲ
﷨DateDiff ( ByRef interval As Const String, ByVal serial1 As Double, ByVal serial2 As Double, ByVal firstdayofweek As Integer = fbUseSystem, ByVal firstdayofyear As Integer = fbUseSystem ) As Integer
䡿DatePart
顿ڻȡ
﷨DatePart ( ByRef interval As Const String, ByVal date_serial As Double, ByVal firstdayofweek As Integer = fbUseSystem, ByVal firstdayofyear As Integer = fbUseSystem ) As Integer
䡿DateSerial
顿к
﷨DateSerial ( ByVal year As Integer, ByVal month As Integer, ByVal day As Integer ) As Integer
䡿DateValue
顿ַк
﷨DateValue ( ByRef date_string As String ) As Double
䡿Day
顿кŻȡһµ
﷨Day ( ByVal date_serial As Double ) As Integer
䡿Hour
顿кŻȡһеСʱ
﷨Hour ( ByVal date_serial As Double ) As Integer
䡿IsDate
顿ַǷתΪк
﷨IsDate ( ByRef stringdate As Const String ) As Integer
䡿Minute
顿кŻȡСʱʱ
﷨Minute ( ByVal date_serial As Double ) As Integer
䡿Month
顿кŻһе·
﷨Month ( ByVal date_serial As Double ) As Integer
䡿MonthName
顿ʾлȡһµ
﷨MonthName ( ByVal month As Integer, ByVal abbreviate As Integer = 0 ) As String
䡿Now
顿ȡǰϵͳʱΪк
﷨Now ( ) As Double
䡿Second
顿кŻȡ
﷨Second ( ByVal date_serial As Double ) As Integer
䡿SetDate
顿õǰϵͳ
﷨SetDate ( ByRef newdate As Const String ) As Integer
䡿SetTime
顿õǰϵͳʱ
﷨SetTime ( ByRef newtime As Const String ) As Integer
䡿Time
顿ַʽصǰϵͳʱ
﷨Time ( ) As String
䡿TimeSerial
顿ȡкָСʱӡ
﷨TimeSerial ( ByVal hour As Integer, ByVal minute As Integer, ByVal second As Integer ) As Double
䡿TimeValue
顿ʱַȡк
﷨TimeValue ( ByRef timestring As String ) As Double
䡿Timer
顿Ծ̬οʱ
﷨Timer ( ) As Double
䡿Year
顿кŻһ
﷨Year ( ByVal date_serial As Double ) As Integer
䡿Weekday
顿кŻȡڼ
﷨Weekday ( ByVal serial As Double , ByVal firstdayofweek As Integer = fbusesystem ) As Integer
䡿WeekdayName
顿лȡһܵ
﷨WeekdayName ( ByVal weekday As Integer, ByVal abbreviate As Integer = 0, ByVal firstdayofweek As Integer = fbUseSystem ) As String
䡿Access
顿OpenָȨ
﷨Open filename for Binary Access {Read | Write | Read Write} as [#]filenum
䡿Append
顿ָıļΪ׷ģʽ
﷨Open filename for Append [Encoding encoding_type ] [Lock lock_type ] as [#]filenum
䡿Binary
顿ָ򿪶ģʽļ豸
﷨Open filename for Binary [Access access_type ] [Lock lock_type ] as [#]filenum
䡿BLoad
顿ʹBSaveļݵBMPͼļмݡ
﷨BLoad ( ByRef filename As Const String, ByVal dest As Any Ptr = 0, ByVal pal As Any Ptr = 0 ) As Integer
䡿BSave
顿һݺ͵ɫϢ浽ϵļ
﷨BSave ( ByRef filename As Const String, ByVal source As Any Ptr, ByVal size As Integer = 0, ByVal pal As Any Ptr = 0, ByVal bitsperpixel As Integer = 0 ) As Integer
䡿Close
顿ر Open 򿪵/ (I/O) ļ
﷨Close [[#]filenum ] [, [#]filenum ...]
 or
 result = Close( [#filenum ] )
䡿Encoding
顿ָıļַʽ
﷨Open filename for {Input|Output|Append} Encoding "utf-8 "|"utf-16 "|"utf-32 "|"ascii " as [#]filenum
䡿EOF
顿ǷѾļĩβ
﷨EOF ( ByVal filenum As Integer ) As Integer
䡿FreeFile
顿һеļ
﷨FreeFile ( ) As Integer
䡿Get
顿ļȡݵ
﷨Get #filenum As Integer, [position As LongInt], ByRef data As Any [, [amount As Integer] [, ByRef bytesread As UInteger] ]
 Get #filenum As Integer, [position As LongInt], data As String [, , ByRef bytesread As UInteger ]
 Get #filenum As Integer, [position As LongInt], data() As Any [, , ByRef bytesread As UInteger ]
䡿Input
顿ָҪΪģʽ򿪵ıļ
﷨Open filename for Input [Encoding encoding_type ] [Lock lock_type ] as [#]filenum
䡿Input
顿ıļжȡֵб
﷨Input # filenum , variable_list
䡿Line
顿ļжȡһı
﷨Line Input #file number , string_variable
䡿LOC
顿ִһļ/дļλ
﷨LOC ( ByVal filenum As Integer ) As LongInt
䡿Lock
顿ƶļļֵĶ/д
﷨Lock #filenum , record
 Lock #filenum , start To end
䡿LOF
顿ش򿪵Ĵļĳ
﷨LOF ( ByVal filenum As Integer ) As LongInt
䡿Open
顿ʹļ򿪴ļжȡд
﷨Open filename For Input [encoding_type ] [lock_type ] As [#]filenumber
 Open filename For Output [encoding_type ] [lock_type ] As [#]filenumber
 Open filename For Append [encoding_type ] [lock_type ] As [#]filenumber

 Open filename For Binary [access_type ] [lock_type ] As [#]filenumber
 Open filename For Random [access_type ] [lock_type ] As [#]filenumber [Len = record_length ]
䡿Output
顿ָҪģʽıļ
﷨Open filename for Output [Encoding encoding_type ] [Lock lock_type ] as [#]filenum
䡿Print #
顿ֵбдļ豸
﷨Print # filenum , [ expressionlist ] [ , | ; ]
䡿Put
顿ݴӻдļ
﷨Put #filenum As Integer, [position As LongInt], data As Any [, amount As Integer]
 Put #filenum As Integer, [position As LongInt], data As String
 Put #filenum As Integer, [position As LongInt], data() As Any
䡿Random
顿ָ򿪶ģʽļ豸
﷨Open filename for Random [Access access_type ] [Lock lock_type ] as [#]filenum [Len = record_length ]
䡿Read
顿ļ˵
﷨Open filename As String For Binary Access Read As #filenum As Integer
䡿Read
顿ļ˵
﷨Open filename As String For Binary Access Read Write As #filenum As Integer
䡿Reset
顿رд򿪵ļñ׼ I/O 
﷨Reset ( )
 Reset ( ByVal streamno As Integer )
䡿Seek
顿ļһζ/дλ
﷨Seek [#]filenum , position
䡿Unlock
顿ɾļϵǰƣ
﷨Unlock #filenum , record
 Unlock #filenum , start To end
䡿Write
顿һŷֵָбıļ豸
﷨Write # filenum , [ expressionlist ]
䡿Write
顿ļ˵
﷨Open filename As String For Binary Access Write As #filenum As Integer
䡿=
顿Ϊֵһֵ
﷨Declare Operator Let ( ByRef lhs As T1 , ByRef rhs As T2 )
䡿&=
顿׷Ӳֵһַһַ
﷨Declare Operator &= ( ByRef lhs As String, ByRef rhs As T2 )
 Declare Operator &= ( ByRef lhs As WString, ByRef rhs As T2 )
䡿+=
顿Ӳֵһ
﷨Declare Operator += ( ByRef lhs As T1 , ByRef rhs As T2 )

 Declare Operator += ( ByRef lhs As T Ptr, ByRef rhs As Integer )

 Declare Operator += ( ByRef lhs As String, ByRef rhs As String )
 Declare Operator += ( ByRef lhs As WString, ByRef rhs As WString )
䡿-=
顿ȥֵһ
﷨Declare Operator -= ( ByRef lhs As T1 , ByRef rhs As T2 )

 Declare Operator -= ( ByRef lhs As T Ptr, ByRef rhs As Integer )
䡿*=
顿һֵֵ
﷨Declare Operator *= ( ByRef lhs As T1 , ByRef rhs As T2 )
䡿/=
顿ֵ
﷨Declare Operator /= ( ByRef lhs As T1 , ByRef rhs As T2 )
䡿\=
顿һֵֵһ
﷨Declare Operator \= ( ByRef lhs As T1 , ByRef rhs As T2 )
䡿^=
顿ָ
﷨Declare Operator ^= ( ByRef lhs As Double, ByRef rhs As Double )
䡿Mod=
顿ֵֵ
﷨Declare Operator Mod= ( ByRef lhs As Integer, ByRef rhs As Integer )
䡿And=
顿ִаλͣӣֵ
﷨Declare Operator And= ( ByRef lhs As T1 , ByRef rhs As T2 )
䡿Eqv=
顿ִаλeqvȼֵۣ
﷨Declare Operator And= ( ByRef lhs As T1 , ByRef rhs As T2 )
䡿Imp=
顿ִbitwise-imp壩ֵ
﷨Declare Operator Imp= ( ByRef lhs As T1 , ByRef rhs As T2 )
䡿or=
顿ִаλ򣨰룩ֵ
﷨Declare Operator Or= ( ByRef lhs As T1 , ByRef rhs As T2 )
䡿Xor=
顿ִһbitwise-xorռ룩ֵһ
﷨Declare Operator Xor= ( ByRef lhs As T1 , ByRef rhs As T2 )
䡿Shl=
顿ƶΪֵ
﷨Declare Operator Shl= ( ByRef lhs As Integer, ByRef rhs As Integer )
 Declare Operator Shl= ( ByRef lhs As UInteger, ByRef rhs As UInteger )
 Declare Operator Shl= ( ByRef lhs As LongInt, ByRef rhs As LongInt )
 Declare Operator Shl= ( ByRef lhs As ULongInt, ByRef rhs As ULongInt )
䡿Shr=
顿ƶΪֵ
﷨Declare Operator Shr= ( ByRef lhs As Integer, ByRef rhs As Integer )
 Declare Operator Shr= ( ByRef lhs As UInteger, ByRef rhs As UInteger )
 Declare Operator Shr= ( ByRef lhs As LongInt, ByRef rhs As LongInt )
 Declare Operator Shr= ( ByRef lhs As ULongInt, ByRef rhs As ULongInt )
䡿Let
顿ʾֵʱ=ҵ
﷨{ Type | Class | Union | Enum } typename
 Declare Operator Let ( [ ByRef | ByVal ] rhs As datatype )
 End { Type | Class | Union }

 Operator typename .Let ( [ ByRef | ByVal ] rhs As datatype )
䡿Let()
顿û͵ֶθֵб
﷨Let( variable1 [, variable2 [, ... ]] ) = UDT_var
䡿+
顿ܽʽ
﷨Declare Operator + ( ByRef lhs As Byte, ByRef rhs As Byte ) As Byte
 Declare Operator + ( ByRef lhs As UByte, ByRef rhs As UByte ) As UByte
 Declare Operator + ( ByRef lhs As Short, ByRef rhs As Short ) As Short
 Declare Operator + ( ByRef lhs As UShort, ByRef rhs As UShort ) As UShort
 Declare Operator + ( ByRef lhs As Integer, ByRef rhs As Integer ) As Integer
 Declare Operator + ( ByRef lhs As UInteger, ByRef rhs As UInteger ) As UInteger
 Declare Operator + ( ByRef lhs As LongInt, ByRef rhs As LongInt ) As LongInt
 Declare Operator + ( ByRef lhs As ULongInt, ByRef rhs As ULongInt ) As ULongInt

 Declare Operator + ( ByRef lhs As Single, ByRef rhs As Single ) As Single
 Declare Operator + ( ByRef lhs As Double, ByRef rhs As Double ) As Double

 Declare Operator + ( ByRef lhs As T Pointer, ByRef rhs As Integer ) As T Pointer
 Declare Operator + ( ByRef rhs As Integer, ByRef lhs As T Pointer ) As T Pointer

 Declare Operator + ( ByRef lhs As T , ByRef rhs As Integer ) As T
 Declare Operator + ( ByRef lhs As Integer, ByRef rhs As T ) As T
䡿-
顿ȥʽ
﷨Declare Operator - ( ByRef lhs As Byte, ByRef rhs As Byte ) As Byte
 Declare Operator - ( ByRef lhs As UByte, ByRef rhs As UByte ) As UByte
 Declare Operator - ( ByRef lhs As Short, ByRef rhs As Short ) As Short
 Declare Operator - ( ByRef lhs As UShort, ByRef rhs As UShort ) As UShort
 Declare Operator - ( ByRef lhs As Integer, ByRef rhs As Integer ) As Integer
 Declare Operator - ( ByRef lhs As UInteger, ByRef rhs As UInteger ) As UInteger
 Declare Operator - ( ByRef lhs As LongInt, ByRef rhs As LongInt ) As LongInt
 Declare Operator - ( ByRef lhs As ULongInt, ByRef rhs As ULongInt ) As ULongInt

 Declare Operator - ( ByRef lhs As Single, ByRef rhs As Single ) As Single
 Declare Operator - ( ByRef lhs As Double, ByRef rhs As Double ) As Double

 Declare Operator - ( ByRef lhs As T Pointer, ByRef rhs As T Pointer ) As Integer
 Declare Operator - ( ByRef lhs As T Pointer, ByRef rhs As Integer ) As T Pointer

 Declare Operator - ( ByRef lhs As T , ByRef rhs As T ) As Integer
 Declare Operator - ( ByRef lhs As T , ByRef rhs As Integer ) As T
 Declare Operator - ( ByRef lhs As Integer, ByRef rhs As T ) As T
䡿*
顿ֱʽ
﷨Declare Operator * ( ByRef lhs As Byte, ByRef rhs As Byte ) As Byte
 Declare Operator * ( ByRef lhs As UByte, ByRef rhs As UByte ) As UByte
 Declare Operator * ( ByRef lhs As Short, ByRef rhs As Short ) As Short
 Declare Operator * ( ByRef lhs As UShort, ByRef rhs As UShort ) As UShort
 Declare Operator * ( ByRef lhs As Integer, ByRef rhs As Integer ) As Integer
 Declare Operator * ( ByRef lhs As UInteger, ByRef rhs As UInteger ) As UInteger
 Declare Operator * ( ByRef lhs As LongInt, ByRef rhs As LongInt ) As LongInt
 Declare Operator * ( ByRef lhs As ULongInt, ByRef rhs As ULongInt ) As ULongInt

 Declare Operator * ( ByRef lhs As Single, ByRef rhs As Single ) As Single
 Declare Operator * ( ByRef lhs As Double, ByRef rhs As Double ) As Double
䡿/
顿
﷨Declare Operator / ( ByRef lhs As Byte, ByRef rhs As Byte ) As Byte
 Declare Operator / ( ByRef lhs As UByte, ByRef rhs As UByte ) As UByte
 Declare Operator / ( ByRef lhs As Short, ByRef rhs As Short ) As Short
 Declare Operator / ( ByRef lhs As UShort, ByRef rhs As UShort ) As UShort
 Declare Operator / ( ByRef lhs As Integer, ByRef rhs As Integer ) As Integer
 Declare Operator / ( ByRef lhs As UInteger, ByRef rhs As UInteger ) As UInteger
 Declare Operator / ( ByRef lhs As LongInt, ByRef rhs As LongInt ) As LongInt
 Declare Operator / ( ByRef lhs As ULongInt, ByRef rhs As ULongInt ) As ULongInt

 Declare Operator / ( ByRef lhs As Single, ByRef rhs As Single ) As Single
 Declare Operator / ( ByRef lhs As Double, ByRef rhs As Double ) As Double
䡿\
顿
﷨Declare Operator \ ( ByRef lhs As Integer, ByRef rhs As Integer ) As Integer
䡿^
顿ָ
﷨Declare Operator ^ ( ByRef lhs As Double, ByRef rhs As Double ) As Double
䡿Mod
顿ȡ̵
﷨Declare Operator Mod ( ByRef lhs As Integer, ByRef rhs As Integer ) As Integer
䡿-
顿ֱʽķ
﷨Declare Operator - ( ByRef rhs As Integer ) As Integer
 Declare Operator - ( ByRef rhs As Single ) As Single
 Declare Operator - ( ByRef rhs As Double ) As Double
䡿Shl
顿ֱʽλƶ
﷨Declare Operator Shl ( ByRef lhs As Integer, ByRef rhs As Integer ) As Integer
 Declare Operator Shl ( ByRef lhs As UInteger, ByRef rhs As UInteger ) As UInteger
 Declare Operator Shl ( ByRef lhs As LongInt, ByRef rhs As LongInt ) As LongInt
 Declare Operator Shl ( ByRef lhs As ULongInt, ByRef rhs As ULongInt ) As ULongInt
䡿Shr
顿ֱʽλƶ
﷨Declare Operator Shr ( ByRef lhs As Integer, ByRef rhs As Integer ) As Integer
 Declare Operator Shr ( ByRef lhs As UInteger, ByRef rhs As UInteger ) As UInteger
 Declare Operator Shr ( ByRef lhs As LongInt, ByRef rhs As LongInt ) As LongInt
 Declare Operator Shr ( ByRef lhs As ULongInt, ByRef rhs As ULongInt ) As ULongInt
䡿And
顿ֵİλͣӣ
﷨Declare Operator And ( ByRef lhs As T1 , ByRef rhs As T2 ) As Ret
䡿Eqv
顿ֵİλͣЧ
﷨Declare Operator Eqv ( ByRef lhs As T1 , ByRef rhs As T2 ) As Ret
䡿Imp
顿ֵİλͣ壩
﷨Declare Operator Imp ( ByRef lhs As T1 , ByRef rhs As T2 ) As Ret
䡿Or
顿ֵλ (߼)
﷨Declare Operator Or ( ByRef lhs As T1 , ByRef rhs As T2 ) As Ret
䡿Not
顿һֵλ
﷨Declare Operator Not ( ByRef rhs As Byte ) As Integer
 Declare Operator Not ( ByRef rhs As UByte ) As Integer
 Declare Operator Not ( ByRef rhs As Single ) As Integer
 Declare Operator Not ( ByRef rhs As Double ) As Integer
 Declare Operator Not ( ByRef rhs As T ) As T
䡿Xor
顿ֵbitwise-xorexclusive disjunction
﷨Declare Operator Xor ( ByRef lhs As T1 , ByRef rhs As T2 ) As Ret
䡿AndAlso
顿ֵĶ·ͣӣ
﷨Declare Operator AndAlso ( ByRef lhs As T1 , ByRef rhs As T2 ) As Ret
䡿OrElse
顿ֵĶ·-߼
﷨Declare Operator OrElse ( ByRef lhs As T1 , ByRef rhs As T2 ) As Ret
䡿Abs
顿һֵľֵ
﷨Abs Overload ( ByVal number As Integer ) As Integer
 Abs ( ByVal number As UInteger ) As UInteger
 Abs ( ByVal number As LongInt ) As LongInt
 Abs ( ByVal number As ULongInt ) As ULongInt
 Abs ( ByVal number As Double ) As Double
䡿Acos
顿ȡһǵķ
﷨Acos ( ByVal number As Double ) As Double
䡿Asin
顿ҳֵķ
﷨Asin ( ByVal number As Double ) As Double
䡿Atan2
顿رķ
﷨Atan2 ( ByVal y As Double, ByVal x As Double ) As Double
䡿Atn
顿ֵķ
﷨Atn ( ByVal number As Double ) As Double
䡿Cos
顿ؽǶȵֵ
﷨Cos ( ByVal angle As Double ) As Double
䡿Exp
顿 e ĸֵʾٴݡ
﷨Exp cdecl ( ByVal number As Double ) As Double
䡿Fix
顿һֵ֣
﷨Fix ( ByVal number As Double ) As Double
 Fix ( ByVal number As Integer ) As Integer
 Fix ( ByVal number As UInteger ) As UInteger
 Fix ( ByVal number As LongInt ) As LongInt
 Fix ( ByVal number As ULongInt ) As ULongInt
䡿Frac
顿ֵС
﷨Frac ( ByVal number As Double ) As Double
 Frac ( ByVal number As Integer ) As Integer
 Frac ( ByVal number As UInteger ) As UInteger
 Frac ( ByVal number As LongInt ) As LongInt
 Frac ( ByVal number As ULongInt ) As ULongInt
䡿Int
顿ֵ
﷨Int ( ByVal number As Double ) As Double
 Int ( ByVal number As Integer ) As Integer
 Int ( ByVal number As UInteger ) As UInteger
 Int ( ByVal number As LongInt ) As LongInt
 Int ( ByVal number As ULongInt ) As ULongInt
䡿Log
顿ظֵȻ
﷨Log cdecl ( ByVal number As Double ) As Double
䡿Randomize
顿
﷨Randomize ( ByVal seed As Double = -1.0, ByVal algorithm As Integer = 0 )
䡿Rnd
顿һ Double ֵΧ [0, 1]֮
﷨Rnd ( ByVal seed As Single = 1.0 ) As Double
䡿Sgn
顿ֵķŲ
﷨Sgn Overload ( ByVal number As Integer ) As Integer
 Sgn ( ByVal number As LongInt ) As LongInt
 Sgn ( ByVal number As Double ) As Double
䡿Sin
顿һǶȵ
﷨Sin ( ByVal angle As Double ) As Double
䡿Sqr
顿ֵƽ
﷨Sqr ( ByVal number As Double ) As Double
䡿Tan
顿ؽǶȵ
﷨Tan ( ByVal angle As Double ) As Double
䡿Allocate
顿ӿд洢ֵһڴ
﷨Allocate cdecl ( ByVal count As Integer ) As Any Ptr
䡿CAllocate
顿ӿд洢ΪһԪظֵڴ棬
﷨CAllocate cdecl ( ByVal num_elements As Integer, ByVal size As Integer = 1 ) As Any Ptr
䡿Clear
顿ʼһЩڴ
﷨Clear cdecl ( ByRef dst As Any, ByVal value As Integer = 0, ByVal bytes As Integer )
䡿Deallocate
顿ͷǰֵڴ
﷨Deallocate cdecl ( ByVal pointer As Any Ptr )
䡿Field
顿ֶָζ롣
﷨Type|Union typename Field = { 1 | 2 | 4 }
 ...
 End Type|Union
䡿Fre
顿ؿڴ
﷨Fre ( ByVal value As Integer = 0 ) As UInteger
䡿Peek
顿ڴеĵַȡ͵ֵ
﷨Peek ( ByVal address As Any Ptr ) As UByte
 Peek ( datatype , ByVal address As Any Ptr ) ByRef As datatype
䡿Poke
顿ֵֵڴеλá
﷨Poke ( ByVal address As Any Ptr, ByRef value As UByte )
 Poke ( datatype , ByVal address As Any Ptr, ByRef value As datatype )
䡿Reallocate
顿ΪеԤڴ¸ֵ洢ռ
﷨Reallocate cdecl ( ByVal pointer As Any Ptr, ByVal count As Integer ) As Any Ptr
䡿Asm
顿ʹָṹĻ롣
﷨Asm
 architecture-dependent instructions
 End Asm

 Or

 Asm architecture-dependent instructions
䡿Data
顿ڱʱ洢ݵ
﷨Data constant_expression1 [,constant_expression2 ]...
䡿End
顿ʾĽ
﷨End (Block)
䡿Is
顿Ƿʱͼ
﷨result = expression Is typename
䡿Let
顿ʾֵ
﷨Let variable = value
 or
 Let( variable1 [, variable2 [, ... ]] ) = udt
 or
 Operator typename .Let ( [ ByRef | ByVal ] rhs As datatype )
 statements
 end operator
䡿OffsetOf
顿ֶεƫ
﷨#define OffsetOf(typename , fieldname ) CInt( @Cast( typename Ptr, 0 )->fieldname )
䡿Option()
顿ָŵĸԺ/
﷨Option( "literal-text " )
䡿To
顿η,ָΧ
﷨For iterator intial_value To ending_value
 statement(s) .
 Next [ iterator ]
 or
 Select Case case_comparison_value
 Case lower_bound To upper_bound
 statement(s) .
 End Select
 or
 Dim variable_identifier ( lower_bound To upper_bound ) As type_specifier
䡿Read
顿ȡʹData洢ֵ
﷨Read variable_list
䡿Rem
顿ʾԴеע͡
﷨Rem comment

 ' Comment

 /' Multi-line
 comment '/
䡿Restore
顿ʹData洢ֵһȡλá
﷨Restore label
䡿SizeOf
顿رĴСֽ͡
﷨SizeOf ( variable | DataType )
䡿Swap
顿ֵ
﷨Swap (ByRef a As Any, ByRef b As Any )
䡿TypeOf
顿ر͡
﷨TypeOf ( variable | datatype )
䡿Common
顿ͷΧη
﷨Common [Shared] symbolname [()] [AS DataType] [, ...]
䡿DyLibFree
顿ڴжض̬ӿ
﷨DyLibFree ( ByVal library As Any Pointer )
䡿DyLibLoad
顿ʱ̬ӿ⣨DLLصڴ
﷨DyLibLoad ( ByRef filename As String ) As Any Pointer
䡿DyLibSymbol
顿dllкĵַ
﷨DyLibSymbol ( ByVal library As Any Ptr, ByRef symbol As String ) As Any Ptr
 DyLibSymbol ( ByVal library As Any Ptr, ByVal symbol As Short ) As Any Ptr
䡿Export
顿һ̣ڱDLL󣬿Աá
﷨{ Sub | Function } proc_name ( argumentlist ) [ As datatype ] Export
䡿Extern
顿ⲿӵı
﷨Extern [ Import ] symbolname [ (subscripts ) ] [ Alias "aliasname " ] As DataType [, ...]
䡿Extern...End
顿ΪضԻƽ̨ĺ
﷨Extern { "C" | "C++" | "Windows" | "Windows-MS" } [ Lib "libname " ]
 declarative statements
 End Extern
䡿Import
顿λDLLеĹݵⲿ
﷨Extern Import symbolname [( subscripts )] [ Alias "aliasname "] [ As DataType] [, ...]
䡿Namespace
顿һռ
﷨Namespace identifier [ Alias "aliasname " ]
 statements
 End Namespace
䡿Private
顿ָڲӵĹ
﷨Private Sub procedure_name [cdecl|stdcall|pascal] [Overload] [Alias "external_name" ] [([parameter_list ])] [Constructor [priority ]] [Static] [Export]
 ..procedure body..
 End Sub

 Private Function procedure_name [cdecl|stdcall|pascal] [Overload] [Alias "external_name" ] [([parameter_list ])] As return_type [Static] [Export]
 ..procedure body..
 End Function
䡿Public
顿ָⲿӵĹ̡
﷨Public Sub procedure_name [cdecl|stdcall|pascal] [Overload] [Alias "external_name" ] [([parameter_list ])] [Constructor [priority ]] [Static] [Export]
 ..procedure body..
 End Sub

 Public Function procedure_name [cdecl|stdcall|pascal] [Overload] [Alias "external_name" ] [([parameter_list ])] As return_type [Static] [Export]
 ..procedure body..
 End Function
䡿Using
顿ռ뵱ǰΧ
﷨Using identifier [, identifier [, ...] ]
䡿CondBroadcast
顿߳CondWait
﷨CondBroadcast ( ByVal handle As Any Ptr )
䡿CondCreate
顿̵ͬ߳
﷨CondCreate ( ) As Any Ptr
䡿CondDestroy
顿Ҫʱٶ߳
﷨CondDestroy ( ByVal handle As Any Ptr )
䡿CondSignal
顿ͨCondWaitͣ߳
﷨CondSignal ( ByVal handle As Any Ptr )
䡿CondWait
顿ִֹͣеǰֱ̣߳ĳЩΪ
﷨CondWait ( ByVal handle As Any Ptr, ByVal mutex As Any Ptr )
䡿MutexCreate
顿ִͬ߳еĻ
﷨MutexCreate ( ) As Any Ptr
䡿MutexDestroy
顿ٻ
﷨MutexDestroy ( ByVal id As Any Ptr )
䡿MutexLock
顿ȡ
﷨MutexLock ( ByVal id As Any Ptr )
䡿MutexUnlock
顿ͷŻ
﷨MutexUnlock ( ByVal id As Any Ptr )
䡿Threadcall
顿ڵִ߳вû
﷨Function Threadcall subname ([paramlist ]) As Any Ptr
䡿ThreadCreate
顿ڵִ߳ûĹ
﷨ThreadCreate
 (
 ByVal procptr As Sub ( ByVal userdata As Any Ptr ),
 ByVal param As Any Ptr = 0,
 ByVal stack_size As Integer = 0
 ) As Any Ptr
䡿Threaddetach
顿ͷ߳̾õȴ߳
﷨ThreadDetach ( ByVal id As Any Ptr )
䡿ThreadWait
顿ȴִ߳вͷ߳̾
﷨ThreadWait ( ByVal id As Any Ptr )
䡿Chain
顿ʱȨתƵⲿ
﷨Chain ( ByRef program As Const String ) As Integer
䡿ChDir
顿ĵǰĿ¼
﷨ChDir ( ByRef path As Const String ) As Integer
䡿Command
顿ڵóв
﷨Command ( ByVal index As Integer = -1 ) As String
䡿CurDir
顿صǰĿ¼/ļ
﷨CurDir ( ) As String
䡿Dir
顿ļϵͳйĿϢ;ִĿ¼
﷨# Include "dir.bi"

 Dir Overload ( ByRef item_spec As Const String, ByVal attrib_mask As Integer = fbNormal, ByRef out_attrib As Integer ) As String
 Dir ( ByRef item_spec As Const String, ByVal attrib_mask As Integer = fbNormal, ByVal p_out_attrib As Integer Ptr = 0 ) As String
 Dir ( ByVal attrib_mask As Integer = fbNormal, ByRef out_attrib As Integer ) As String
 Dir ( ByVal attrib_mask As Integer = fbNormal, ByVal p_out_attrib As Integer Ptr = 0 ) As String
䡿End
顿
﷨End ( ByVal retval As Integer = 0 )
䡿Environ
顿ϵͳֵ
﷨Environ ( ByRef varname As Const String ) As String
䡿Exec
顿ʱִתƵⲿ
﷨Exec ( ByRef program As Const String, ByRef arguments As Const String ) As Integer
䡿ExePath
顿еĳ·
﷨ExePath ( ) As String
䡿FileAttr
顿йش򿪵ļŵϢ
﷨FileAttr ( ByVal filenum As Integer, ByVal returntype As Integer = 1 ) As Integer
䡿FileCopy
顿ļ
﷨FileCopy ( ByVal source As ZString Ptr, ByVal destination As ZString Ptr ) As Integer
䡿FileDateTime
顿ļ޸ĵںʱ䷵Ϊк
﷨FileDateTime ( ByVal filename As ZString Ptr ) As Double
䡿FileExists
顿ļĴ
﷨FileExists ( ByVal filename As ZString Ptr ) As Integer
䡿FileLen
顿ҵļļĳ
﷨FileLen ( filename As String ) As LongInt
䡿Isredirected
顿stdinstdoutǷضһļ
﷨IsRedirected ( ByVal is_input As Long = 0 ) As Long
䡿Kill
顿Ӵ/洢ɾļ
﷨Kill ( ByRef filename As Const String ) As Integer
䡿MkDir
顿ڱļϵͳϴһļ/Ŀ¼
﷨MkDir ( ByRef folder As Const String ) As Integer
䡿Name
顿ڴļ
﷨Name( ByRef oldname As Const String, ByRef newname As Const String ) As Integer
䡿RmDir
顿ļϵͳɾļ/Ŀ¼
﷨RmDir ( ByRef folder As Const String ) As Integer
䡿Run
顿ִתƵⲿ
﷨Run ( ByRef program As Const String, ByRef arguments As Const String = "" ) As Integer
䡿SetEnviron
顿ϵͳ
﷨SetEnviron ( ByRef varexpression As String ) As Integer
䡿Shell
顿ϵͳ
﷨Shell ( ByRef command As Const String ) As Integer
䡿System
顿رд򿪵ļ
﷨System ( ByVal retval As Integer = 0 )
䡿WindowTitle
顿ó򴰿ڱ
﷨WindowTitle ( ByRef title As Const String )
䡿Pointer
顿η
﷨Dim symbolname As DataType {Pointer | Ptr}
䡿ProcPtr
顿ع̵ĵַ
﷨Declare Operator ProcPtr ( ByRef lhs As T ) As T Ptr
䡿Ptr
顿η
﷨Dim symbolname As DataType {Ptr | Pointer}
䡿SAdd
顿һַָݵָ
﷨Overload SAdd ( ByRef str As String ) As ZString Ptr
 SAdd ( ByRef str As WString ) As ZString Ptr
 SAdd ( ByRef str As ZString ) As ZString Ptr
䡿StrPtr
顿ַַݵĵַ
﷨Declare Operator StrPtr ( ByRef lhs As String ) As ZString Ptr
 Declare Operator StrPtr ( ByRef lhs As WString ) As ZString Ptr
䡿VarPtr
顿رĵַ
﷨Declare Operator VarPtr ( ByRef lhs As T ) As T Ptr
䡿...
顿ڴ̲ݿɱĲеޣԱʾԪɳʼȷ
﷨Declare { Sub | Function } proc_name cdecl ( param As datatype, ... )

 Dim array_symbol ([lbound To] ...) [As datatype] => { expression_list }

 #define identifier ( [ parameters , ] variadic_parameter ... ) body
䡿Abstract
顿󷽷
﷨Type typename Extends base_typename
 Declare Abstract Sub|Function|Property|Operator ...
 End Type
䡿Alias
顿SubFunctionṩ
﷨[Declare] { Sub | Function } usablename Alias "alternatename " (...)
䡿Any
顿AnyԸַʽͻֵռλ
﷨Dim identifier As Any Pointer|Ptr
 or
 Declare Sub|Function identifier ( ByRef identifier As Any [ , ... ] )
 or
 Dim identifier (Any [, Any...]) As DataType
 or
 [ Declare ] { Sub | Function } proc_name ( param (Any [, Any...]) As DataType )
 or
 Dim identifier As DataType = Any
 or
 New DataType ( Any )
 or
 New(Address) DataType [count ] { Any }
 or
 InStr|InStrRev ( string , Any substring )
䡿Base
顿UDT캯ָUDTĳʼֵ
﷨Base ( constructor-parameters... )
 or:
 Base UDT-initializer
䡿Base
顿ṩTypeķǾ̬ĻͳԱʽ
﷨Base.member
 Base [ .Base ... ] .member
䡿ByRef
顿˵ȷĴһΪַ
﷨ByRef param As datatype
䡿ByRef
顿ָͨ÷غ
﷨Function name ( parameter-list ) ByRef As datatype
䡿ByVal
顿˵ʽݲֵ
﷨ByVal param As datatype
䡿Call
顿ӳ
﷨Call procname ([parameter list ])
䡿cdecl
顿ڹָcdecl ʽԼ
﷨Sub name cdecl [Overload] [Alias "alias" ] ( parameters )
 Function name cdecl [Overload] [Alias "alias" ] ( parameters ) As return_type
䡿Const
顿ָԱֻġ
﷨Type typename
 Declare Const Sub|Function|Property|Operator ...
 End Type
䡿Constructor
顿ûʱԶ
﷨Type typename
 Declare Constructor ( )
 Declare Constructor ( [ ByRef | ByVal ] parameter As datatype [ = default ] [, ... ] )
 End Type

 Constructor typename ( [ parameters ] )
 statements
 End Constructor
䡿Constructor
顿ָģ鼶֮ǰִһ
﷨[Public | Private] Sub procedure_name [Alias "external_identifier "] [()] Constructor [priority ] [Static]
 { procedure body }
 End Sub
䡿Destructor
顿ûͳΧʱԶ
﷨Type typename
 field declarations
 Declare Destructor ( )
 End Type

 Destructor typename ( )
 statements
 End Destructor
䡿Destructor
顿ڳֹʱָһ̵ִ
﷨[Public | Private] Sub identifier [Alias "external_identifier "] [()] Destructor [priority ] [Static]
 { procedure body }
 End Sub
䡿Declare
顿һģ鼶Ա
﷨Declare Sub name [ param_list ]
 Declare Function name [ param_list ] As return_type
 Declare Operator op_symbol param_list [ As return_type ]

 Type T
 Declare Constructor [ param_list ]
 Declare Destructor
 Declare Sub name [ param_list ]
 Declare Function name [ param_list ] As return_type
 Declare Operator name [ param_list ] [ As return_type ]
 Declare Property name [ ( [ param_list ] ) ] [ As return_type ]
 End Type
䡿Function
顿һ(ֵĹ)
﷨[Public|Private] Function identifier [cdecl|pascal|stdcall] [Overload] [Alias external_identifier ] [([parameter_list ])] [As return_type ] [Static] [Export]
 statements
 ...
 { {Return [return_value ]}|{Function = return_value }|{identifier = return_value } }
 ...
 End Function
䡿Function
顿һзֵĳԱ̡
﷨{ Type | Class | Union } typename
 Declare [ Static | Const ] Function fieldname [calling convention specifier ] [ Alias external_name ] ( [ parameters ] ) As datatype [ Static ]
 End { Type | Class | Union }

 Function typename .fieldname ( [ parameters ] ) As datatype
 statements
 End Function
䡿Lib
顿ָҵӻĿ
﷨Declare { Sub | Function } proc_name Lib "libname " [ Alias "symbol_name " ] ( arguments list ) As return_type

 Extern "mangling " lib "libname "
 declarative statements
 end Extern

 Type T
 As Integer dummy
 Declare Constructor Lib "libname " [ Alias "symbol_name " ] ( arguments list )
 end Type
䡿Naked
顿дûprolog / epilogĺ
﷨{Sub | Function} identifier Naked [calling_convention ] ( param_list ) [As data_type ]
 asm_statements
 End {Sub | Function}
䡿Operator
顿һ
﷨{ Type | Class | Union | Enum } typename
 Declare Operator Cast () As datatype
 Declare Operator @ () As datatype Ptr
 Declare Operator assignment_op ( [ ByRef | ByVal ] rhs As datatype )
 Declare Operator [] ( index As datatype ) [ ByRef ] As datatype
 Declare Operator New ( size As UInteger ) As Any Ptr
 Declare Operator New[] ( size As UInteger ) As Any Ptr
 Declare Operator Delete ( buf As Any Ptr )
 Declare Operator Delete[] ( buf As Any Ptr )
 End { Type | Class | Union | Enum }
 { Type | Class | Union } typename
 Declare Operator For ()
 Declare Operator For ( [ ByRef | ByVal ] stp As typename )
 Declare Operator Step ()
 Declare Operator Step ( [ ByRef | ByVal ] stp As typename )
 Declare Operator Next ( [ ByRef | ByVal ] cond As typename ) As Integer
 Declare Operator Next ( [ ByRef | ByVal ] cond As typename , [ ByRef | ByVal ] stp As typename ) As Integer
 End { Type | Class | Union }

 Declare Operator unary_op ( [ ByRef | ByVal ] rhs As datatype ) As datatype
 Declare Operator binary_op ( [ ByRef | ByVal ] lhs As datatype, [ ByRef | ByVal ] rhs As datatype ) As datatype

 Operator typename .Cast () As datatype
 Operator typename .@ () As datatype Ptr
 Operator typename .assignment_op ( [ ByRef | ByVal ] rhs As datatype )
 Operator [] ( index As datatype ) [ ByRef ] As datatype
 Operator unary_op ( [ ByRef | ByVal ] rhs As datatype ) As datatype
 Operator binary_op ( [ ByRef | ByVal ] lhs As datatype, [ ByRef | ByVal ] rhs As datatype ) As datatype
 Operator typename .New ( size as uinteger ) As Any Ptr
 Operator typename .New[] ( size As UInteger ) As Any Ptr
 Operator typename .Delete ( buf As Any Ptr )
 Operator typename .Delete[] ( buf As Any Ptr )
䡿Overload
顿ָƿ
﷨Declare [Static] Sub procedure_name [cdecl|stdcall|pascal] Overload [Alias "external_name" ] [([parameter_list ])] [Constructor [priority ]] [Static] [Export]
 Declare [Static] Function procedure_name [cdecl|stdcall|pascal] Overload [Alias "external_name" ] [([parameter_list ])] As return_type [Static] [Export]
 [Public|Private] Sub procedure_name [cdecl|stdcall|pascal] Overload [Alias "external_name" ] [([parameter_list ])] [Constructor [priority ]] [Static] [Export]
 ..procedure body..
 End Sub
 [Public|Private] Function procedure_name [cdecl|stdcall|pascal] Overload [Alias "external_name" ] [([parameter_list ])] As return_type [Static] [Export]
 ..procedure body..
 End Function
䡿Override
顿;ָ븲
﷨Type typename Extends basename
 ...
 Declare Sub|Function|Operator|Property|Destructor ... ( [parameterlist ] ) [As datatype ] Override
 ...
 End Type
䡿pascal
顿ڹָPascal ʽԼ
﷨Sub name pascal [Overload] [Alias "alias" ] ( parameters )
 Function name pascal [Overload] [Alias "alias" ] ( parameters ) As return_type
䡿Private
顿TypeClassָ˽гԱʿ
﷨Type typename
 Private:
 member declarations
 End Type
䡿Protected
顿TypeClassָܱĳԱʿ
﷨Type typename
 Protected:
 member declarations
 End Type
䡿Property
顿ͻе
﷨{ Type | Class } typename
 Declare Property fieldname () As datatype
 Declare Property fieldname ( [ ByRef | ByVal ] new_value As datatype )
 Declare Property fieldname ( [ ByRef | ByVal ] index As datatype ) As datatype
 Declare Property fieldname ( [ ByRef | ByVal ] index As datatype, [ ByRef | ByVal ] new_value As datatype )
 End { Type | Class }
䡿Public
顿TypeClassָԱʿ
﷨Type typename
 Public:
 member declarations
 End Type
䡿Static
顿̬Ա̻
﷨Type typename
 Static variablename As DataType [, ...]
 Declare Static Sub|Function procedurename ...
 ...
 End Type

 Dim typename.variablename As DataType [= initializer ] [, ...]

 [Static] Sub|Function typename .procedurename ...
 ...
 End Sub|Function
䡿Sub
顿һ
﷨
䡿Sub
顿Ա̡
﷨
䡿stdcall
顿ڹָstdcall ʽԼ
﷨Sub name stdcall [Overload] [Alias "alias" ] ( parameters )
 Function name stdcall [Overload] [Alias "alias" ] ( parameters ) As return_type
䡿This
顿صʵݸTypeClassеķǾ̬Ա
﷨This.fieldname
 or
 With This
 .fieldname
 End With
䡿va_arg
顿ӱбصǰ
﷨variable = va_arg ( argument_list , datatype )
䡿va_first
顿ָбеһָ
﷨pointer_variable = va_first()
䡿va_next
顿ָɱбһָ
﷨Argument_Pointer = va_next ( Argument_List , datatype )
䡿Virtual(成员)
顿ⷽ
﷨Type typename Extends base_typename
 Declare Virtual Sub|Function|Property|Operator|Destructor ...
 End Type
䡿Continue
顿ѭһ
﷨Continue {Do | For | While}
䡿Case
顿
﷨Case expression
䡿Do
顿ѭ
﷨Do [ { Until | While } condition ]
 [ statement block ]
 Loop

 Do
 [ statement block ]
 Loop [ { Until | While } condition ]
䡿Do...Loop
顿ѭ
﷨Do [ { Until | While } condition ]
 [ statement block ]
 Loop
 or
 Do
 [ statement block ]
 Loop [ { Until | While } condition ]
䡿Else
顿֧Ŀ
﷨If expression Then statement(s) [Else statement(s) ]
 or
 If expression Then : statement(s) [Else statement(s) ] : End If
 or
 If expression Then
 statement(s)
 [ ElseIf expression Then ]
 statement(s)
 [ Else ]
 statement(s)
 End If
䡿ElseIf
顿֧Ŀ
﷨If expression Then
 statement(s)
 [ ElseIf expression Then ]
 statement(s)
 [ Else ]
 statement(s)
 End If
䡿EndIf
顿֧Ŀ䡣
﷨
䡿Exit
顿˳
﷨Exit {Do For While Select }
Exit {Sub Function Operator Property }
䡿GoSub
顿ʹһδ벢ء
﷨GoSub label
䡿Goto
顿תһ
﷨Goto label
䡿If...Then
顿֧Ŀ
﷨If expression Then [statement(s) ] [Else [statement(s) ]] [End If]
 or
 If expression Then : [statement(s) ] [Else [statement(s) ]] : End If
 or
 If expression Then
 [statement(s) ]
 [ ElseIf expression Then ]
 [statement(s) ]
 [ Else ]
 [statement(s) ]
 End If
䡿IIf
顿ֵ֮һ
﷨IIf ( condition , expr_if_true , expr_if_false )
䡿Is
顿Select CaseС
﷨Case Is expression
䡿For
顿䣬openӾȡġ
﷨For iterator = startvalue To endvalue [ Step increment ]
 or
 Open [ device ] "filename " For filemode As #handle
 or
 declare operator For ( byref stp as datatype )
䡿For...Next
顿ѭ
﷨For iterator [ As datatype ] = startvalue To endvalue [ Step stepvalue ]
 [ statement block ]
 Next [ iterator ]
䡿Loop
顿ѭ
﷨Do
 [ statement block ]
 Loop [ { Until | While } condition ]
䡿Next
顿For...NextѭĽ
﷨Next [ identifier_list ]
䡿On...Gosub
顿ݱʽñǩ
﷨On expression GoSub label1 [, ...]
䡿On...Goto
顿ڱʽתǩ
﷨On expression Goto label1[, ...]
䡿Return
顿,ӹ̻GoSub.
﷨Return [ expression ]
 or
 Return [ label ]
䡿Select
顿
﷨Select Case expression
 [ Case expressionlist ]
 [statements ]
 [ Case Else ]
 [statements ]
 End Select
 or
 Select Case As Const integer_expression
 [ Case constant | enumeration ]
 [ statements ]
 [ Case Else ]
 [ statements ]
 End Select
䡿Sleep
顿ȴֱָʱȥ߰һ
﷨Sleep Overload ( ByVal amount As Integer = -1 )
 Sleep ( ByVal amount As Integer , ByVal keyflag As Integer ) As Integer
䡿Step
顿η
﷨For iterator = initial_value To end_value Step increment
䡿Then
顿֧Ŀ䡣
﷨If expression Then statement(s) [Else statement(s) ]
 or
 If expression Then : statement(s) [Else statement(s) ] : End If
 or
 If expression Then
 statement(s)
 [ ElseIf expression Then ]
 statement(s)
 [ Else ]
 statement(s)
 End If
䡿Until
顿Do..Loopʹõ䡣
﷨Do Until condition
 or
 Loop Until condition
䡿Wend
顿䡣
﷨While [condition ]
 [statement block ]
 Wend
䡿While
顿䡣
﷨Do While condition
 [statement block ]
 Loop
 or
 Do
 [statement block ]
 Loop While condition
 or
 While [condition ]
 [statement block ]
 Wend
䡿While...Wend
顿ѭ
﷨While [condition ]
 [statement block ]
 Wend
䡿InStr
顿ַеһֵַַ
﷨InStr Overload ( ByRef str As Const String, [ Any ] ByRef substring As Const String ) As Integer
 InStr ( ByRef str As Const WString, [ Any ] ByRef substring As Const WString ) As Integer
 InStr ( ByVal start As Integer, ByRef str As Const String, [ Any ] ByRef substring As Const String ) As Integer
 InStr ( ByVal start As Integer, ByRef str As Const WString, [ Any ] ByRef substring As Const WString ) As Integer
䡿InStrRev
顿ַַַһγ
﷨InStrRev ( ByRef str As Const String, [ Any ] ByRef substring As Const String, ByVal start As Integer = -1 ) As Integer
 InStrRev ( ByRef str As Const WString, [ Any ] ByRef substring As Const WString, ByVal start As Integer = -1 ) As Integer
䡿LCase
顿ַСд
﷨LCase Overload ( ByRef str As Const String, ByVal mode As Integer = 0 ) As String
 LCase ( ByRef str As Const WString, ByVal mode As Integer = 0 ) As WString
䡿Left
顿ַߵӴ
﷨Left Overload ( ByRef str As Const String, ByVal n As Integer ) As String
 Left ( ByRef str As Const WString, ByVal n As Integer ) As WString
䡿Len
顿رʽ͵ĳ
﷨Len ( ByRef expression As String ) As Integer
 Len ( ByRef expression As ZString ) As Integer
 Len ( ByRef expression As WString ) As Integer
 Len ( datatype ) As Integer
䡿LSet
顿һַ
﷨LSet Overload ( ByRef dst As String, ByRef src As Const String )
 LSet ( ByVal dst As WString Ptr, ByVal src As Const WString Ptr )
䡿LTrim
顿ɾһııַ
﷨LTrim Overload ( ByRef str As Const String, [ Any ] ByRef trimset As Const String = " " ) As String
 LTrim ( ByRef str As Const WString, [ Any ] ByRef trimset As Const WString = WStr(" ") ) As WString
䡿Mid
顿һַһַַ
﷨Mid ( ByRef text As String, ByVal start As Integer, ByVal length As Integer, ByRef expression As Const String )
 Mid ( ByVal text As WString Ptr, ByVal start As Integer, ByVal length As Integer, ByVal expression As Const WString Ptr )
䡿Mid
顿ַַ
﷨Mid ( ByRef str as Const String, ByVal start as integer ) as String
 Mid ( ByVal str as Const WString Ptr, ByVal start as integer ) as WString
 Mid ( ByRef str as Const String, ByVal start as integer, ByVal n as integer ) as String
 Mid ( ByVal str as Const WString Ptr, ByVal start as integer, ByVal n as integer ) as WString
䡿Right
顿ַұߵӴ
﷨Right Overload ( ByRef str As Const String, ByVal n As Integer ) As String
 Right ( ByRef str As Const WString, ByVal n As Integer ) As WString
䡿RSet
顿Ҷַеַ
﷨RSet Overload ( ByRef dst As String, ByRef src As Const String )
 RSet ( ByVal dst As WString Ptr, ByVal src As Const WString Ptr )
䡿RTrim
顿ɾַҲΧַַ
﷨RTrim Overload ( ByRef str As Const String, [ Any ] ByRef trimset As Const String = " " ) As String
 RTrim ( ByRef str As Const WString, [ Any ] ByRef trimset As Const WString = WStr(" ") ) As WString
䡿Space
顿һոĸȵַ" "
﷨Space( ByVal count As Integer ) As String
䡿String
顿ضַһȵַ
﷨String ( ByVal count As Integer, ByVal ch_code As Integer ) As String
 String ( ByVal count As Integer, ByRef ch As Const String ) As String
䡿Trim
顿ɾַҲΧַַ
﷨Trim Overload ( ByRef str As Const String, [ Any ] ByRef trimset As Const String = " " ) As String
 Trim ( ByRef str As Const WString, [ Any ] ByRef trimset As Const WString = WStr(" ") ) As WString
䡿UCase
顿ַĴд
﷨UCase Overload ( ByRef str As Const String, ByVal mode As Integer = 0 ) As String
 UCase ( ByRef str As Const WString, ByVal mode As Integer = 0 ) As WString
䡿WSpace
顿һո" "ĸȵWString
﷨WSpace( ByVal count As Integer ) As WString
䡿Wstring
顿дһȵWStringһĿַ
﷨WString ( ByVal count As Integer, ByVal ch_code As Integer ) As WString
 WString ( ByVal count As Integer, ByRef ch As Const WString ) As WString
䡿Asc
顿ַӦASCIIUnicodeʾʽ
﷨Asc Overload ( ByRef str As Const String, ByVal position As Integer = 1 ) As UInteger
 Asc ( ByVal str As Const ZString Ptr, ByVal position As Integer = 1 ) As UInteger
 Asc ( ByVal str As Const WString Ptr, ByVal position As Integer = 1 ) As UInteger
䡿Bin
顿һĶƣbase 2ַʾʽ
﷨Bin Overload ( ByVal number As UByte ) As String
 Bin ( ByVal number As UShort ) As String
 Bin ( ByVal number As Ulong ) As String
 Bin ( ByVal number As ULongInt ) As String
 Bin ( ByVal number As Const Any Ptr ) As String
 Bin ( ByVal number As UByte, ByVal digits As Long ) As String
 Bin ( ByVal number As UShort, ByVal digits As Long ) As String
 Bin ( ByVal number As Ulong, ByVal digits As Long ) As String
 Bin ( ByVal number As ULongInt, ByVal digits As Long ) As String
 Bin ( ByVal number As Const Any Ptr, ByVal digits As Long ) As String
䡿Chr
顿һASCIIֵһַ
﷨Chr ( ByVal ch As Integer [, ... ] ) As String
䡿CVD
顿64λ8ַֽתΪ˫ֵ
﷨CVD ( ByVal l As LongInt ) As Double
 CVD ( ByRef str As Const String ) As Double
䡿CVI
顿ʹöƸȸַתΪ
﷨CVI ( ByVal sng As Single ) As Integer
 CVI ( ByRef str As Const String ) As Integer
 CVI<bits> ( expr As DataType ) As Integer<bits >
䡿CVL
顿ȸַֽתΪLong
﷨CVL ( ByVal sng As Single ) As Long
 CVL ( ByRef str As Const String ) As Long
䡿CVLongInt
顿˫ȸַֽתΪLongInt
﷨CVLongInt ( ByVal dbl As Double ) As LongInt
 CVLongInt ( ByRef str As Const String ) As LongInt
䡿CVS
顿32λ4ַֽתΪȱ
﷨CVS ( ByVal i As Integer ) As Single
 CVS ( ByRef str As Const String ) As Single
䡿CVShort
顿һ˫ַֽתΪShort
﷨CVShort ( ByRef str As Const String ) As Short
䡿Format
顿ʽָʽ
﷨Format ( ByVal numerical_expression As Double, ByRef formatting_expression As Const String = "" ) As String
䡿Hex
顿ظֵʮ
﷨Hex Overload ( ByVal number As UByte ) As String
 Hex ( ByVal number As UShort ) As String
 Hex ( ByVal number As Ulong ) As String
 Hex ( ByVal number As ULongInt ) As String
 Hex ( ByVal number As Const Any Ptr ) As String
 Hex ( ByVal number As UByte, ByVal digits As Long ) As String
 Hex ( ByVal number As UShort, ByVal digits As Long ) As String
 Hex ( ByVal number As Ulong, ByVal digits As Long ) As String
 Hex ( ByVal number As ULongInt, ByVal digits As Long ) As String
 Hex ( ByVal number As Const Any Ptr, ByVal digits As Long ) As String
䡿MKD
顿DoubleStringĶƸƣ䳤Ϊ8ֽ
﷨MKD ( ByVal number As Double ) As String
䡿MKI
顿ĴСͬȵStringĶƸ
﷨MKI ( ByVal number As Integer ) As String
 MKI<bits > ( ByVal number As Integer<bits > ) As String
䡿MKL
顿LongStringĶƸƣ䳤Ϊ4ֽ
﷨MKL ( ByVal number As Long ) As String
䡿MKLongInt
顿LongIntStringĶƸƣ䳤Ϊ8ֽ
﷨MKLongInt ( ByVal number As LongInt ) As String
䡿MKS
顿SingleStringĶƸƣ䳤Ϊ4ֽ
﷨MKS ( ByVal number As Single ) As String
䡿MKShort
顿ShortStringĶƸƣ䳤Ϊ2ֽ
﷨MKShort ( ByVal number As Short ) As String
䡿Oct
顿תΪ˽Ʊʾ
﷨Oct Overload ( ByVal number As UByte ) As String
 Oct ( ByVal number As UShort ) As String
 Oct ( ByVal number As Ulong ) As String
 Oct ( ByVal number As ULongInt ) As String
 Oct ( ByVal number As Const Any Ptr ) As String
 Oct ( ByVal number As UByte, ByVal digits As Long ) As String
 Oct ( ByVal number As UShort, ByVal digits As Long ) As String
 Oct ( ByVal number As Ulong, ByVal digits As Long ) As String
 Oct ( ByVal number As ULongInt, ByVal digits As Long ) As String
 Oct ( ByVal number As Const Any Ptr, ByVal digits As Long ) As String
䡿Str
顿һı͵ֵ Unicode ַı
﷨Str Overload ( ByVal n As Byte ) As String
 Str ( ByVal n As UByte ) As String
 Str ( ByVal n As Short ) As String
 Str ( ByVal n As UShort ) As String
 Str ( ByVal n As Integer ) As String
 Str ( ByVal n As UInteger ) As String
 Str ( ByVal n As LongInt ) As String
 Str ( ByVal n As ULongInt ) As String
 Str ( ByVal n As Single ) As String
 Str ( ByVal n As Double ) As String
 Str ( ByRef str As Const String ) As String
 Str ( ByVal str As Const WString ) As String
䡿Val
顿ַתΪ
﷨Val Overload ( ByRef str As Const String ) As Double
 Val ( ByRef str As Const WString ) As Double
䡿ValLng
顿ַתΪ
﷨ValLng Overload ( ByRef strnum As Const String ) As LongInt
 ValLng ( ByVal strnum As Const WString Ptr ) As LongInt
䡿ValInt
顿ַתΪ
﷨ValInt Overload ( ByRef strnum As Const String ) As Long
 ValInt ( ByVal strnum As Const WString Ptr ) As Long
䡿ValUInt
顿ַתΪ
﷨ValUInt Overload ( ByRef strnum As Const String ) As Ulong
 ValUInt ( ByVal strnum As Const WString Ptr ) As Ulong
䡿ValULng
顿ַתΪ޷ų
﷨ValULng Overload ( ByRef strnum As Const String ) As ULongInt
 ValULng ( ByVal strnum As Const WString Ptr ) As ULongInt
䡿WBin
顿һֵĶWStringUnicodeʾ
﷨WBin Overload ( ByVal number As UByte ) As WString
 WBin ( ByVal number As UShort ) As WString
 WBin ( ByVal number As Ulong ) As WString
 WBin ( ByVal number As ULongInt ) As WString
 WBin ( ByVal number As Const Any Ptr ) As WString
 WBin ( ByVal number As UByte, ByVal digits As Long ) As WString
 WBin ( ByVal number As UShort, ByVal digits As Long ) As WString
 WBin ( ByVal number As Ulong, ByVal digits As Long ) As WString
 WBin ( ByVal number As ULongInt, ByVal digits As Long ) As WString
 WBin ( ByVal number As Const Any Ptr, ByVal digits As Long ) As WString
䡿WChr
顿ذһUnicodeַĿַַ
﷨Wchr ( ByVal ch As Integer [, ... ] ) As WString
䡿WHex
顿һֵʮWStringUnicodeʾ
﷨WHex Overload ( ByVal number As UByte ) As WString
 WHex ( ByVal number As UShort ) As WString
 WHex ( ByVal number As Ulong ) As WString
 WHex ( ByVal number As ULongInt ) As WString
 WHex ( ByVal number As Const Any Ptr ) As WString
 WHex ( ByVal number As UByte, ByVal digits As Long ) As WString
 WHex ( ByVal number As UShort, ByVal digits As Long ) As WString
 WHex ( ByVal number As Ulong, ByVal digits As Long ) As WString
 WHex ( ByVal number As ULongInt, ByVal digits As Long ) As WString
 WHex ( ByVal number As Const Any Ptr, ByVal digits As Long ) As WString
䡿WOct
顿תΪUnicode˽Ʊʾ
﷨WOct Overload ( ByVal number As UByte ) As WString
 WOct ( ByVal number As UShort ) As WString
 WOct ( ByVal number As Ulong ) As WString
 WOct ( ByVal number As ULongInt ) As WString
 WOct ( ByVal number As Const Any Ptr ) As WString
 WOct ( ByVal number As UByte, ByVal digits As Long ) As WString
 WOct ( ByVal number As UShort, ByVal digits As Long ) As WString
 WOct ( ByVal number As Ulong, ByVal digits As Long ) As WString
 WOct ( ByVal number As ULongInt, ByVal digits As Long ) As WString
 WOct ( ByVal number As Const Any Ptr, ByVal digits As Long ) As WString
䡿WStr
顿ֻASCIIַĿַַʾʽ
﷨WStr Overload ( ByVal n As Byte ) As WString
 WStr ( ByVal n As UByte ) As WString
 WStr ( ByVal n As Short ) As WString
 WStr ( ByVal n As UShort ) As WString
 WStr ( ByVal n As Integer ) As WString
 WStr ( ByVal n As UInteger ) As WString
 WStr ( ByVal n As LongInt ) As WString
 WStr ( ByVal n As ULongInt ) As WString
 WStr ( ByVal n As Single ) As WString
 WStr ( ByVal n As Double ) As WString
 WStr ( ByRef str As Const String ) As WString
 WStr ( ByVal str As Const WString Ptr ) As WString
䡿Cast
顿ʽתΪָ
﷨Cast( datatype, expression )
䡿CByte
顿ַֻʽתΪByte.
﷨CByte ( ByVal expression As datatype ) As Byte
䡿CDbl
顿ַֻʽתΪDoubleȸ
﷨CDbl ( ByVal expression As datatype ) As Double
䡿CInt
顿ַֻʽתΪIntegerInteger<bits >
﷨CInt ( ByVal expression As datatype ) As Integer
 CInt<bits > ( ByVal expression As datatype ) As Integer<bits >
䡿CLng
顿ַֻʽתΪLong
﷨CLng ( ByVal expression As datatype ) As Long
䡿CLngInt
顿ַֻʽתΪ64λLongInt
﷨CLngInt ( ByVal expression As datatype ) As LongInt
䡿CPtr
顿ָʽתΪָָ
﷨CPtr( PointerDataType , expression )
䡿CShort
顿numericstringʽתΪShort
﷨CShort ( ByVal expression As datatype ) As Short
䡿CSign
顿תһʽзŵ
﷨CSign ( expression )
䡿CSng
顿ַֻʽתΪSingleȸ
﷨CSng ( ByVal expression As datatype ) As Single
䡿CUByte
顿ַֻʽתΪ޷ֽڣUByte
﷨CUByte ( ByVal expression As datatype ) As UByte
䡿CUInt
顿ַֻʽתΪUIntegerUInteger<bits >
﷨CUInt ( ByVal expression As datatype ) As UInteger
 CUInt<bits > ( ByVal expression As datatype ) As UInteger<bits >
䡿CULng
顿ַֻʽתΪUlong
﷨CULng ( ByVal expression As datatype ) As Ulong
䡿CULngInt
顿ַֻʽתΪ64λ޷ULongInt
﷨CULngInt ( ByVal expression As datatype ) As ULongInt
䡿CUnsg
顿ʽתΪ޷
﷨CUnsg ( expression )
䡿CUShort
顿ַֻʽתΪ޷UShort
﷨CUShort ( ByVal expression As datatype ) As UShort
䡿CharToUTF
顿ͨzstring ַתΪUTF롣
﷨CharToUTF(byval encod as long,byval src as zstring ptr,byval chars as integer,byval dst as any ptr,byval bytes as integer ptr) as any ptr
䡿WCharToUTF
顿ַWstringתΪUTFַ
﷨WCharToUTF(byval encod as long,byval src as wstring ptr,byval chars as integer,byval dst as any ptr,byval bytes as integer ptr) as any ptr
䡿UTFToChar
顿UTFַתΪͨzstring
﷨UTFToChar(byval encod as long,byval src as any ptr,byval dst as zstring ptr,byval chars as integer ptr) as zstring ptr
䡿UTFToWChar
顿UTFַתΪַWstring
﷨UTFToWChar(byval encod as long,byval src as any ptr,byval dst as wstring ptr,byval chars as integer ptr) as wstring ptr
