🚀 go-pugleaf

Beste Visual Basic programmeurs,

Ik heb hier een zeergoede advertentie i.v.m het schrijven van DLL's
met alle zeer sterke mogelijkheden wat PowerBasic te bieden heeft
want het is een zeer snelle compiler (geen interpreter, geen runtime
modules) en vooral veelzijdig en evenaart zeer goed C

De volgende producten staan op hun website:

PowerBasic for DOS Compilers (wordt verder uitgebreidt met OOP
mogelijkheid en add-on PBVISION en nog andere mogelijkheden)

 "BASIC developers who write DOS applications expect the same from
their programming tools as anyone else does: powerful language syntax,
a high-productivity development environment, a fast and efficient
compiler, solid documentation, a good selection of third-party tools,
and intangibles such as the vendor's dedication to the language and
its user base. These are tough criteria, and almost every product we
looked at came up short. But not PowerBASIC, Version 3.0. Our Editor's
Choice in the DOS category, it delivered in almost every regard." - PC
Magazine, September 28, 1993. 

Overview
Instant TSRs, built-in assembler, new data types, BCD variables,
direct array operations (sort, scan, insert, delete), fast math, and
many other BASIC firsts make this the new standard of comparison for
BASIC compilers. 

And PowerBASIC continues to improve with each release because our
development team listens to you, our customers. We respond to your
needs at every opportunity. Our latest revision offers even tighter,
faster code, and the ability to create add-on help files which
integrate seamlessly into the PowerBASIC IDE. 

If you are a DOS BASIC programmer who wants his compiler to continue
to improve, PowerBASIC is clearly the upgrade choice. PowerBASIC is
nearly 100% compatible with Quick Basic syntax, so the move up to
PowerBASIC couldn't be easier. 

Features
Virtual Arrays
Now you can store your arrays (numeric, fixed-length string and
user-defined type) in expanded memory. Make room in lower memory for
more code and dynamic string data. Create arrays up to 16 megabytes in
size, limited only by available EMS memory. 

Instant TSRs
Create TSRs in an instant with just five lines of code. A 600K TSR can
"pop-down" to a memory image of just 4K, with automatic memory
swapping to EMS or virtual disk. TSRs can be activated by practically
any stimulus: a hot key, a timer, inactivity, even a message from a
foreground program. They can be safely uninstalled under internal
program control, or by external request. Even BIOS keystroke stuffing
is available. In fact, multiple TSRs can activate each other
repeatedly, with two-way communication throughout. 

Built-in Assembler
Looking for even better performance? The new built-in Assembler may be
just what you need. For the first time, you can write Assembler code
and mix it with your PowerBASIC code line by line. Hand optimize the
most critical sections for absolute performance. PowerBASIC handles
all the details automatically. You can reference your variables,
parameters, labels and functions by name -- even debut at the CPU
register level in the expanded environment. 

New Data Types
PowerBASIC offers 11 numeric data types, 4 string data types, then
adds user-defined TYPES and UNIONS as well. There are unsigned byte,
word, and double word variables. Integers of 16,32, even 64 bits.
Single, double, and extended precision floats. Fixed and
Floating-point BCD. Fixed, Flex Dynamic and ASCIIZ (null-terminated
fixed) strings. You can even map Flex strings into dynamic structures;
they're defined, created, and sized at run-time for true database
capability. 

Direct Console I/O
As the importance of the Internet grows, so does the need for DOS
programs to communicate with Web servers. PowerBASIC allows DOS
applications to use Direct Console I/O for communication with a web
server through a CGI interface. Using Standard Input, DOS programs can
read form data from a web page, process it (such as a database
lookup), and create an output page through Standard Output for display
to the end user. 

BCD Variables
Finally you can eliminate round-off errors, even those associated with
currency variables in other languages. You aren't forced to 4 decimal
places. Instead you make your choice: from 0 to 18 digits, and always
with automatic rounding to the precise level of your needs. In
PowerBASIC, all BCD variables are implemented as scaled integers for
fast calculation. 

Array Operations
Built-in Array Sort, Scan, Insert, and Delete, with optional collate
sequencing for international or special character sets. 

