EXPL-32 Development System

Top  Next
The EXPL Developments System is a special version of EXPL  designed to make it easy to write and debug programs.

This version of EXPL supports 32-bit integer size and dynamic access to up to 2-gigabytes of memory, The Development System includes an IDE with a code editors, compiler and simulated DOS/VGA console that emulates 61 Standard CGA, EGA, VGA, and Vesa Modes. It also includes a debugger that allows the programmer to single step through programs, view variable values, change variable values, set break points and step through the low-level I2L opcodes that compose the program. Finally, the language includes a set of more than 60 extended intrinsics that handle the functions that would be handled by DOS or assembly language in previous versions. Sources are available here

Click here for the full help-file index.

New Release - 3-20-2022- Structs.
EXPL. now supports structs similar to those available in C, Pascal and most other languages.

Structs are declared like this:

type TVector = record
 real X,Y,Z;

 You use them like any other XPL variable: 

TVector V1, V2;


function T3DVector CrossProduct3D(V1,V2);
\Do cross product of two vectors
\ Assumes left-hand coordinate system
T3DVector V1,V2;
T3DVector V;
V.X:=  ((V1.Y * V2.Z) - (V1.Z * V2.Y));
V.Y:= -((V1.X * V2.Z) - (V1.Z * V2.X));
V.Z:=  ((V1.X * V2.Y) - (V1.Y * V2.X));
return V;

Click here for more information.

New Release - 1-2-2020- Redirection and other incremental improvements

1. There are several new intrinsics:

SetScreenScale - Scales the video screen by a specified scale-factor.
GetScreenScale - Returns the current screen scale-factor.
GetSysMetrics - Returns various operating system settings including current screen resolution.
SetKeyboardParams - Sets keyboard repeat rate and response delay
GetKeyboardParams - Returns keyboard repeat rate and response delay

2. The Debugger now shows the execution time for each line of code or each I2L instruction when you are single stepping through the code. This is useful for optimizing the code because it shows which subroutines or lines of code take the most time.

3. There was a bug where the Tool-Tip hints would stay on the screen for several seconds when the program was run, or you switched screens. The problem has been fixed so that all hints are hidden as soon as you leave the editor page.


New Release - 10-4-2017 - Redirection and other incremental improvements

1. EXPL now supports redirection from the command line or the IDE.
2. EXPL now supports opening a DOS prompt or Windows Explorer in the director of the currently edited EXPL file
3. EXPL now handles the underscore character "-" in "%" binary numbers.
4. The speed of text and character output has been increased by about 50%.
5. There is a new "CloseOnTerminate" intrinsic that controls whether a stand-alone program closes when it terminates 
6. There is now an option that controls the size of the IDE window on startup. 
7. There is a menu option in a stand-alone program that reruns the program
8. The Status bar in a stand-alone program shows whether the program is running or not.
9. There are also a number of minor bug fixes and improvements.

New Release - 3-1-2017 - Intrinsic Argument Checking and other incremental improvements
Intrinsic Parameter Checking.

 If an intrinsic is called with the wrong or number of types arguments, it creates a stack imbalance that can cause the program to crash or behave unpredictably. If the program is large, finding the bad intrinsic call can be very difficult it literally involves scanning through every line of code in the file.

To solve this problem, 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. If a problem is found, the Compiler will flag the exact line and argument where the error occurred. This makes it easy to find intrinsic errors. It also very useful for preventing bugs before they occur.

Automatic Intrinsics.

EXPL 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 or additional code statements, the subsequent intrinsic declarations will override and take precedence over the previous declarations.

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. These could be library files or any other relevant 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 the files and not be able to run a program or use the IDE.

XPL0 Manual.
The XPL0 Language Manual is now included as a part of the EXPL help file. This saves you having to look for hard copies or find it on the web. You can view an online version of the manual here: The XPL0 Programming Language
New Demo programs.

CubeMap.xpl. This program demonstrates some of the advanced capabilities of the EXPL hardware accelerated graphics features. The program uses "Cube Mapping" to present a scene where the user is immersed in a 3D world. The technique uses six bitmap images to form  a 3D panorama that surrounds the user. Users can move through the 3D world by rotating their vision up, down, right or left. They can also move forward or back.

There are also several other new demo programs, including an Homogenous Coordinate demo and the 2048 game. Click here for a complete list of all demo programs.

Other Improvments

1. Engineering Notation. To be consistent with other versions of XPL0, the Format and RLOut intrinsics support engineering notation.

2. 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

3. 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.

4. 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.

5. 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.

6. 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.

7. 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.

8. 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.

9. 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.

New Release - 2-16-2016 - Accelerated Graphics, Improved Debugger
Hardware Acceleration
This release adds hardware accelerated 3D graphic and scene graph support. This makes EXPL 3D graphics 100 to 200 times faster than comparable assembly language programs that don't use hardware acceleration. The new features support meshes, lines, string, frames, textures, lighting and materials. Click here for an overview of the 3D graphic system. For some examples of what the new feature can do, check out the 3D Demo Programs. Finally, check out the Step-By-Step 3D graphics tutorial.
Easier Programming
The new version has many new features that make it easier to write code. This include being able to open an unlimited files at the same time, "tool-tip" information that displays variable, intrinsic and procedure information when mouse over a variable. This includes the place where the symbol is declared, the type of variable and the arguments and return value for intrinsics. You can even right-click on symbol and jump to where the symbol is defined, even if it is in another file.
There is also a Program Structure Tool that visually shows the hierarchical structure of the program and variables including procedure nesting. Finally, there is now a search feature that allows you search through all files that are open or all files in a directory and generates a list of lines that match the targets.
Improved Debugging.
The debugger can now evaluate arbitrary expressions inside array subscripts. Subscripts can contain any variable or constant in scope, including other arrays.  For example:  Frog(Dog + 6 / 2, Pig(X, Y));

That means that you can mouse over the final parenthesis in a muti-dimensional array that program will evaluate all the variables in the subscript and display the current value of the array variable.

The debugger can now save a list of watches and break points. This  saves you the hassle of trying enter or set a large number of watches and breakpoints between sessions.
There are many more new feature in this version of EXPL. Click here for more detailed information about the new features.