|Top Previous Next|
2017 Release. The latest release of EXPL has several improvements.
1. Automatic Intrinsics. The program now automatically includes the standard intrinsic declaration with every program. This include is generated internally, so it doesn't require having any external files. The include is set at Level -1, instead of Level 0 like normal includes. This means that if the program has its own included intrinsic file, the duplicate names will override and take precedence over the same names in the automatic include.
The automatic includes are passed to the compiler as an array of filenames or strings. This means that any number of automatic includes can be inserted. This includes specialized intrinsic declarations and library files. The fact that the files can be included as strings means the programming environment never has to carry around a set of extraneous files. This makes it less likely the user will lose files and disable the programming environment.
3. Variable Display. The Variable Watch option in the debugger now supports fixed, floating point and engineering notation display options. Also, the mouse-over variable value display option can display real numbers in fixed, floating point and engineering notation formats
4. Line Numbers. The Line-number dialog now allows you to double click on the a specific file and the corresponding line the in the source code will be highlighted.
5. Debugging Arrays. The debugger can now display large portions of arrays at once. This is done by specifying the array dimensions. The arrays is then displayed in the Watch List or a separate window that allows you to see large blocks of data.
6. Auto Repeat. The Step-Over and Step-into buttons in the debugger now auto-repeat if you hold the mouse button down while pressing the Control-Key. This makes it easy to rapidly step through instructions.
7. Variable Case. In the past, the debugger displayed variables as all upper case, even if there were mixed case. The debugger now displays variable in the original case that was used in the source code.
8. Reordered Compiler Messages. The compiler messages have been reorder so the first error appears first in the list and the summary appears at the top.
9. Watch Variable Number Format. There is a new format option for watch variable values in the debugger. It is called "General." When this option is selected, floating point variables are displayed in the most compact format possible. In other words, if the number contains no fraction, no decimal point or numbers past the decimal point are displayed.
10 Console Copy. You can now copy the text from Console Window to the Windows Clip board. Likewise, you can copy the image of the Console Window to the Windows Clipboard as a bitmap.
11. Intrinsic Parameter Checking. EXPL now supports intrinsic parameter checking. When this option is enabled, the Compiler checks each intrinsic call to make sure that the right number and type of parameter is used. This can be very useful for preventing bugs before they occur.
12. XPL0 Manual. The XPL0 Language Manual is now included as a part of the EXPL help file. This save you having to look for hard copies or find it on the web.
2016 Release. The latest release of EXPL has dozens of new features that make it easier and faster to program, and it adds hardware accelerated 3D graphics. Here is a list of the newest features:
1 Accelerated Graphics. EXPL now supports hardware accelerated, 3D graphics through a set of 45 new intrinsics. The accelerated 3D graphics are about 100 to 200 times faster than even the fastest assembly language code. The new features also support Scene Graphs for building complex images.
2. Easier Programming. The new version has many new features that make it easier to write code. Here are some of the most important new features:
a. You can now have an unlimited number of source files open at the same time, not just two. Each file has its own tab so you can easily switch between files. This makes it easy to debug programs that have multiple include files. It also makes it easy to copy and paste snippets of code between files. Right clicking on a tab brings up a menu that lets you close the file or transfer it. Tabs can be dragged to new positions to reorder them.
b. There are more "Tool-tip" features. Running the mouse over a symbol in the source editor pops up a small window that tells where the symbol is defined, and whether it is a procedure, variable or an intrinsic. It also tells the variable type and the line of code where the symbol is defined. If the symbol is an intrinsic, it shows the arguments and return values of the intrinsic. You can even right click on a symbol and jump to where the symbol is defined, even if it is in another file. These features work even if the program cannot be successfully compiled, because EXPL will maintain a partial symbol table up to the point at which there was an error.
c. There is a Program Structure Tool that visually shows the hierarchical structure of the program and variables, including procedure nesting.
d. There is now a search feature that enables you to search through all files that are open or all files in a directory and generate a list of lines that match the targets.
3. Improved Debugging. The debugger has many improvements:
a. The debugger can now evaluate arbitrary expressions inside array subscripts. Subscripts can contain any variable or constant in scope, including other arrays. In other words, subscripts can be nested to include arrays inside of arrays. For example:
Frog(Dog + 6 / 2, Pig(X, Y));
This means that you can mouse over the final parenthesis in a multi-dimensional array, and the program will evaluate all the variables in the subscript and display the current value of the array variable. The same thing applies to watches. A watch on an array variable can display the value of the array item specified by a complex subscript expression. All subscript expressions must evaluate to integer values. The debugger cannot evaluate function calls, intrinsic calls or compiler functions in the subscript of an array variable.
b. The I2L Debugger now displays the floating point processor status word. This useful for debugging floating point issues.
c. The Variable List in the debugger now shows all procedures and variables hierarchically. Previously, all procedures were shown at the same level with variables underneath. Now procedures may be nested inside other procedures, showing the overall structure of the program.
d. The debugger can now save a list of watches and breakpoints. This is useful when you have a large number of watches and breakpoints. It saves you the hassle of trying to enter or set a large number of watches and breakpoints between sessions.
March 2013 Release. This is a 32-bit version of the language. It contains many changes both large and small. Here is a list of the most important changes:
I. Major Changes.
1. 32-Bit EXPL. All parts of the system have been converted from 16 to 32 bits. This means that EXPL can directly address 4 gigabytes of memory. It also means that all integer arithmetic is done with 32-bit integers, greatly increasing the range of values that can be used.
2. Dynamic Heap Allocation. All heap allocations are now done dynamically. This means that a program starts out with a small memory allocation for the heap at 32K bytes. As a program uses the heap, the runtime package checks to see if the current memory allocation has been exceeded. If it has, the program expands the heap allocation to accommodate the request. This way, a program only uses the amount of memory that is actually needed. Once the heap has been expanded to accommodate a Reserve, it stays expanded until the program terminates. Since EXPL returns memory to its own pool when it exits from subroutines, the expanded heap space is available for other uses in other parts of the program.
Memory allocations that use the heap are optimized for speed. This means that you can do thousands of small allocations in a short period of time. For example, in a test application EXPL was able to do 1 million Reserves, of 500 bytes each, in less than one second. This is less than one microsecond per Reserve.
The upper limit of the allocation is set to half the integer range. For 32-bit EXPL this is 2-gigabytes. On a typical Windows system with at least 2 gigabytes of RAM, you can allocate up to 1.2 gigabytes of memory without any side effects, such as slowing other applications or interfering with the operating system. Beyond 1.2 gigabytes, Windows' memory manager usually needs to rearrange memory to create such a large, contiguous block of memory, and this process can take several seconds of disk swapping. Allocations of more than 1.4 gigabytes will usually fail. This is because Windows is using around 600K of memory for kernel functions, and these blocks are locked into hardware memory and can't be swapped out. Of course, all these limits can vary depending on how much memory is installed on the computer, what other applications are running and how the computer is configured.
3. Malloc/Release. The Malloc and Release intrinsics now handle dynamic memory like the DOS version. When DOS allocates memory, it returns a segment pointer that specifies a memory location in 16-byte paragraphs. This enables the DOS system to specify up to 1 megabyte of memory in 64K chunks. Under EXPL the language simulates the paragraph addressing scheme. Under the 16-bit version of EXPL, you can Malloc up to 64K of segments, each one up to 64K in length for a total of 1-megabyte of memory. Under 32-bit EXPL, you can specify up to 2-gigabytes of segments with each segment being up to 2-gigabytes in length. However, the same limits described above under Dynamic Heap Allocation apply to Malloc. Specifically, the total memory allocation is limited to between 1.2 to 1.4 gigabytes.
II. Debugger Improvements.
1. Array Variables in Debugger. The Debugger can now display the contents of n-dimensional arrays. You can display single array elements or a range of elements. You can also modify the contents of array locations.
2. Debugger and Include Files. The debugger can now work with include files. For example, the debugger can step through include files as well as the main program. You can also set breakpoints and watch variables in include files. As the debugger encounters include files, it opens each include file in a separate page, tracking the execution path through any number of program files.
3. System Resources Display. The debugger now has a dialog that displays detailed information about all the System Resources available in the runtime system. This includes the state of the video display, bitmaps allocated, memory allocation and files opened. The values are updated dynamically so you can keep track of how they change as you step through the program and stop execution at a breakpoint.
4. Live Palettes. The VGA Palette Dialog can also dynamically show the current palette changes while you are stepping through a program. This makes it easy to verify that your program is working in the correct video mode and that any changes you make to the palette are setting the correct colors.
III. Productivity Improvements.
1. Intrinsic Lookup. You can now right click on a word in the editor and look up an intrinsic in the Help File. To make this possible, the Help File has been reorganized so that each intrinsic is a separate topic.
2. Intrinsic Hints. If you mouse-over an identifier in the source code that is an intrinsic, the prototype for the intrinsic will be displayed. This makes it easier to understand what the arguments for an intrinsic are supposed to do. For example, you might see an intrinsic that looks like this:
By mousing-over the names the arguments are displayed, making it easy to determine what each argument does.
4. VGA Mode/Palettes. There is now a dialog box that displays all VGA modes available in EXPL. It includes detailed information about the characteristics of each mode. You can also display the color palette for each mode including all 16.7 million colors available in the 24- and 32-bit color modes. This makes it easy to select line and text colors while you write programs.
5. Compiler/Disassembler and Constant Arrays. The compiler's parsing of constant arrays has been sped up between 10 and 100 times. The Disassembler's processing of large data blocks has been sped up by 25 times.
6. Insert Intrinsic Declaration. There is now an option that inserts the declaration for the file containing the standard EXPL intrinsic declarations.
7. File Properties. There is now an option that will display detailed information about the file that is open in either of the editors. The information includes full filename and path, and the creation, access and modification dates for the file.
8. Console RGB Color Display. The Status Bar for the console now shows the RGB color of the pixel under the mouse cursor. This is useful for debugging graphic programs by letting you check the color of any pixel on the screen.
9. Include Editor. The Include Editor has been upgraded to support all the features of the main source editor.
10. Editors Fonts/Colors. You now have the option of setting the editors' fonts and screen colors.
IV. Intrinsic Changes:
1. New Intrinsics. There are 13 new intrinsics:
2. Intrinsic Changes and Improvements:
a. The GetTime intrinsic now returns microseconds instead of milliseconds.
b. The CopyImage intrinsic has been changed so the Source Handle and Source Rectangle arguments come first.
c. The PaintImage intrinsic has been changed so the Source Handle argument comes first.
d. There are four new SetCopyMode options that flip the bitmap horizontally, vertically or by even multiples of 90 degrees.
e. The SetWind intrinsic has now been fully implemented including the clipping and scrolling modes.
f. The SetPen intrinsic now has 11 new pen drawing modes beyond XOR.
g. The MulDiv intrinsic now performs a 32 x 32 multiply and divide, carrying a 64-bit intermediate result to avoid overflow.
V. Syntax Changes.
1. The Size Of Variables. EXPL itself now supports a "sizeof" command that returns the size of any EXPL data type, variable, constant and procedure in bytes. This is a portability feature that enables you to write code that can be transported between different systems without making any changes to the code.
2. Passing Real by Reference. EXPL now supports the "@" operator. This operator is necessary for passing reals to a subroutine by reference. In the past, you had to pass reals by reference as follows:
16-bit XPL = Test(addr X, 0, 0, 0)
32-bit XPL = Test(addr X, 0)
The extra zeros were necessary to pad the address so it fit in the real variable that received the address. Since 16- and 32-bit XPL have different size words, the number of arguments necessary to pad the value is different for different versions of the language. The "@" operator performs this function automatically, and it handles both 16- and 32-bit XPL.
This means the same construct can be used with either version of the language.
3. Whole-Line Comments. The backslash comment character's functionality has been improved. In the past, there was no way to comment out a whole line if there was another backslash on the line because the second backslash negated the first. To solve this problem, double backslashes in the source code now comment out the rest of the line even if the line contains other backslashes. For example, the double backslash at the beginning of this line comments out the whole line:
\\if CHAR>=^A then if CHAR<=^Z ! CHAR=^_ then \IDENTIFIER
4. Binary Constants. The compiler now supports the "%" binary constant option.
VI. New Demos. As a result of upgrading to 32 bits and the other new features, EXPL can run many more of Loren Blaney's programs including Windoze and Textris. Click here for a complete list of the demo programs available with the EXPL installation.