Fast Math
An optional procedural float package offers startling speed. Without a
numeric co-processor, it's 40% to 500% faster than emulation. Yet it
still uses the '87 when available. It's IEEE-compatible, so you can
intermix procedural, emulated, or '87 specific code as needed. 

BASIC Firsts
PowerBASIC is the first to offer both user-defined TYPES and UNIONS,
unlimited dynamic strings, and a true handle-based string memory
manager. There are code pointers (to any sub/function/label),
conditional compilation ($IF/$ELSE/$ENDIF), even viewports for screen
text display. Then add Huge Arrays (greater than 64k), Absolute Arrays
(at a specific address), even EXIT FAR to allow multi-level
sub/function exit (beats the LONGJMP in C, any day). 

Structure
Create BASIC programs with any level of structure desired. Free-form
or absolute, the choice is yours. You can even choose to require
variable declaration before use. Another first for PowerBASIC. 

Bit Operations
PowerBASIC offers a full complement of bit operations including:
SHIFT, ROTATE, TEST, SET, RESET, and TOGGLE. Even implied bit arrays
of up to 512K bits are supported. 

Communications
Here's where PowerBASIC shines. Serial port communication is available
for COM1 through COM4. BAUD rates up to 115200. Any combination of
non-standard IRQ lines. Explicit control of DTR, even after program
termination. Automatic error detection or masking is available, with
optional flus of erroneous data. 

IDE with Mouse Support
 Use true compiled code to develop and debug -- the same code as your
EXE file. So you'll never need to deal with a slow, threaded p-code
interpreter. That means faster development, and the elimination of
subtle differences between interpreted and compiled results. You can
easily customize colors, keystrokes and compile options to suit your
personal taste. If EMS is present, the editor will store your source
code and help files in higher memory to make room for larger programs
during debugging. 

Third Party Tools
The most powerful and respected tool kits are available to PowerBASIC
users. Libraries from companies like Crescent, Information Management
Systems, Ansoft, and others make PowerBASIC the most comprehensive
BASIC compiler available today. A superb monthly newsletter (Basically
Speaking) offers timely advice and examples specifically aimed at the
PowerBASIC programmer. In a nutshell, with PowerBASIC, you'll never
need to re-invent the wheel. 

Help and Support
PowerBASIC includes extensive printed documentation -- over 700 pages
of Programmer's and Reference Guide. Then, the context-sensitive
on-line help system puts further detail right at your fingertips just
when you need it most. Perfect for the novice or the professional
developer. Technical support is available from our engineering staff
by telephone, email, mail, fax or our Web based message forums.
PowerBASIC revolutionizes BASIC by introducing true Pointer variables
for the first time in any BASIC programming dialect. Now with the
addition of Pointers, BASIC has all the important features of the
other major programming languages like C and Pascal. PowerBASIC allows
Pointers to target other Pointers, offering more levels of indirection
than any other language. 

"Up to now, BASIC programmers couldn't take advantage of the power of
Pointers," explained Bob Zale, president of PowerBASIC, Inc. "Our goal
is to continue to add to the power of BASIC, while at the same time
maintaining the ease of learning and ease of use that are traditional
with the language. Many programmers are now migrating to PowerBASIC
from C, and they require Pointers to translate their code. Since we
are a customer driven company, we've introduced Pointers into the
latest version of PowerBASIC." 

Version also allows underscores in variable names, enhanced
communications support, including support for the 16550 UART chip,and
added optimizations in speed when performing DWORD math. In addition
to improvements in the compiler itself, PowerBASIC, Inc. has enhanced
the online context-sensitive help system by adding information on Code
and Data Pointers, providing more importable source code examples, and
expanding the information on all of the extensive data types (15 in
all) supported by PowerBASIC. The two-volume documentation has also
been revised and enhanced to aid in the functionality of this
revision. 

"The true power of Pointers is in their speed and flexibility,"
reported Bruce Tonkin, noted software industry journalist and
programmer. "A pointer is a variable that holds a 32-bit (4-byte)
address of data located elsewhere in memory. It is called a pointer
because it literally points to data. The data that is being pointed to
is referred to as the target. Since the address is defined at
run-time, any target in memory can be referenced by the program just
as if it were a standard PowerBASIC variable." 

