Dec 132017
 
Comparison of Quick Basic & Power Basic 3.X.

Full Description of File


Informational text file describing the
100 ways PowerBASIC 3.0 beats QuickBasic
and a feature by feature comparison of
PB 3.0, QB 4.5, PDS 7.1 and VBDOS


File POWERTXT.ZIP from The Programmer’s Corner in
Category BASIC Language
Comparison of Quick Basic & Power Basic 3.X.
File Name File Size Zip Size Zip Type
100WAYS.DOC 18292 6954 deflated
COMPARE.DOC 16603 6299 deflated
FILE_ID.DIZ 160 137 deflated
TPCREAD.ME 199 165 deflated

Download File POWERTXT.ZIP Here

Contents of the 100WAYS.DOC file




100 ways PowerBASIC 3.0 beats QuickBasic
========================================

1- PB3 directly creates TSR (terminate/stay-resident) programs which can
"pop-down" to a memory image of 4K! Memory resident programs can be
activated by practically any stimulus: a hot key, timer, inactivity,
a hardware or software interrupt, even a message from a foreground
program. In fact, it's possible for multiple TSRs to activate each
other repeatedly, with two-way communication throughout. No other
language offers this capability as an integral part of the compiler.

2- PB3 uses all real mode memory for dynamic strings. It's the first
and only Basic with a no-limit, handle-based string memory manager;
QB is limited to substantially less than 64k, and PDS has "inside"
segmentation limits (<64k per module, per sub-program, etc.)

3- The PB3 String Memory Manager is a resource available to any user
code. Both Basic and Assembler code can allocate, release, and alter
memory blocks as required by the programmer. While other compilers
may allow you to calcluate string location or assignment, none allow
the full memory management functionality of PowerBASIC.

4- PB3 compiles to true machine code in the integrated environment; the
identical code as an .EXE file. You never need to deal with a slow,
p-code interpreter as in QB and PDS. That means faster development,
and the elimination of subtle differences between interpreted and
compiled results.

5- PB3 offers unsigned integer variable types: BYTE, WORD, DOUBLE WORD.
(byte: 0-255 word: 0-65,535 dword: 0-4,294,967,295). Unsigned
integers are not available in other Basic compilers.

6- Optionally, PB3 can require that all variables be declared before use;
this option greatly enhances the probability of catching "typos"
automatically during compilation.

7- Dual Monitor Support is offered in both the PowerBASIC Integrated
Environment and the PBD Standalone debugger. This allows the
programmer to simultaneously view a full screen of source code and
debug information alongside a second full screen generated by the
target program. Annoying screen flashes and pauses are eliminated.

8- PowerBASIC is DesqView aware.

9- As an enhancement to user-defined TYPES, PowerBASIC is the first Basic
compiler to offer user-defined UNIONS as well.

10- PB3 offers 64-bit signed integer variables types. Quad-word integers
are not available in other Basic compilers.

11= With PowerBASIC, there is no need to maintain numerous sets of
libraries. Other compilers require one set of run time libraries for
near strings, another for far strings, and still another for each of
the floating point options. Then you need Quick Libraries for work
in the IDE, but Link Libraries to create an .EXE. With PowerBASIC,
there's no more confusion: All run time libraries are built into
the compiler, and PB3 selects them automatically! Furthermore, the
built-in PowerBASIC linker recognizes the same object modules, units,
and libraries, whether you're running in the IDE or creating an .EXE.

12- PB3 offers a USING$ function, which may be referenced in any string
expression. It duplicates the numeric and text formatting capability
of PRINT USING, but allows the result to be saved or modified, rather
than require immediate printing.

13- PB3 offers extended precision (80-bit) floating point variable types.

14- The PRINT USING and USING$ functions in PB3 may be dynamically altered
to format numeric values with leading zeros, or other special
characters. Further, currency characters ("$,.") may be easily
adapted to non-USA standards when needed.

15- PB3 offers conditional compilation directives ($IF/$ELSE/$ENDIF) to
allow easy version control, as well as large comment blocks in your
source code.

16- PB3 supports HUGE arrays (total data size > 64k) on a selective basis.
Unlike other Basic compilers, the extra overhead of huge array
calculation is only applied to those arrays which require it.

17- PB3 supports fixed-point BCD variable type with variable precision
from 0-18 digits, not a forced 4 digits which introduces additional
round-off errors.

18- PB3 supports floating point BCD variable type.

19- PB3 offers built-in array manipulation functions: ARRAY SORT,
ARRAY SCAN, ARRAY INSERT, and ARRAY DELETE.

20- PB3 offers a full-functioned, built-in assembler. Critical sections
of a program can easily be hand-optimized to provide the utmost
performance, as Assembler and Basic can be intermixed line-by-line.

21- PB3 won't run out of memory compiling the largest programs. It
automatically uses EMS, XMS, and VMS virtual disk memory.

22- User-defined TYPE arrays need not be a power of two in element
size in order to exceed 128k of data space.

23- The PB3 program editor offers the capability to read and write
blocks of text to external disk files.

24- PB3 supports source-level metastatements for all compilation
switches.

