Overview | Pricing & Licensing | Evals & Downloads | Compatibility | Publisher Details | Reviews | Support Forum | Summary

Our regular prices are shown below. Please logon to see your discounted prices.

PowerBASIC Console Compiler for Windows V6.0

Our prices include ComponentSource technical support and, for most downloadable products, an online backup and a FREE upgrade to the new version if it is released within 30 days of your purchase.  All sales are made on our standard Terms and Conditions and subject to our Return Policy. Please contact us if you require any licensing option not listed, including volume licensing and previous versions.

Our regular prices are shown above. Please logon to see your discounted prices.

What’s new in PowerBASIC Console Compiler for Windows V6.0?

• Unicode Support - Mix Unicode and ANSI in the same program. Convert strings to and from OEM, Unicode, ANSI, and UTF-8. Display Unicode characters. Print Unicode characters. Read and write to Unicode files. Conversions from Unicode and ANSI are automatic. You can even select to have a complete Unicode emulation package in your executable to allow it to run properly on Windows 95, 98, and ME or select to have the runtime only use ANSI API routines.
• Resources - You can add resource data inline, right in your BASIC source code. There is no need to create a resource file, compile it, and then link it into your source. All this done automatically. Add bitmaps, icons, manifests, strings, type libraries, wave files, version information, and even binary data (RCDATA). Of course, .RC, .PBR, and .RES files are still supported. The inline resource support simplifies adding resources to your program.
• Static Link Libraries - Static Link Libraries (SLLs) consist of a set of Classes, Subs, and Functions that are compiled into a machine-code library. A SLL is the perfect vehicle for third-party code, because it creates a single final module that does not require source code to be distributed. It allows you to create a group of your own libraries that you know function correctly and don't require any further debugging. It also offers big advantages to larger group programming projects to control distribution of various elements. Multiple SLL modules may be collected into a Power Library, which is linked as a single item. Creating an SLL could not be easier. All it takes is a single #COMPILE SLL at the top of your module source code. When you wish to use the SLL code in a host program, you simply use #LINK "MyLib.SLL" and the contents are automatically embedded in the new .EXE. It's just that simple.  
• Graphics - The built in graphics engine has been expanded to support virtual graphic windows, clipping regions, scrolling text, text wrapping, and much more! Create a virtual graphic window that displays the contents of a larger virtual window. Scroll bars are added so the user can move the viewport to the desired section. There is even an option to allow the user to "drag" the edges of a graphic window to a new size. Graphic windows can be made noncloseable by the user. Work with rows and columns in a graphic window, similar to the DOS or Console LOCATE statement. GRAPHIC PRINT now supports POS(n), SPC(n), and TAB(n) functions for even more control over printing text. There's even a new Text window specially designed for text display and input, just like a Console window, but more attractive.
• Threads - Creating multi-threaded applications is easier than ever. The built-in THREAD object offers a collection of methods which allow you to easily create and maintain additional threads of execution in your programs. Functions, Subroutines, Methods, and Properties can even be marked as THREADSAFE. When a procedure is declared THREADSAFE, PowerBASIC automatically establishes a semaphore which allows only one thread to execute it at a time. Others must wait until the first thread exits the THREADSAFE procedure before they are allowed to begin. This is important to protect global data (global, threaded, static, and instance variables) from corruption by interaction of the threads.
• Optimization - #OPTIMIZE has been expanded with #OPTIMIZE CODE. Any unreferenced code will be removed from the compiled program to minimize the executable file size. String handling routines have been dramatically improved in performance. A STRINGBUILDER object for high performance string concatenation has been added. Of course, you can still use BUILD$ to concatenate strings with high efficiency. There has been an improvement in graphic execution speed. Use the #ALIGN metastatement to gain ultimate efficiency from critical code sections. Then there's #OPTIMIZE SIZE and #OPTIMIZE SPEED to choose between faster execution or smaller code size.
• Printing - The built in GDI printer engine has been expanded. Use XPRINT PREVIEW to display a replica of a printed document on the screen. Set a clipping region. Wrap text on the printed page. Work with rows and columns on the host printer. XPRINT PRINT now supports POS(n), SPC(n), and TAB(n) functions for even more control over printing text. Limit a print job by set and retrieving the page number limits and selection flag from the Print Dialog which is displayed when XPRINT ATTACH CHOOSE is executed. Many of the XPRINT statements now have a similar function form for use in expressions.
• IDE - Numerous improvements in the IDE have been made. The IDE is now based on tabs rather than MDI children. Up to 36 bookmarks are now supported. Improved undo handling. Quick context-sensitive syntax help is shown on the status bar. Find/Replace can now be set to wrap around the file. Project files have been enhanced to support a list of files, their scrolling position and caret position, a primary file, the active tab, breakpoints, bookmarks, and the debug Watch list. Backup files can now be created with a timestamp, numbered from 0 to 99, or even no backup file if you prefer. There's Print Preview and the new #PAGE metastatement for inserting a page break when printing from the IDE. Improved template files. The Open File dialog for source files now allows selecting multiple files at a time.