Traditionally, a BASIC programmer had to use combinations of DEF SEG,
PEEK, and POKE to access memory. Allowing the programmer to address
memory as bytes, integers, long integers, and strings. If the target
data took any other form, conversion was necessary. 

Pointers allow the programmer to address the target memory location in
any fashion desired. Even as pre-defined structure. Now with
PowerBASIC, calling DEF SEG and PEEK/POKE is unnecessary, so the
programmer has access to that data much more quickly. 

Additionally, Code Pointers allow a programmer to call a SUB or jump
to a label without needing to know their names. The CALL DWORD
extension allow programmers to call sub programs by address and pass
up to 16 parameters by reference. 

Source code examples have been enhanced, and additional examples have
been added. Including source code to useful programming utilities,
such as a text searching engine, a text file browser, a source code
formatter, a 'whereis' utility for finding files anywhere on your hard
drive, and our popular QuickBASIC to PowerBASIC conversion utility.  

System Requirements
IBM PC/XT or compatible running DOS version 3.1 or later 
512k of RAM 
4 MB of EMS memory is recommended for optimal compiler performance. 
A hard disk with 1.8 MB available for installation. 

Order Today 

PowerBASIC 3.5 for DOS is available for $119. The upgrade from
PowerBASIC 2.x and 3.x to version 3.5 is just $59 and includes a new
manual set. 

PowerBasic 32 bit Console Compiler v2.0 for Windows 95/98/NT/ME/2000

Schrijven van 32-bit Windows Console Application met al of niet
gebruik van WinAPI's

PowerBASIC Console Compiler for Windows
  Fast 32-bit BASIC for Windows 95/98/2000 and Windows NT 
Create CGI apps for your Web Server 
Client/Server communications - Send/Receive email 
Regular expression Search and Replace 
Access the entire Win32 API, including ODBC and Winsock 
Easily port DOS BASIC code to Win32 today! 

 

Ever wished for a 32-bit BASIC compiler? One with the straightforward
DOS text mode interface but megabytes and megabytes of memory? Ever
wished for a 32-bit Windows compiler that's truly easy to use? Well,
now it's here. Today. The PowerBASIC Console Compiler for Windows.
With PB/CC, it's a whole new Windows! Text mode for Win95, Win98, and
WinNT! 

 What is a Console? The Console is a text mode interface connected
right to the heart of 32-bit Windows. It looks and acts just like a
text mode DOS program, but it's actually a True 32-bit Windows
application! With a console application, there's no fluff, no animated
puppets, just intense computing power. Port existing Basic code from
DOS to Windows today! Access a flat memory model that's practically
unlimited. Boost performance with true 32-bit code. Launch multiple
concurrent threads. Use the CPU and numeric coprocessor directly with
Inline Assembler. Choose Register Variables for your most critical
code. With PB/CC, size and performance are the prime factors. 

PB/CC supports PRINT, LOCATE, LINE INPUT, INKEY$, INSTAT, CLS, COLOR,
and LPRINT. All of the standard text functions. But then we added
more. CURSOR, INSHIFT, PAGE, PCOPY, WAITKEY$ and WAITSTAT. A complete
set of mouse handling routines. SCROLL any region of the screen in any
direction. STDIN, STDOUT, and STDERR. Even a PARSE$ function to
extract delimited fields, and new options for the EXTRACT$ function,
too. All the text tools you'll ever need. 

PB/CC's high degree of compatibility with PowerBASIC, QuickBasic,
GW-BASIC and BASICA means that you can port existing DOS applications
to Win32 with ease. Stop CHAINing from module to module in DOS when
you can create a single 32-bit machine code executable up to 2
gigabytes in size. And creating an array that uses 50 megabytes of RAM
is as simple as: 


                DIM x%(0 to 26214400)

So just how fast is PB/CC anyway? We thought you'd never ask! This
tiny example may give you some idea of the power in 32-bit PB/CC. 


                x## = 1 : y## = 1.000001
                t!  = timer
                for i& = 1 to 100000000
                  x## = x## * y##
                next
                t! = timer - t!
                print t!