25- VIEW TEXT supports scrollable rectangular text view ports.

26- PEEK and POKE extensions support byte, integer, and long integer.

27- PEEK$ and POKE$ extensions support memory block moves or assignment.

28- FLUSH will force all buffered data to be written to a disk file,
while minimizing the overhead of a file close and re-open.

29- PowerBASIC offers MIN and MAX functions which allow a variable
number of arguments: PRINT MIN(a%,b%,c%,d%)

30- BIT operations include shift, rotate, set, reset, toggle, test.

31- BIT arrays up to 512k bits are implicitly supported.

32- CHR$ allows a variable number of arguments. CRLF$ = chr$(13,10)

33- Optional procedural math package offers faster calculation
(improvement of 40% to 500%) when no numeric co-processor is
installed. Procedural math package uses the 8087 if it is
available, and can toggle between the emulator/procedural option
on a statement-by-statement basis for the highest optimization.
Procedural package adheres to IEEE floating-point standard.

34- Flex string variable type offers fixed-length strings which may
be sized dynamically at run-time.

35- MAP statement allows flex scalar and array variables to be
linked together into dynamic data structures, with nesting
capabilities limited only by available memory. These data
structures are created and sized dynamically at the time of
program execution to offer dynamic data base capabilities.

36- Many string and numeric functions offer the ANY option, such
as INSTR("abcde", ANY "cq") returns 3.

37- EXTRACT$ captures that portion of a string up to a sub-string.

38- REPEAT$ creates a string from a repetition of another string.

39- REPLACE substitutes one sub-string for all occurrences of another.

40- REMOVE$ removes all occurrences of a sub-string.

41- VERIFY ascertains that all characters in one string also occur
in a second string.

42- TALLY counts the occurrences of a sub-string.

43- LTRIM$/RTRIM$ strip leading/trailing spaces or other characters.

44- STR$(x,y) function specifies y significant decimal digits.

45- ROUND(x,y) rounds off x to y digits past the decimal point.

46- STRPTR/STRSEG return the address of any string variable data.
Dynamic, Flex, and Fixed-length strings are supported as both
scalars and arrays.

47- END statement may return an optional error level.

48- ASCII functions avoids error conditions of ASC function, by
returning -1 if the argument is a zero-length string.

49- Integer divide, MOD, AND, OR, XOR, EQV, and IMP are valid
on all numeric values in the range of a quad-word (64-bit)
integer (+/- 2^63-1).

50- PB3 optionally generates 80286/80386 specific code.

51- Library stripping for ambiguous library functions is controlled
directly by meta-statements or menu choices, rather than the
necessity of complex linker commands.

52- Separate compilation via unit modules is simpler, faster, and
offers standard PUBLIC/EXTERNAL statements.

53- Assembler object modules may be linked via $LINK meta-statements.

54- Executable files are generated directly rather than complex
shells to a compiler and linker, resulting in faster compilation.

55- A full complement of error checks can easily enabled or
disabled, including STACK, NUMERIC, OVERFLOW, and BOUNDS.

56- The PowerBasic editor doesn't alter capitalization or spacing,
and doesn't insert or remove code from the source program.

57- Line continuation characters are supported inside and ouside of

the IDE.

58- Identical code, just as efficient, is generated when error
trapping is enabled. Other compilers generate larger, slower
code whenever a program includes an ON ERROR GOTO clause. This
is a serious factor often overlooked in published benchmarks.

59- PowerBasic supports a single-line if/then/else statement which
is 100% compatible with BASICA/GW-BASIC. Other Basics force this
code to be re-written.

60- PowerBasic performs short-circuit expression evaluation in
boolean expressions.

61- Interpreted print: the user chooses graphic character or
interpreted actions for special ascii characters.

62- MTIMER function provides microtimer accuracy.

63- INSTAT function tests for a keypress without removing it from
the keyboard buffer.

64- INCR and DECR statements are offered for all numeric data types.

65- Forward references to DEF FN, SUB, and FUNCTION are allowed.

66- $SEGMENT allows multiple segments of module level code within
the same source file. There is no requirement to split your
program into multiple modules as your program size increases.

67- EXP2, EXP10, LOG2 and LOG10 are supported.

68- CEIL function returns the smallest integer greater or equal to n.

69- CALL INTERRUPT is built right into the PowerBASIC language. There's
no need to load a special library in order to access this capability.

70- FRAC function returns the fractional part of n.

71- FIX function returns the whole number part of n.

72- ISTRUE and ISFALSE Boolean operators force true and false values
to -1 and 0 respectively.

73- ITERATE forces a new iteration of a loop.

74- PB3 offers absolute arrays at any specific memory location.

75- EXIT FAR provides a controlled, multi-level SUB/FUNCTION
exit - a safe, yet powerful enhancement to the SETJMP and
LONGJMP functions found in C compilers. This allows you to
exit a SUB/FUNCTION, and immediately branch to the label most
recently specified as an EXIT FAR destination in any "parent"
procedure with any number of intervening procedure calls. All
temporaries and local variables are released as necessary, so
this is readily usable for special exception-processing. EXIT
FAR constructs may be nested to any level.