PowerBASIC Console Compiler is a state of the art, high performance compiler which allows you to develop virtually any type of application. PowerBASIC Console Compiler is a native code compiler for 32-bit Windows. It creates applications with a text mode user interface, perfect for Internet CGI applications or conversions from DOS. The machine code generated is among the most efficient in the industry, both in terms of size and speed. A complete IDE is included for program creation and debugging.

PowerBASIC Console Compiler professional level capabilities include Regular Expressions, multi-threading, a built-in Assembler, a full Macro facility, and much more. The machine code generated by PowerBASIC Console Compiler is small in size and and fast in execution speed. The .EXEs PowerBASIC Console Compiler creates are single standalone executables which require no run-time libraries, no DLLs, no support files of any kind unless you choose that approach. Source code is compiled at more than one million lines per minute, hundreds or thousands of times faster than many compilers. With a few changes to your DOS source code you can create programs with the PowerBASIC Console Compiler and gain access to virtually unlimited memory and the speed of 32-bit processing.

Main Features:

• Macro facility, seldom seen in a high level language, is an integral part of PowerBASIC Console Compiler. A Macro invokes a text substitution engine allowing you to extend PowerBASIC Console Compiler. With PowerBASIC macros, you can design your own unique, personal language
• PowerBASIC Console Compiler enables you to easily create fast and powerful Internet CGI applications. The PowerBASIC Automation Interface lets you tap the power of components and invoke libraries and applications via Client COM Services. Built-in support for TCP and UDP gives your application the means to communicate with servers on the Internet or local Intranets, send email messages with SMTP download web pages using HTTP oreven create your own TCP or UDP server for communication with other applications. High-speed Serial Communications built-ins let you access modems or other serial devices without struggling with obscure API calls or dial into remote computers with just a few lines of code
• PowerBASIC Console Compiler makes it easy to produce multi-threaded applications. Your program can handle 2, 3, or 1000 tasks, all at the same time. Print a report while data entry continues ,watch for a hardware signal while calculating data services. It even offers THREADED variables for "Thread Local Storage", each THREAD gets its own unique copy of the variable -- automatically
• Built-in professional level graphics support lets your program do virtually anything with text and graphics, without using the Windows API. A complete family of LPRINT functions gives you direct text access to line printers. Extended printing is easy with PowerBASIC's exclusive XPRINT suite of functions. Just like GRAPHIC for the screen, XPRINT offers it all on the printer. Print text -- any font, any size, any color. Bitmaps and images, lines and boxes, circles and polygons, virtually all the features of the GRAPHIC screen are there for printers. Retrieve the size of the printer page, printable area, margins, even the number of points per inch. Select landscape or portrait mode, even the print quality setting. The PRINTER$() function returns the name and port of every available printer
• PowerBASIC Console Compiler includes a built-in assembler, ARRAY SORT / SCAN / INSERT / DELETE / ASSIGN, MAT functions, bit operations, register variables, and much more. Supported variable types include signed and unsigned integers to 64-bit. Single, double, and extended precision float. Two forms of currency. Dynamic strings, fixed strings, ASCIIZ strings. User-defined types and unions. Guids. Variants, pointers, and BIT and SIGNED BIT field variables in types and unions
• A solid IDE simplifies programming tasks. Its editor component provides source file templates, bookmarks, block indent/outdent and block comment/uncomment. A "Code Finder" module shows every sub, function and macro name, aliases, types, and line numbers. You can sort on any column, in either direction, and change the column order in a flash. Set debugging breakpoints even in include files. The array of debugging features is impressive. PROFILE gives an overview listing of every sub and function, how many times each was called, and the total time spent executing each. CALLSTK captures all stack frames above you. TRACE generates an execution log of each sub, function, label, and TRACE PRINT, as they're executed. The watch windows for variables and registers are moveable and resizable and all dialogs remember the last used size and location. The Help file contains complete documentation. Help files for add-ons are supported, and there's a direct link to the Win32 API help. Syntax highlighting with selectable colors, fonts, and keyword case, and printed listings in color