What do we have here? 100,000,000 iterations of a simple floating
point operation. On a 300 Mhz Pentium II, PowerBASIC 3.5 for DOS runs
this code in 9.72 seconds. Pretty respectable, we think. PB3 has been
benchmarked favorably against every sort of compiler... C++, Pascal,
QuickBasic, you name it. It's always competitive. 

So what about the 32-bit PB/CC? Same computer. Same operating system
(WinNT4). Same source code, line for line. No attempt to minimize any
background tasks. Elapsed time: 1.67 seconds. May we repeat that?
Elapsed time: 1.67 seconds. That's an instant gain of around 582%!
PB/CC is almost six times faster than the best DOS Basic around! 

Why so much faster? Lots of reasons. Register variables. Use of 32-bit
registers for long integer operations. Much improved optimization.
Simply put, lots of tricks that just aren't practical in 16-bit code.
So what's the bottom line? Infoworld may have described PowerBASIC
best when they said... 

"It's not your basic BASIC!" 

Just like PowerBASIC for DOS, our console compiler creates text mode
applications. They just run faster, deal with gigabytes of memory, and
offer access to the entire Win32 API. And since the source code is so
similar to PB3 and QB45, it's incredibly easy porting DOS code to
Windows today! 

 The PB/CC Editor allows you to edit an unlimited number of source and
text files. It features color syntax highlighting and lets you choose
your own font. You get a combo-box which lets you easily jump from one
Sub or Function to another. Search and replace text with multiple
levels of undo. Even context sensitive help on any keyword. The
integrated debugger allows you to step through your source code line
by line and watch variables. It even catches General Protection Faults
(GPF) in your code and takes you right to the offending line of source
code. 

Tired of the hassle of "drag and drop form designers"? Lost in a sea
of API calls just to display text and numbers in a window? With PB/CC,
it's a whole new Windows! Compile Basic code to sizzling text mode
programs. For Win95, Win98, even WinNT. Put your programming effort
where it belongs -- at the core of your code. And when your
calculations are complete, it's a simple matter to PRINT, or even
LPRINT, the results! 

Did you say Internet? Create CGI apps for your web server! It's the
perfect tool. PB/CC offers Standard Input & Output for easy
communication. Get standalone executables as small as 10K. All with no
run-time requirements of any kind. Whether your program looks up
names, or simply calculates a mortgage, it can take data from a web
form, process as needed, then deliver the results right to the browser
of a distant end user. 

You know, a typical shopping cart program written in Visual Basic
needs some 5 Megabytes of RAM. So, using VB, you may find you're
limited to around 20 simultaneous connections. But use PB/CC instead,
and memory needs plummet! To around 100K total! That means 1000
simultaneous connections on that very same Web Server! 

Built-in support for TCP and UDP means that your application can now
communicate with far-away servers on the Internet or local servers on
your Intranet. Send email messages with SMTP. Download web pages using
HTTP. Even create your own TCP or UDP server for communication with
other applications. 

High-speed Serial Communications means you can can access modems or
other serial devices without struggling with obscure API calls. Dial
into remote computers that aren't connected to the internet with just
a few lines of code. 

PB/CC supports code and data pointers, unsigned integers, and
null-terminated (ASCIIZ) strings. Access to the Win32 API, or any
32-bit DLL, is a breeze! Including ODBC, Winsock, and the Internet
controls. There's an inline assembler, support for threads, even
user-defined register variables for an amazing boost in performance.
And with 32-bit code, access to 2 gigabytes of RAM is built right in!
A megabyte dynamic string? That and much more is just automatic! 


PB/CC 2.0 Features
Array Sort, Scan, Insert, Delete 
Bit Shift, Rotate, Test Set, Reset and Toggle 
Built-in 32-bit assembler 
Client/Server Network Communication using TCP and UDP 
Code pointer variables (create your own callbacks) 
Compile to true machine code 
Complete access to the entire Win32 API, including ODBC and TAPI 
Conditional compilation ($If/$ElseIf/$EndIf) 
Currency variables with two levels of precision 
Data pointer variables 
Extended-precision (80-bit) floating point variables 
High-speed Serial Communications 
Matrix operations are included 
Native support for I/O redirection (STDOUT, STDIN and STDERR) 
Native support for multi-threading 
Peek/Poke, Peek$/Poke$ for memory access 
Quad-word integers (64-bit) 
Register variables, both integer and floating point 
Regular Expression Search and Replace 
String equates 
User-Defined Types and Unions 
Unsigned byte, word, and double word variables 