76- CODEPTR and CODESEG functions allow you to obtain the offset
and Segment of any SUB, FUNCTION, or LABEL in the program.
This capability, unavailable in other Basics, is essential
for interrupt handlers and certain other assembler code.

77- A standalone debugger (PBD.EXE) is included with PowerBASIC 3.0.

78- The PB3 Librarian (PBLIB.EXE) constructs libraries which may
include both industry-standard object modules (.obj), as well as
highly efficient binary unit modules (.pbu) constructed by the
PowerBASIC compiler.

79- Internal assembler code can access all PowerBASIC variables (even
local and static variables), as well as subs, functions, and labels.

80- $ALIAS metastatement allows the name of the main data segment to be
redefined for external object modules.

81- BITS function allows fast, one-step conversion between signed and
unsigned representations of a numeric value.

82- Internal procedures ARRAYCALC and ARRAYINFO are provided so that
assembler code can manipulate all aspects of PowerBASIC arrays.

83- PowerBASIC offers the option to preserve or discard the GOSUB stack
at the current SUB/FUNCTION level in case of a trapped error. If
the choice is to discard it, substantially more efficient code can
be generated.

84- PowerBASIC functions can be called just as if they were a SUB, and
the returned result is discarded.

85- CLS statement offers options to clear the text viewport, the graphics
viewport, the key line, or the entire screen.

86- ERRTEST function returns the current error number, while resetting it
to zero for future calls. This provides an efficient means of error
polling when using ON ERROR RESUME NEXT to mask system errors.

87- FILEATTR function can optionally return the open/closed status of a
particular file number, as well as the record length of a random file.

88- KEY statement now offers an optional third parameter which allows the
programmer to define any shift keys which should be ignored in
determining if ON KEY GOSUB should be called. With other Basics,
it's necessary to declare numerous key statements to cover every
possible combination of shift keys., or else an errant "caps lock"
or "num lock" key can cause a defined hot-key to be ignored.

89- NAME statement allows renaming of directories as well as files.

90- Serial communication is supported at baud rates up to 115200. Other
Basics are limited to 9600.

91- DIR$ function allows you to read directory items with any attribute,
not just normal files: sub-directories, volumes, hidden/system files.

92- OPEN COM supports the DT option which causes DTR to be asserted after
the communications file is closed.

93- PowerBASIC supports direct access to COM3 and COM4.

94- OPTION BINARY BASE allows the programmer to choose binary file access
based at zero or one, depending upon the program logic.

95- PowerBASIC provides documented Basic and Assembler access to numerous
internal system variables. This provides easy access to the cpu type,
co-processor type, cursor shape and visibility, PB revision, screen
page and attributes, video card, print using format characters,
screen/viewport size, and much more.

96- BIN$ function returns the binary representation of a number.

97- GET$ statement reads a binary file, assigning a specified number of
bytes to a string variable.

98- PUT$ statement writes a string expression to a binary file.

99- DELAY statement pauses program execution for n seconds without the
possibility of interrupt by a keystroke.

100- While PowerBASIC offers a large superset of the functionality found
in other compilers, moving up to PowerBASIC 3.0 couldn't be easier!
PB3 is 99+% compatible with QuickBasic syntax, and our Programmer's
Guide devotes a chapter to the minor differences which remain.


PowerBASIC . . . it's not your basic BASIC!



Check List
==========

Feature PB 3.0 QB 4.5 PDS 7.1 VBDOS
======= ====== ====== ======= =====

TSR programming support built-in X
Internal Assembler in the language X
Option to require variable declaration X X
Unsigned byte, word, dword integer variables X
User-Defined TYPES X X X X
User-Defined UNIONS X
User-Defined Dynamic Data Structures (MAPS) X
Array sort, scan, insert, delete statement X
Pointers to a sub, function, or label X
EXIT FAR multi-level sub/function exit X
Unlimited dynamic string space <1> X
ON LOCAL ERROR X X X
Standalone debugger included X X X
Editor never changes your source programs X
Conditional compilation ($IF/$ELSE/$ENDIF) X
Viewport for screen text display X X
Alternate procedural math package X X X
Procedural math package utilizes 8087 X
Extended 80-bit floats & 64-bit integers X
Floating point BCD variables X
Fixed point BCD variables <2> X X X
Block memory moves with PEEK$/POKE$ X


<1> PowerBASIC can allocate all real mode memory for any and all dynamic
strings. There are no "inside limits" (such as 64k limit per module
or sub-program) as are found in far string implementations.

<2> PowerBASIC Fixed-Point BCD variables are implemented as 64-bit scaled
integers for computational efficiency. The decimal digits (to the right
of the decimal point) may be user-defined from 0 to 18. Some Microsoft
products offer a currency data type, which is fixed at 4 decimal places.
Even though the internal format is identical to that of PowerBASIC,
additional round-off code is typically required in financial calculations
to correct the precision to standard dollars/cents levels. Since this
binary-coded-decimal format differs from traditional "natural bcd",
Microsoft contends that their products do not support BCD variables.


 December 13, 2017  Add comments

Leave a Reply