1574 lines
33 KiB
Text
1574 lines
33 KiB
Text
.topic lang.datatypes
|
|
.title Data Types
|
|
.toc 0 Data Types
|
|
.default
|
|
.index Data Types
|
|
.index Integer
|
|
.index Long
|
|
.index Single
|
|
.index Double
|
|
.index String
|
|
.index Boolean
|
|
|
|
.h1 Data Types
|
|
|
|
DVX BASIC supports the following data types. Each type has a corresponding type suffix character that can be appended to variable names.
|
|
|
|
.h2 Primary Types
|
|
|
|
.table
|
|
Type Size Suffix Range / Description
|
|
---- ---- ------ -------------------
|
|
Integer 2 bytes % -32768 to 32767
|
|
Long 4 bytes & -2147483648 to 2147483647
|
|
Single 4 bytes ! 32-bit float, approximately 7 digits precision
|
|
Double 8 bytes # 64-bit float, approximately 15 digits precision
|
|
String variable $ Variable-length, reference-counted, dynamic string
|
|
Boolean 2 bytes (none) True (-1) or False (0)
|
|
.endtable
|
|
|
|
.h2 Internal Types
|
|
|
|
These types are not directly declarable but are used internally by the runtime.
|
|
|
|
.table
|
|
Internal Type Description
|
|
------------- -----------
|
|
Array Reference-counted multi-dimensional array (up to 8 dimensions)
|
|
UDT User-defined type instance (created with TYPE...END TYPE)
|
|
Object Opaque host object (form reference, control reference)
|
|
Ref ByRef pointer to a variable slot (used for ByRef parameters)
|
|
.endtable
|
|
|
|
.h2 Type Suffixes
|
|
|
|
Type suffixes can be appended to variable names to declare their type implicitly:
|
|
|
|
.code
|
|
count% = 42 ' Integer
|
|
total& = 100000 ' Long
|
|
rate! = 3.14 ' Single
|
|
pi# = 3.14159265 ' Double
|
|
name$ = "Hello" ' String
|
|
.endcode
|
|
|
|
.h2 Numeric Literals
|
|
|
|
.table
|
|
Form Example Description
|
|
---- ------- -----------
|
|
Decimal integer 42 Values -32768..32767 are Integer; larger are Long
|
|
Hex integer &HFF Hexadecimal literal
|
|
Long suffix 42&, &HFF& Force Long type
|
|
Floating-point 3.14, 1.5E10 Double by default
|
|
Single suffix 3.14! Force Single type
|
|
Double suffix 3.14# Force Double type
|
|
.endtable
|
|
|
|
.h2 Type Promotion
|
|
|
|
When mixing types in expressions, values are automatically promoted to a common type: Integer -> Long -> Single -> Double. Strings are not automatically converted to numbers (use VAL and STR$).
|
|
|
|
.link lang.func.conversion See also: Conversion Functions
|
|
|
|
.topic lang.operators
|
|
.title Operators
|
|
.toc 1 Operators
|
|
.index Operators
|
|
.index Precedence
|
|
.index AND
|
|
.index OR
|
|
.index NOT
|
|
.index XOR
|
|
.index EQV
|
|
.index IMP
|
|
.index MOD
|
|
|
|
.h1 Operators
|
|
|
|
Operators listed from highest precedence (evaluated first) to lowest precedence (evaluated last).
|
|
|
|
.table
|
|
Precedence Operator Description
|
|
---------- -------- -----------
|
|
1 (highest) ^ Exponentiation
|
|
2 - (unary) Negation
|
|
3 * / \ MOD Multiply, float div, integer div, modulus
|
|
4 + - Addition, subtraction
|
|
5 & String concatenation
|
|
6 = <> < > <= >= Comparison (returns Boolean)
|
|
7 NOT Logical/bitwise NOT
|
|
8 AND Logical/bitwise AND
|
|
9 XOR Logical/bitwise XOR
|
|
10 OR Logical/bitwise OR
|
|
11 EQV Logical/bitwise equivalence
|
|
12 (lowest) IMP Logical/bitwise implication
|
|
.endtable
|
|
|
|
.h2 String Concatenation
|
|
|
|
Use & to concatenate strings. The + operator also concatenates when both operands are strings.
|
|
|
|
.code
|
|
result$ = "Hello" & " " & "World"
|
|
result$ = firstName$ & " " & lastName$
|
|
.endcode
|
|
|
|
.topic lang.statements
|
|
.title Statements Overview
|
|
.toc 1 Statements
|
|
.index Statements
|
|
.index REM
|
|
.index Comments
|
|
|
|
.h1 Statements
|
|
|
|
Multiple statements can appear on one line separated by :. Lines can be continued with _ at the end. Comments start with ' or REM.
|
|
|
|
.link lang.declarations Declaration Statements (DIM, REDIM, CONST, TYPE)
|
|
.link lang.conditionals Conditional Statements (IF, SELECT CASE)
|
|
.link lang.loops Loop Statements (FOR, DO, WHILE)
|
|
.link lang.procedures Procedures (SUB, FUNCTION, DEF FN)
|
|
.link lang.flow Flow Control (EXIT, CALL, GOTO, GOSUB, ON)
|
|
.link lang.io Input/Output (PRINT, INPUT, DATA/READ)
|
|
.link lang.misc Miscellaneous Statements
|
|
|
|
.topic lang.declarations
|
|
.title Declaration Statements
|
|
.toc 2 Declarations
|
|
.index DIM
|
|
.index REDIM
|
|
.index CONST
|
|
.index TYPE
|
|
.index END TYPE
|
|
.index DECLARE
|
|
.index DECLARE LIBRARY
|
|
.index SHARED
|
|
.index STATIC
|
|
.index OPTION
|
|
.index OPTION BASE
|
|
.index OPTION COMPARE
|
|
.index OPTION EXPLICIT
|
|
.index DEFINT
|
|
.index DEFLNG
|
|
.index DEFSNG
|
|
.index DEFDBL
|
|
.index DEFSTR
|
|
.index LET
|
|
.index SWAP
|
|
.index ERASE
|
|
|
|
.h1 Declaration Statements
|
|
|
|
.h2 DIM
|
|
|
|
Declares variables and arrays with an explicit type.
|
|
|
|
.code
|
|
DIM variable AS type
|
|
DIM variable(upperBound) AS type
|
|
DIM variable(lower TO upper) AS type
|
|
DIM variable(dim1, dim2, ...) AS type
|
|
DIM variable AS UdtName
|
|
DIM variable AS STRING * n
|
|
DIM SHARED variable AS type
|
|
.endcode
|
|
|
|
Examples:
|
|
|
|
.code
|
|
Dim name As String
|
|
Dim count As Integer
|
|
Dim values(100) As Double
|
|
Dim matrix(1 To 10, 1 To 10) As Single
|
|
Dim Shared globalFlag As Boolean
|
|
Dim record As PersonType
|
|
Dim fixedStr As String * 20
|
|
.endcode
|
|
|
|
.note info
|
|
DIM SHARED makes a variable accessible from all procedures without passing it as a parameter.
|
|
.endnote
|
|
|
|
.h2 REDIM
|
|
|
|
Reallocates a dynamic array, optionally preserving existing data.
|
|
|
|
.code
|
|
REDIM array(newBounds) AS type
|
|
REDIM PRESERVE array(newBounds) AS type
|
|
.endcode
|
|
|
|
.code
|
|
ReDim items(newSize) As String
|
|
ReDim Preserve scores(1 To newCount) As Integer
|
|
.endcode
|
|
|
|
.h2 CONST
|
|
|
|
Declares a named constant. The value must be a literal (integer, float, string, or boolean).
|
|
|
|
.code
|
|
CONST name = value
|
|
.endcode
|
|
|
|
.code
|
|
Const MAX_SIZE = 100
|
|
Const PI = 3.14159265
|
|
Const APP_NAME = "DVX App"
|
|
Const DEBUG_MODE = True
|
|
.endcode
|
|
|
|
.h2 TYPE...END TYPE
|
|
|
|
Defines a user-defined type (record/structure).
|
|
|
|
.code
|
|
TYPE TypeName
|
|
fieldName AS type
|
|
...
|
|
END TYPE
|
|
.endcode
|
|
|
|
.code
|
|
Type PersonType
|
|
firstName As String
|
|
lastName As String
|
|
age As Integer
|
|
End Type
|
|
|
|
Dim p As PersonType
|
|
p.firstName = "Scott"
|
|
p.age = 30
|
|
.endcode
|
|
|
|
UDT fields can themselves be UDTs (nested types).
|
|
|
|
.h2 DECLARE
|
|
|
|
Forward-declares a SUB or FUNCTION. Required when a procedure is called before it is defined.
|
|
|
|
.code
|
|
DECLARE SUB name ([BYVAL] param AS type, ...)
|
|
DECLARE FUNCTION name ([BYVAL] param AS type, ...) AS returnType
|
|
.endcode
|
|
|
|
.h2 DECLARE LIBRARY
|
|
|
|
Declares external native functions from a dynamically loaded library. This allows BASIC programs to call functions exported by DXE libraries.
|
|
|
|
.code
|
|
DECLARE LIBRARY "libraryName"
|
|
DECLARE SUB name ([BYVAL] param AS type, ...)
|
|
DECLARE FUNCTION name ([BYVAL] param AS type, ...) AS returnType
|
|
END DECLARE
|
|
.endcode
|
|
|
|
.code
|
|
Declare Library "rs232"
|
|
Declare Function ComOpen(ByVal port As Integer) As Integer
|
|
Declare Sub ComClose(ByVal port As Integer)
|
|
Declare Sub ComSend(ByVal port As Integer, ByVal data$ As String)
|
|
End Declare
|
|
.endcode
|
|
|
|
.h2 STATIC
|
|
|
|
Declares a local variable that retains its value between calls.
|
|
|
|
.code
|
|
STATIC variable AS type
|
|
.endcode
|
|
|
|
.code
|
|
Sub Counter()
|
|
Static count As Integer
|
|
count = count + 1
|
|
Print count
|
|
End Sub
|
|
.endcode
|
|
|
|
.h2 OPTION
|
|
|
|
Sets compiler options. Must appear before any executable code.
|
|
|
|
.code
|
|
OPTION BASE 0 ' Arrays start at index 0 (default)
|
|
OPTION BASE 1 ' Arrays start at index 1
|
|
OPTION COMPARE BINARY ' Case-sensitive string comparisons (default)
|
|
OPTION COMPARE TEXT ' Case-insensitive string comparisons
|
|
OPTION EXPLICIT ' All variables must be declared with DIM
|
|
.endcode
|
|
|
|
.h2 DEFtype Statements
|
|
|
|
Set the default type for variables based on their first letter.
|
|
|
|
.code
|
|
DEFINT letterRange
|
|
DEFLNG letterRange
|
|
DEFSNG letterRange
|
|
DEFDBL letterRange
|
|
DEFSTR letterRange
|
|
.endcode
|
|
|
|
.code
|
|
DefInt I-N ' Variables starting with I through N default to Integer
|
|
DefStr S ' Variables starting with S default to String
|
|
.endcode
|
|
|
|
.h2 Assignment
|
|
|
|
Assigns a value to a variable, array element, or UDT field.
|
|
|
|
.code
|
|
variable = expression
|
|
array(index) = expression
|
|
udt.field = expression
|
|
LET variable = expression
|
|
.endcode
|
|
|
|
The LET keyword is optional and supported for compatibility.
|
|
|
|
.h2 SWAP
|
|
|
|
Exchanges the values of two variables.
|
|
|
|
.code
|
|
SWAP variable1, variable2
|
|
.endcode
|
|
|
|
.code
|
|
Swap a, b
|
|
.endcode
|
|
|
|
.h2 ERASE
|
|
|
|
Frees the memory of an array and resets it.
|
|
|
|
.code
|
|
ERASE arrayName
|
|
.endcode
|
|
|
|
.topic lang.conditionals
|
|
.title Conditional Statements
|
|
.toc 2 Conditionals
|
|
.index IF
|
|
.index THEN
|
|
.index ELSE
|
|
.index ELSEIF
|
|
.index END IF
|
|
.index SELECT CASE
|
|
.index CASE
|
|
.index CASE ELSE
|
|
.index END SELECT
|
|
|
|
.h1 Conditional Statements
|
|
|
|
.h2 IF...THEN...ELSE...END IF
|
|
|
|
Conditional execution. Supports single-line and multi-line forms.
|
|
|
|
.h3 Single-line form
|
|
|
|
.code
|
|
IF condition THEN statement
|
|
IF condition THEN statement ELSE statement
|
|
.endcode
|
|
|
|
.h3 Multi-line form
|
|
|
|
.code
|
|
IF condition THEN
|
|
statements
|
|
ELSEIF condition THEN
|
|
statements
|
|
ELSE
|
|
statements
|
|
END IF
|
|
.endcode
|
|
|
|
.code
|
|
If x > 10 Then
|
|
Print "Large"
|
|
ElseIf x > 5 Then
|
|
Print "Medium"
|
|
Else
|
|
Print "Small"
|
|
End If
|
|
|
|
If ready Then Print "Go!"
|
|
.endcode
|
|
|
|
.h2 SELECT CASE
|
|
|
|
Multi-way branch based on an expression value.
|
|
|
|
.code
|
|
SELECT CASE expression
|
|
CASE value
|
|
statements
|
|
CASE value1, value2
|
|
statements
|
|
CASE low TO high
|
|
statements
|
|
CASE IS operator value
|
|
statements
|
|
CASE ELSE
|
|
statements
|
|
END SELECT
|
|
.endcode
|
|
|
|
.code
|
|
Select Case grade
|
|
Case 90 To 100
|
|
Print "A"
|
|
Case 80 To 89
|
|
Print "B"
|
|
Case Is >= 70
|
|
Print "C"
|
|
Case 60, 65
|
|
Print "D (borderline)"
|
|
Case Else
|
|
Print "F"
|
|
End Select
|
|
.endcode
|
|
|
|
CASE items can be combined with commas. The IS keyword allows comparison operators: <, >, <=, >=, =, <>.
|
|
|
|
.topic lang.loops
|
|
.title Loop Statements
|
|
.toc 2 Loops
|
|
.index FOR
|
|
.index NEXT
|
|
.index STEP
|
|
.index DO
|
|
.index LOOP
|
|
.index WHILE
|
|
.index WEND
|
|
.index UNTIL
|
|
.index EXIT FOR
|
|
.index EXIT DO
|
|
|
|
.h1 Loop Statements
|
|
|
|
.h2 FOR...NEXT
|
|
|
|
Counted loop with an optional step value.
|
|
|
|
.code
|
|
FOR variable = start TO limit [STEP step]
|
|
statements
|
|
NEXT [variable]
|
|
.endcode
|
|
|
|
.code
|
|
For i = 1 To 10
|
|
Print i
|
|
Next i
|
|
|
|
For x = 10 To 0 Step -2
|
|
Print x
|
|
Next
|
|
.endcode
|
|
|
|
The variable name after NEXT is optional. Use EXIT FOR to break out early.
|
|
|
|
.h2 DO...LOOP
|
|
|
|
General-purpose loop with pre-test, post-test, or infinite forms.
|
|
|
|
.code
|
|
DO [WHILE condition | UNTIL condition]
|
|
statements
|
|
LOOP [WHILE condition | UNTIL condition]
|
|
.endcode
|
|
|
|
.code
|
|
' Pre-test
|
|
Do While count < 10
|
|
count = count + 1
|
|
Loop
|
|
|
|
' Post-test
|
|
Do
|
|
line$ = ReadLine()
|
|
Loop Until line$ = "quit"
|
|
|
|
' Infinite loop (exit with EXIT DO)
|
|
Do
|
|
DoEvents
|
|
If done Then Exit Do
|
|
Loop
|
|
.endcode
|
|
|
|
.h2 WHILE...WEND
|
|
|
|
Simple pre-test loop (legacy form; prefer DO...LOOP).
|
|
|
|
.code
|
|
WHILE condition
|
|
statements
|
|
WEND
|
|
.endcode
|
|
|
|
.code
|
|
While Not EOF(1)
|
|
Line Input #1, line$
|
|
Print line$
|
|
Wend
|
|
.endcode
|
|
|
|
.topic lang.procedures
|
|
.title Procedures
|
|
.toc 2 Procedures
|
|
.index SUB
|
|
.index END SUB
|
|
.index FUNCTION
|
|
.index END FUNCTION
|
|
.index DEF FN
|
|
.index BYVAL
|
|
.index BYREF
|
|
.index EXIT SUB
|
|
.index EXIT FUNCTION
|
|
|
|
.h1 Procedures
|
|
|
|
.h2 SUB...END SUB
|
|
|
|
Defines a subroutine (no return value).
|
|
|
|
.code
|
|
SUB name ([BYVAL] param AS type, ...)
|
|
statements
|
|
END SUB
|
|
.endcode
|
|
|
|
.code
|
|
Sub Greet(ByVal name As String)
|
|
Print "Hello, " & name
|
|
End Sub
|
|
.endcode
|
|
|
|
Parameters are passed ByRef by default. Use ByVal for value semantics. Use EXIT SUB to return early.
|
|
|
|
.h2 FUNCTION...END FUNCTION
|
|
|
|
Defines a function with a return value.
|
|
|
|
.code
|
|
FUNCTION name ([BYVAL] param AS type, ...) AS returnType
|
|
statements
|
|
name = returnValue
|
|
END FUNCTION
|
|
.endcode
|
|
|
|
.code
|
|
Function Square(ByVal n As Double) As Double
|
|
Square = n * n
|
|
End Function
|
|
.endcode
|
|
|
|
Assign to the function name to set the return value. Use EXIT FUNCTION to return early.
|
|
|
|
.h2 DEF FN
|
|
|
|
Defines a single-expression function.
|
|
|
|
.code
|
|
DEF FNname(params) = expression
|
|
.endcode
|
|
|
|
.code
|
|
Def FnSquare(x) = x * x
|
|
Print FnSquare(5) ' prints 25
|
|
.endcode
|
|
|
|
.topic lang.flow
|
|
.title Flow Control
|
|
.toc 2 Flow Control
|
|
.index EXIT
|
|
.index CALL
|
|
.index GOTO
|
|
.index GOSUB
|
|
.index RETURN
|
|
.index ON GOTO
|
|
.index ON GOSUB
|
|
|
|
.h1 Flow Control
|
|
|
|
.h2 EXIT
|
|
|
|
Exits the current block early.
|
|
|
|
.code
|
|
EXIT FOR
|
|
EXIT DO
|
|
EXIT SUB
|
|
EXIT FUNCTION
|
|
.endcode
|
|
|
|
.h2 CALL
|
|
|
|
Explicitly calls a subroutine or function. The return value (if any) is discarded.
|
|
|
|
.code
|
|
CALL name
|
|
CALL name(args)
|
|
.endcode
|
|
|
|
Normally you can omit CALL and just use the name directly.
|
|
|
|
.h2 GOTO / GOSUB / RETURN
|
|
|
|
.code
|
|
GOTO label
|
|
GOSUB label
|
|
RETURN
|
|
.endcode
|
|
|
|
GOSUB pushes the return address, executes code at the label, and RETURN jumps back. At module level, RETURN returns from a GOSUB. Inside a SUB/FUNCTION, RETURN returns from the procedure.
|
|
|
|
.code
|
|
GoSub Initialize
|
|
Print "Done"
|
|
End
|
|
|
|
Initialize:
|
|
count = 0
|
|
name$ = ""
|
|
Return
|
|
.endcode
|
|
|
|
.h2 ON...GOTO / ON...GOSUB
|
|
|
|
Computed branch based on an integer expression.
|
|
|
|
.code
|
|
ON expression GOTO label1, label2, ...
|
|
ON expression GOSUB label1, label2, ...
|
|
.endcode
|
|
|
|
If the expression evaluates to 1, control goes to the first label; 2, the second; and so on. If out of range, execution falls through.
|
|
|
|
.topic lang.io
|
|
.title Input/Output Statements
|
|
.toc 2 Input/Output
|
|
.index PRINT
|
|
.index INPUT
|
|
.index DATA
|
|
.index READ
|
|
.index RESTORE
|
|
.index SPC
|
|
.index TAB
|
|
.index PRINT USING
|
|
|
|
.h1 Input/Output Statements
|
|
|
|
.h2 PRINT
|
|
|
|
Outputs text to the console or to a file channel.
|
|
|
|
.code
|
|
PRINT [expression] [{; | ,} expression] ...
|
|
PRINT #channel, expression
|
|
PRINT USING format$; expression [; expression] ...
|
|
.endcode
|
|
|
|
.list
|
|
.item ; between items -- no separator (items are concatenated)
|
|
.item , between items -- advance to the next 14-column tab zone
|
|
.item Trailing ; or , suppresses the newline
|
|
.item ? is an alias for PRINT
|
|
.endlist
|
|
|
|
Special functions inside PRINT:
|
|
|
|
.list
|
|
.item SPC(n) -- print n spaces
|
|
.item TAB(n) -- advance to column n
|
|
.endlist
|
|
|
|
.code
|
|
Print "Name:"; Tab(20); name$
|
|
Print Using "###.##"; total
|
|
Print #1, "Written to file"
|
|
.endcode
|
|
|
|
.h2 INPUT
|
|
|
|
Reads a line of text from the user or from a file channel.
|
|
|
|
.code
|
|
INPUT variable
|
|
INPUT "prompt"; variable
|
|
INPUT #channel, variable
|
|
.endcode
|
|
|
|
.code
|
|
Input "Enter your name: "; name$
|
|
Input #1, line$
|
|
.endcode
|
|
|
|
.h2 DATA / READ / RESTORE
|
|
|
|
Inline data pool for constants.
|
|
|
|
.code
|
|
DATA value1, value2, "string", ...
|
|
READ variable1, variable2, ...
|
|
RESTORE
|
|
.endcode
|
|
|
|
DATA statements define a pool of values. READ reads the next value from the pool into a variable. RESTORE resets the read pointer to the beginning.
|
|
|
|
.code
|
|
Data 10, 20, 30, "Hello"
|
|
Read a, b, c, msg$
|
|
Print a; b; c; msg$
|
|
Restore
|
|
.endcode
|
|
|
|
.topic lang.misc
|
|
.title Miscellaneous Statements
|
|
.toc 2 Miscellaneous Statements
|
|
.index ON ERROR
|
|
.index RESUME
|
|
.index RESUME NEXT
|
|
.index ERROR
|
|
.index ERR
|
|
.index SHELL
|
|
.index SLEEP
|
|
.index RANDOMIZE
|
|
.index END
|
|
.index RANDOMIZE TIMER
|
|
|
|
.h1 Miscellaneous Statements
|
|
|
|
.h2 Error Handling
|
|
|
|
.code
|
|
ON ERROR GOTO label ' Enable error handler
|
|
ON ERROR GOTO 0 ' Disable error handler
|
|
RESUME ' Retry the statement that caused the error
|
|
RESUME NEXT ' Continue at the next statement after the error
|
|
ERROR n ' Raise a runtime error with error number n
|
|
.endcode
|
|
|
|
The ERR keyword returns the current error number in expressions.
|
|
|
|
.code
|
|
On Error GoTo ErrorHandler
|
|
Open "missing.txt" For Input As #1
|
|
Exit Sub
|
|
|
|
ErrorHandler:
|
|
Print "Error number:"; Err
|
|
Resume Next
|
|
.endcode
|
|
|
|
.h2 SHELL
|
|
|
|
Executes an operating system command.
|
|
|
|
.code
|
|
SHELL "command"
|
|
.endcode
|
|
|
|
When used as a function, returns the exit code of the command.
|
|
|
|
.code
|
|
Shell "DIR /B"
|
|
exitCode = Shell("COPY A.TXT B.TXT")
|
|
.endcode
|
|
|
|
.h2 SLEEP
|
|
|
|
Pauses execution for a specified number of seconds.
|
|
|
|
.code
|
|
SLEEP seconds
|
|
.endcode
|
|
|
|
.h2 RANDOMIZE
|
|
|
|
Seeds the random number generator.
|
|
|
|
.code
|
|
RANDOMIZE seed
|
|
RANDOMIZE TIMER ' Seed from system clock
|
|
.endcode
|
|
|
|
.h2 END
|
|
|
|
Terminates program execution immediately.
|
|
|
|
.code
|
|
END
|
|
.endcode
|
|
|
|
.topic lang.fileio
|
|
.title File I/O
|
|
.toc 1 File I/O
|
|
.index OPEN
|
|
.index CLOSE
|
|
.index PRINT #
|
|
.index INPUT #
|
|
.index LINE INPUT
|
|
.index WRITE #
|
|
.index GET
|
|
.index PUT
|
|
.index SEEK
|
|
.index FOR INPUT
|
|
.index FOR OUTPUT
|
|
.index FOR APPEND
|
|
.index FOR RANDOM
|
|
.index FOR BINARY
|
|
|
|
.h1 File I/O
|
|
|
|
.h2 OPEN
|
|
|
|
Opens a file for reading, writing, or appending.
|
|
|
|
.code
|
|
OPEN filename$ FOR INPUT AS #channel
|
|
OPEN filename$ FOR OUTPUT AS #channel
|
|
OPEN filename$ FOR APPEND AS #channel
|
|
OPEN filename$ FOR RANDOM AS #channel [LEN = recordSize]
|
|
OPEN filename$ FOR BINARY AS #channel
|
|
.endcode
|
|
|
|
.table
|
|
Mode Description
|
|
---- -----------
|
|
INPUT Open for sequential reading. File must exist.
|
|
OUTPUT Open for sequential writing. Creates or truncates.
|
|
APPEND Open for sequential writing at end of file.
|
|
RANDOM Open for random-access record I/O.
|
|
BINARY Open for raw binary I/O.
|
|
.endtable
|
|
|
|
.h2 CLOSE
|
|
|
|
Closes an open file channel.
|
|
|
|
.code
|
|
CLOSE #channel
|
|
.endcode
|
|
|
|
.h2 PRINT #
|
|
|
|
Writes text to a file.
|
|
|
|
.code
|
|
PRINT #channel, expression
|
|
.endcode
|
|
|
|
.h2 INPUT #
|
|
|
|
Reads comma-delimited data from a file.
|
|
|
|
.code
|
|
INPUT #channel, variable
|
|
.endcode
|
|
|
|
.h2 LINE INPUT #
|
|
|
|
Reads an entire line from a file into a string variable.
|
|
|
|
.code
|
|
LINE INPUT #channel, variable$
|
|
.endcode
|
|
|
|
.h2 WRITE #
|
|
|
|
Writes comma-delimited data to a file. Strings are enclosed in quotes, numbers are undecorated. Each statement writes a newline at the end.
|
|
|
|
.code
|
|
WRITE #channel, expr1, expr2, ...
|
|
.endcode
|
|
|
|
.code
|
|
Write #1, "Scott", 42, 3.14
|
|
' Output: "Scott",42,3.14
|
|
.endcode
|
|
|
|
.h2 GET / PUT
|
|
|
|
Read and write records in RANDOM or BINARY mode files.
|
|
|
|
.code
|
|
GET #channel, [recordNum], variable
|
|
PUT #channel, [recordNum], variable
|
|
.endcode
|
|
|
|
.h2 SEEK
|
|
|
|
Sets the file position. As a function, returns the current position.
|
|
|
|
.code
|
|
SEEK #channel, position ' Statement: set position
|
|
pos = SEEK(channel) ' Function: get current position
|
|
.endcode
|
|
|
|
.topic lang.func.string
|
|
.title String Functions
|
|
.toc 1 Built-in Functions
|
|
.toc 2 String Functions
|
|
.index ASC
|
|
.index CHR$
|
|
.index FORMAT$
|
|
.index HEX$
|
|
.index INSTR
|
|
.index LCASE$
|
|
.index LEFT$
|
|
.index LEN
|
|
.index LTRIM$
|
|
.index MID$
|
|
.index RIGHT$
|
|
.index RTRIM$
|
|
.index SPACE$
|
|
.index STR$
|
|
.index STRING$
|
|
.index TRIM$
|
|
.index UCASE$
|
|
.index VAL
|
|
|
|
.h1 String Functions
|
|
|
|
.table
|
|
Function Returns Description
|
|
-------- ------- -----------
|
|
ASC(s$) Integer ASCII code of first character of s$
|
|
CHR$(n) String Character with ASCII code n
|
|
FORMAT$(value, fmt$) String Formats a numeric value using format string
|
|
HEX$(n) String Hexadecimal representation of n
|
|
INSTR(s$, find$) Integer Position of find$ in s$ (1-based), 0 if not found
|
|
INSTR(start, s$, find$) Integer Search starting at position start
|
|
LCASE$(s$) String Converts s$ to lowercase
|
|
LEFT$(s$, n) String Leftmost n characters of s$
|
|
LEN(s$) Integer Length of s$
|
|
LTRIM$(s$) String Removes leading spaces from s$
|
|
MID$(s$, start [, length]) String Substring from position start (1-based)
|
|
RIGHT$(s$, n) String Rightmost n characters of s$
|
|
RTRIM$(s$) String Removes trailing spaces from s$
|
|
SPACE$(n) String String of n spaces
|
|
STR$(n) String Converts number n to string
|
|
STRING$(n, char) String String of n copies of char
|
|
TRIM$(s$) String Removes leading and trailing spaces from s$
|
|
UCASE$(s$) String Converts s$ to uppercase
|
|
VAL(s$) Double Converts string s$ to a numeric value
|
|
.endtable
|
|
|
|
.h2 MID$ Assignment
|
|
|
|
MID$ can also be used on the left side of an assignment to replace a portion of a string:
|
|
|
|
.code
|
|
Mid$(s$, 3, 2) = "XY" ' Replace 2 characters starting at position 3
|
|
.endcode
|
|
|
|
.topic lang.func.math
|
|
.title Math Functions
|
|
.toc 2 Math Functions
|
|
.index ABS
|
|
.index ATN
|
|
.index COS
|
|
.index EXP
|
|
.index FIX
|
|
.index INT
|
|
.index LOG
|
|
.index RND
|
|
.index SGN
|
|
.index SIN
|
|
.index SQR
|
|
.index TAN
|
|
.index TIMER
|
|
|
|
.h1 Math Functions
|
|
|
|
.table
|
|
Function Returns Description
|
|
-------- ------- -----------
|
|
ABS(n) Double Absolute value of n
|
|
ATN(n) Double Arctangent of n (in radians)
|
|
COS(n) Double Cosine of n (radians)
|
|
EXP(n) Double e raised to the power n
|
|
FIX(n) Integer Truncates n toward zero (removes fractional part)
|
|
INT(n) Integer Largest integer less than or equal to n (floor)
|
|
LOG(n) Double Natural logarithm (base e) of n
|
|
RND[(n)] Double Random number between 0 (inclusive) and 1 (exclusive)
|
|
SGN(n) Integer Sign of n: -1, 0, or 1
|
|
SIN(n) Double Sine of n (radians)
|
|
SQR(n) Double Square root of n
|
|
TAN(n) Double Tangent of n (radians)
|
|
TIMER Double Number of seconds since midnight
|
|
.endtable
|
|
|
|
.note info
|
|
RND with a negative argument seeds and returns. RND(0) returns the previous value. Use RANDOMIZE to seed the generator.
|
|
.endnote
|
|
|
|
.topic lang.func.conversion
|
|
.title Conversion Functions
|
|
.toc 2 Conversion Functions
|
|
.index CDBL
|
|
.index CINT
|
|
.index CLNG
|
|
.index CSNG
|
|
.index CSTR
|
|
|
|
.h1 Conversion Functions
|
|
|
|
.table
|
|
Function Returns Description
|
|
-------- ------- -----------
|
|
CDBL(n) Double Converts n to Double
|
|
CINT(n) Integer Converts n to Integer (with banker's rounding)
|
|
CLNG(n) Long Converts n to Long
|
|
CSNG(n) Single Converts n to Single
|
|
CSTR(n) String Converts n to its String representation
|
|
.endtable
|
|
|
|
.topic lang.func.fileio
|
|
.title File I/O Functions
|
|
.toc 2 File I/O Functions
|
|
.index EOF
|
|
.index FREEFILE
|
|
.index INPUT$
|
|
.index LOC
|
|
.index LOF
|
|
.index LBOUND
|
|
.index UBOUND
|
|
|
|
.h1 File I/O Functions
|
|
|
|
.table
|
|
Function Returns Description
|
|
-------- ------- -----------
|
|
EOF(channel) Boolean True if file pointer is at end of file
|
|
FREEFILE Integer Next available file channel number
|
|
INPUT$(n, #channel) String Reads n characters from the file
|
|
LOC(channel) Long Current read/write position in the file
|
|
LOF(channel) Long Length of the file in bytes
|
|
SEEK(channel) Long Current file position (function form)
|
|
LBOUND(array [, dim]) Integer Lower bound of an array dimension
|
|
UBOUND(array [, dim]) Integer Upper bound of an array dimension
|
|
.endtable
|
|
|
|
.topic lang.func.misc
|
|
.title Miscellaneous Functions
|
|
.toc 2 Miscellaneous Functions
|
|
.index DATE$
|
|
.index TIME$
|
|
.index ENVIRON$
|
|
|
|
.h1 Miscellaneous Functions
|
|
|
|
.table
|
|
Function Returns Description
|
|
-------- ------- -----------
|
|
DATE$ String Current date as "MM-DD-YYYY"
|
|
TIME$ String Current time as "HH:MM:SS"
|
|
ENVIRON$(name$) String Value of environment variable name$
|
|
ERR Integer Current runtime error number (0 if no error)
|
|
.endtable
|
|
|
|
.topic lang.forms
|
|
.title Form and Control Statements
|
|
.toc 1 Form and Control Statements
|
|
.index LOAD
|
|
.index UNLOAD
|
|
.index Show
|
|
.index Hide
|
|
.index Me
|
|
.index DoEvents
|
|
.index DOEVENTS
|
|
.index MsgBox
|
|
.index MSGBOX
|
|
.index InputBox$
|
|
.index INPUTBOX$
|
|
.index vbModal
|
|
.index Control Arrays
|
|
.index Event Handlers
|
|
|
|
.h1 Form and Control Statements
|
|
|
|
DVX BASIC supports Visual Basic-style forms and controls for building graphical user interfaces. Forms are defined in .frm files and loaded at runtime.
|
|
|
|
.h2 Loading and Unloading Forms
|
|
|
|
.code
|
|
LOAD FormName
|
|
UNLOAD FormName
|
|
.endcode
|
|
|
|
LOAD creates the form and its controls in memory. UNLOAD destroys the form and frees its resources.
|
|
|
|
.h2 Showing and Hiding Forms
|
|
|
|
.code
|
|
FormName.Show [modal]
|
|
FormName.Hide
|
|
Me.Show [modal]
|
|
Me.Hide
|
|
.endcode
|
|
|
|
Pass vbModal (1) to Show for a modal dialog.
|
|
|
|
.code
|
|
Form2.Show vbModal
|
|
Me.Hide
|
|
.endcode
|
|
|
|
.h2 Property Access
|
|
|
|
Read and write control properties using dot notation:
|
|
|
|
.code
|
|
ControlName.Property = value
|
|
value = ControlName.Property
|
|
.endcode
|
|
|
|
.code
|
|
Text1.Text = "Hello"
|
|
label1.Caption = "Name: " & name$
|
|
x = Text1.Left
|
|
.endcode
|
|
|
|
.h2 Method Calls
|
|
|
|
.code
|
|
ControlName.Method [args]
|
|
.endcode
|
|
|
|
.code
|
|
List1.AddItem "New entry"
|
|
List1.Clear
|
|
.endcode
|
|
|
|
.h2 Me Keyword
|
|
|
|
Me refers to the current form. Use it to access the form's own properties, controls, and methods from within event handlers.
|
|
|
|
.code
|
|
Me.Caption = "Updated Title"
|
|
Me.Text1.Text = ""
|
|
Me.Hide
|
|
.endcode
|
|
|
|
.h2 Control Arrays
|
|
|
|
Multiple controls can share a name with unique indices. Access individual controls with parenthesized indices:
|
|
|
|
.code
|
|
Option1(0).Value = True
|
|
Label1(idx).Caption = "Item " & Str$(idx)
|
|
Me.Label1(i).Visible = True
|
|
.endcode
|
|
|
|
.h2 DoEvents
|
|
|
|
Yields control to the DVX event loop, allowing the GUI to process pending events. Call this in long-running loops to keep the UI responsive.
|
|
|
|
.code
|
|
DOEVENTS
|
|
.endcode
|
|
|
|
.code
|
|
For i = 1 To 10000
|
|
' process data
|
|
If i Mod 100 = 0 Then DoEvents
|
|
Next
|
|
.endcode
|
|
|
|
.h2 MsgBox
|
|
|
|
Displays a message box dialog. Can be used as a statement (discards result) or as a function (returns the button clicked).
|
|
|
|
.code
|
|
MSGBOX message$ [, flags]
|
|
result = MSGBOX(message$ [, flags])
|
|
.endcode
|
|
|
|
.code
|
|
MsgBox "Operation complete"
|
|
answer = MsgBox("Continue?", vbYesNo + vbQuestion)
|
|
If answer = vbYes Then
|
|
' proceed
|
|
End If
|
|
.endcode
|
|
|
|
.h2 InputBox$
|
|
|
|
Displays an input dialog and returns the user's text entry.
|
|
|
|
.code
|
|
result$ = INPUTBOX$(prompt$ [, title$ [, default$]])
|
|
.endcode
|
|
|
|
.code
|
|
name$ = InputBox$("Enter your name:", "Name Entry", "")
|
|
.endcode
|
|
|
|
.h2 Event Handler Convention
|
|
|
|
Event handlers are named ControlName_EventName and defined as SUBs:
|
|
|
|
.code
|
|
Sub Command1_Click()
|
|
MsgBox "Button clicked!"
|
|
End Sub
|
|
|
|
Sub Form_Load()
|
|
Me.Caption = "My App"
|
|
End Sub
|
|
|
|
Sub Text1_Change()
|
|
Label1.Caption = "You typed: " & Text1.Text
|
|
End Sub
|
|
.endcode
|
|
|
|
.h3 Common Events
|
|
|
|
.table
|
|
Event Description
|
|
----- -----------
|
|
Click Control was clicked
|
|
DblClick Control was double-clicked
|
|
Change Control value/text changed
|
|
KeyPress Key was pressed (receives key code)
|
|
KeyDown Key went down (receives key code and shift state)
|
|
KeyUp Key was released
|
|
MouseDown Mouse button pressed
|
|
MouseUp Mouse button released
|
|
MouseMove Mouse moved over control
|
|
GotFocus Control received input focus
|
|
LostFocus Control lost input focus
|
|
Form_Load Form is being loaded
|
|
Form_Unload Form is being unloaded
|
|
Form_Resize Form was resized
|
|
Timer Timer interval elapsed
|
|
.endtable
|
|
|
|
.topic lang.sql
|
|
.title SQL Functions
|
|
.toc 1 SQL Functions
|
|
.index SQLOpen
|
|
.index SQLClose
|
|
.index SQLExec
|
|
.index SQLAffected
|
|
.index SQLQuery
|
|
.index SQLNext
|
|
.index SQLEof
|
|
.index SQLField$
|
|
.index SQLFieldInt
|
|
.index SQLFieldDbl
|
|
.index SQLFieldCount
|
|
.index SQLFreeResult
|
|
.index SQLError$
|
|
.index SQLite
|
|
|
|
.h1 SQL Functions
|
|
|
|
DVX BASIC includes built-in SQLite database support through a set of SQL functions. All functions use database handles and result set handles (integers) returned by SQLOpen and SQLQuery.
|
|
|
|
.h2 Opening and Closing Databases
|
|
|
|
.h3 SQLOpen
|
|
|
|
Opens a SQLite database file and returns a database handle.
|
|
|
|
.code
|
|
db = SQLOPEN(path$)
|
|
.endcode
|
|
|
|
.code
|
|
db = SQLOpen(App.Data & "\mydata.db")
|
|
.endcode
|
|
|
|
.h3 SQLClose
|
|
|
|
Closes an open database.
|
|
|
|
.code
|
|
SQLCLOSE db
|
|
.endcode
|
|
|
|
.h2 Executing SQL
|
|
|
|
.h3 SQLExec
|
|
|
|
Executes a SQL statement that does not return data (INSERT, UPDATE, DELETE, CREATE TABLE, etc.). Can be used as a statement or as a function returning a Boolean success flag.
|
|
|
|
.code
|
|
SQLEXEC db, sql$
|
|
ok = SQLEXEC(db, sql$)
|
|
.endcode
|
|
|
|
.code
|
|
SQLExec db, "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT)"
|
|
SQLExec db, "INSERT INTO users (name) VALUES ('Scott')"
|
|
ok = SQLExec(db, "DELETE FROM users WHERE id = 5")
|
|
.endcode
|
|
|
|
.h3 SQLAffected
|
|
|
|
Returns the number of rows affected by the last INSERT, UPDATE, or DELETE.
|
|
|
|
.code
|
|
count = SQLAFFECTED(db)
|
|
.endcode
|
|
|
|
.h2 Querying Data
|
|
|
|
.h3 SQLQuery
|
|
|
|
Executes a SELECT query and returns a result set handle.
|
|
|
|
.code
|
|
rs = SQLQUERY(db, sql$)
|
|
.endcode
|
|
|
|
.code
|
|
rs = SQLQuery(db, "SELECT id, name FROM users ORDER BY name")
|
|
.endcode
|
|
|
|
.h3 SQLNext
|
|
|
|
Advances to the next row in the result set. Can be used as a statement or as a function returning True if a row is available.
|
|
|
|
.code
|
|
SQLNEXT rs
|
|
hasRow = SQLNEXT(rs)
|
|
.endcode
|
|
|
|
.h3 SQLEof
|
|
|
|
Returns True if there are no more rows in the result set.
|
|
|
|
.code
|
|
done = SQLEOF(rs)
|
|
.endcode
|
|
|
|
.h2 Reading Fields
|
|
|
|
.h3 SQLField$
|
|
|
|
Returns a field value as a string. The field can be specified by column index (0-based) or by column name.
|
|
|
|
.code
|
|
value$ = SQLFIELD$(rs, columnIndex)
|
|
value$ = SQLFIELD$(rs, "columnName")
|
|
.endcode
|
|
|
|
.code
|
|
name$ = SQLField$(rs, "name")
|
|
first$ = SQLField$(rs, 0)
|
|
.endcode
|
|
|
|
.h3 SQLFieldInt
|
|
|
|
Returns a field value as an integer.
|
|
|
|
.code
|
|
value = SQLFIELDINT(rs, columnIndex)
|
|
.endcode
|
|
|
|
.h3 SQLFieldDbl
|
|
|
|
Returns a field value as a double.
|
|
|
|
.code
|
|
value# = SQLFIELDDBL(rs, columnIndex)
|
|
.endcode
|
|
|
|
.h3 SQLFieldCount
|
|
|
|
Returns the number of columns in the result set.
|
|
|
|
.code
|
|
count = SQLFIELDCOUNT(rs)
|
|
.endcode
|
|
|
|
.h2 Result Set Cleanup
|
|
|
|
.h3 SQLFreeResult
|
|
|
|
Frees a result set. Always call this when done iterating a query.
|
|
|
|
.code
|
|
SQLFREERESULT rs
|
|
.endcode
|
|
|
|
.h2 Error Information
|
|
|
|
.h3 SQLError$
|
|
|
|
Returns the last error message for the database.
|
|
|
|
.code
|
|
msg$ = SQLERROR$(db)
|
|
.endcode
|
|
|
|
.h2 Complete SQL Example
|
|
|
|
.code
|
|
Dim db As Long
|
|
Dim rs As Long
|
|
|
|
db = SQLOpen(App.Data & "\contacts.db")
|
|
SQLExec db, "CREATE TABLE IF NOT EXISTS contacts (name TEXT, phone TEXT)"
|
|
SQLExec db, "INSERT INTO contacts VALUES ('Alice', '555-1234')"
|
|
|
|
rs = SQLQuery(db, "SELECT name, phone FROM contacts")
|
|
Do While Not SQLEof(rs)
|
|
SQLNext rs
|
|
Print SQLField$(rs, "name"); Tab(20); SQLField$(rs, "phone")
|
|
Loop
|
|
SQLFreeResult rs
|
|
SQLClose db
|
|
.endcode
|
|
|
|
.topic lang.app
|
|
.title App Object
|
|
.toc 1 App Object
|
|
.index App
|
|
.index App.Path
|
|
.index App.Config
|
|
.index App.Data
|
|
|
|
.h1 App Object
|
|
|
|
The App object provides read-only properties for the application's directory paths.
|
|
|
|
.table
|
|
Property Returns Description
|
|
-------- ------- -----------
|
|
App.Path String Directory containing the application's executable
|
|
App.Config String Directory for application configuration files
|
|
App.Data String Directory for application data files (databases, etc.)
|
|
.endtable
|
|
|
|
.code
|
|
configFile$ = App.Config & "\settings.ini"
|
|
dbPath$ = App.Data & "\myapp.db"
|
|
Print "Running from: " & App.Path
|
|
.endcode
|
|
|
|
.topic lang.ini
|
|
.title INI Functions
|
|
.toc 1 INI Functions
|
|
.index IniRead
|
|
.index IniWrite
|
|
.index INI
|
|
|
|
.h1 INI Functions
|
|
|
|
DVX BASIC provides built-in functions for reading and writing standard INI configuration files.
|
|
|
|
.h2 IniRead
|
|
|
|
Reads a value from an INI file. Returns the default value if the key is not found.
|
|
|
|
.code
|
|
value$ = INIREAD(file$, section$, key$, default$)
|
|
.endcode
|
|
|
|
.code
|
|
name$ = IniRead(App.Config & "\app.ini", "User", "Name", "Unknown")
|
|
fontSize = Val(IniRead(App.Config & "\app.ini", "Display", "FontSize", "12"))
|
|
.endcode
|
|
|
|
.h2 IniWrite
|
|
|
|
Writes a value to an INI file. Creates the file, section, or key if they do not exist.
|
|
|
|
.code
|
|
INIWRITE file$, section$, key$, value$
|
|
.endcode
|
|
|
|
.code
|
|
IniWrite App.Config & "\app.ini", "User", "Name", "Scott"
|
|
IniWrite App.Config & "\app.ini", "Display", "FontSize", Str$(fontSize)
|
|
.endcode
|
|
|
|
.topic lang.constants
|
|
.title Predefined Constants
|
|
.toc 1 Predefined Constants
|
|
.index vbOKOnly
|
|
.index vbOKCancel
|
|
.index vbYesNo
|
|
.index vbYesNoCancel
|
|
.index vbRetryCancel
|
|
.index vbInformation
|
|
.index vbExclamation
|
|
.index vbCritical
|
|
.index vbQuestion
|
|
.index vbOK
|
|
.index vbCancel
|
|
.index vbYes
|
|
.index vbNo
|
|
.index vbRetry
|
|
.index True
|
|
.index False
|
|
.index Predefined Constants
|
|
|
|
.h1 Predefined Constants
|
|
|
|
The following constants are predefined by the compiler and available in all programs.
|
|
|
|
.h2 MsgBox Button Style Flags
|
|
|
|
.table
|
|
Constant Value Description
|
|
-------- ----- -----------
|
|
vbOKOnly 0 OK button only (default)
|
|
vbOKCancel 1 OK and Cancel buttons
|
|
vbYesNo 2 Yes and No buttons
|
|
vbYesNoCancel 3 Yes, No, and Cancel buttons
|
|
vbRetryCancel 4 Retry and Cancel buttons
|
|
.endtable
|
|
|
|
.h2 MsgBox Icon Flags
|
|
|
|
Add an icon flag to the button style to display an icon in the message box.
|
|
|
|
.table
|
|
Constant Value Description
|
|
-------- ----- -----------
|
|
vbInformation &H10 Information icon
|
|
vbExclamation &H20 Warning icon
|
|
vbCritical &H30 Error/critical icon
|
|
vbQuestion &H40 Question mark icon
|
|
.endtable
|
|
|
|
.h2 MsgBox Return Values
|
|
|
|
.table
|
|
Constant Value Description
|
|
-------- ----- -----------
|
|
vbOK 1 User clicked OK
|
|
vbCancel 2 User clicked Cancel
|
|
vbYes 3 User clicked Yes
|
|
vbNo 4 User clicked No
|
|
vbRetry 5 User clicked Retry
|
|
.endtable
|
|
|
|
.h2 Show Mode Flags
|
|
|
|
.table
|
|
Constant Value Description
|
|
-------- ----- -----------
|
|
vbModal 1 Show form as modal dialog
|
|
.endtable
|
|
|
|
.h2 Boolean Constants
|
|
|
|
.table
|
|
Constant Value Description
|
|
-------- ----- -----------
|
|
True -1 Boolean true
|
|
False 0 Boolean false
|
|
.endtable
|