System Requirements
Personal computer with a 80386 or higher processor 
Windows 95/98 or Windows NT 3.51 or later 
2 MB of available memory 
One 3.5" high-density disk drive 
A hard disk with 3.0 MB available for installation 


Order Today
PB/CC version 2.0 is priced at $159 plus shipping. Owners of PB/CC
v1.0 can upgrade for just $79 plus shipping. 

Documentation for this product is provided in electronic form. A
printed manual is available for $29 plus shipping. 

 
PowerBasic 32 bit DLL Compiler for Windows 95/98/NT/ME/2000
- Het is een product die voor de twee dient :

 1. Schrijven van volwaardige en krachtige GUI Windows Applications
     met DDT.

2. Schrijven van heel snelle en krachtige DLL's die je in elke andere
    programmeertaal kan aanroepen, dus ook in Visual Basic.
    Voor verdere details bezoek hun website en geef sugesties of stel
    mij maar vragen over de producten.

PB/DLL 6.0 is a native code compiler for Windows 95/98/2000 and
windows NT. It creates extremely efficient executables (.EXE) and
industry-standard DLLs accessible from most any Windows language or
application. One popular trade journal described PB/DLL...
PowerBASIC Compiler Awarded
"Two Thumbs Up!"
"(If you) find that Visual Basic simply isn't fast enough for your
code-intensive routines, you absolutely owe it to yourself to add
PB/DLL to your arsenal of tools. TWO THUMBS UP!" 

Karl E. Peterson, Contributing Editor
Visual Basic Programmer's Journal 
 


PB/DLL out-performs Visual Basic by a typical factor from 3 to 23
times. That's right, it's up to 2,300% faster than VB! "Hello, World!"
created with VB is over 1,400,000 bytes with all the necessary runtime
DLLs. But with the PowerBASIC DLL Compiler for Windows? Just 4,608
bytes on disk, or 1,534 bytes in memory. That's something like 30,000%
smaller than VB! 

So just how fast is PB/DLL anyway? We thought you'd never ask! This
tiny example may give you some idea of the power in 32-bit PB/DLL: 


            x## = 1 : y## = 1.000001
            t! = timer
            for i& = 1 TO 100000000
              x## = x## * y##
            next
            t! = timer - t!
            MsgBox FORMAT$(t!)

What do we have here? 100,000,000 iterations of a simple floating
point operation. On a 300 Mhz Pentium II, PowerBASIC 3.5 for DOS runs
this code in 9.72 seconds. Pretty respectable, we think. PB3 has been
benchmarked favorably against every sort of compiler... C++, Pascal,
QuickBasic, you name it. It's always competitive. 

So what about the 32-bit PB/DLL? Same computer. Same operating system
(WinNT4). Same source code, line for line. No attempt to minimize any
background tasks. Elapsed time: 1.67 seconds. May we repeat that?
Elapsed time: 1.67 seconds. That's an instant gain of around 582%!
PB/DLL is almost six times faster than the best DOS Basic around! 

With PB/DLL, you get complete support for multi-threading, even in
DLLs called by a language which is not "thread-safe", such as Visual
Basic. Register variables which are up to 5 times faster than memory
variables, perfect for speeding up large calculations. 

Dynamic Dialog Tools allow you to create a complete user interface
with menus, buttons, listboxes, text boxes, labels, bitmaps, and much
more. No cumbersome "dragging & dropping", with DDT you simply define
your dialog forms in code. And their truly dynamic! Loading up to 20
times faster than Visual Basic forms. Try our complete SMTP email
client, a 27k .EXE file that allows you to send an email message to
anyone on the internet. 

 The PB/DLL Editor allows you to edit an unlimited number of source
and text files. It features color syntax highlighting and lets you
choose your own font. You get a combo-box which lets you easily jump
from one Sub or Function to another. Search and replace text with
multiple levels of undo. Even context sensitive help on any keyword.
The integrated debugger allows you to step through your source code
line by line and watch variables. It even catches General Protection
Faults (GPF) in your code and takes you right to the offending line of
source code. 

PB/DLL offers Performance... Sorting string arrays is a necessity in
nearly every program. Using VB in Windows 98, we created an array of
100,000 dynamic strings. Sorted them. Then erased them. The total
elapsed time: close to 2 minutes. Then we took the identical code,
line for line, and compiled it in PB/DLL. It executed in around 2
seconds! That's some 5,000% faster than VB! 

The Inline Assembler supports all opcodes through Pentium class,
including MMX and floating point. OLE strings for compatibility with
VB. A multi-windowed, syntax-highlighting source code editor and
debugger is an integral part of the package. 

Simply put, PB/DLL sizzles! Compile and link at over 700,000 lines per
minute -- The World's Fastest Compiler. Use PowerBASIC for Sizzling
performance, Register variables, Pointer variables, Types and Unions,
Unsigned integers, Bit operations, even a built-in assembler with MMX,
Pentium, and Floating Point support! 

New in PB/DLL 6.0, Dynamic Dialog Tools. With only a few lines of
BASIC code you can create a complete Graphical User Interface in
minutes. No more struggling with drag-and-drop form designers. No more
slow forms. And no more expensive ActiveX controls to access the
controls built-in to Windows 95, 98, 2000 and NT 4.0. Even add menus
to your dialogs. 

Client/Server Network Communications using TCP and UDP. TCP
communications allows you to download files from a web server, access
an FTP site, even send email messages over the internet. UDP
communications allows you to create client/server applications for
your local intranet. 

Advanced string handling such as Regular Expression search and
replace, PARSE$, EXTRACT$, STRDELETE$, and more. All of your data
manipulation needs. 

We put the POWER in Basic... We've said it before, but it has never
been more true than it is today. With version 6, there's a new War On
Bloatware! For the very first time, it's feasible to deliver a 32-bit
Windows application on a single floppy disk. 


PB/DLL 6.0 Features
Array Sort, Scan, Insert, Delete 
Bit Shift, Rotate, Test Set, Reset and Toggle 
Built-in 32-bit assembler 
Client/Server Network communications using TCP and UDP 
Code pointer variables (create your own callbacks) 
Compile to true machine code 
Complete access to the entire Win32 API 
Conditional compilation ($If/$EndIf) 
Currency variables with two levels of precision 
Data pointer variables 
Extended-precision (80-bit) floating point variables 
High-speed serial communications 
Native support for multi-threading 
Peek/Poke, Peek$/Poke$ for memory access 
Regular Expression search and replace 
User-Defined Types and Unions 
Unsigned byte, word, and double word variables 
Works with any Windows programming language that supports calls to
DLLs 
64-bit quad-word integers 
PB/DLL 6.0 now includes the 16-bit PB/DLL compiler at no extra charge.


System Requirements
Personal computer with a 386 or higher processor 
Windows 95, Windows 98, Windows 2000 or Windows NT 3.51 or later 
2 MB of available memory 
One 3.5" high-density disk drive 
A hard disk with 3.0 MB available for installation 


Order Today
PB/DLL 6.0 is available for $189 plus shipping. Previous PB/DLL owners
can upgrade for only $99 plus shipping. 

Documentation for this product is provided in electronic form. A
printed manual is available for $29 plus shipping. 

HUN WEBSITE VAN POWERBASIC IS:

http://www.powerbasic.com

- PBDOS v3.5
- PBCC v2.0
- PBDLL v6.0
- PBVISION/PBWORKSHOP for PBDOS
- PowerBASIC QuickPak Pro
- PowerBasic PBBTree for PBDOS en PBDLL

VOOR POWERBASIC ADD ONS EN PLUG INS

http://www.perfectsync.com voor PBCC en PBDLL
http://www.ezgui.com
http://www.kgpsoftware.com
http://www.inner-smile.com 
http://www.zeypher.com ==> SVGA lib
http://www.zapsolution.com

Met vriendelijke groeten
Stephane