InstantC compiles your code whenever you load source from disk, and when you want to test code you've edited. Compiling a program is necessary, of course, but when you only have to change two lines of code to fix an error, the time you spend waiting for a traditional environment to recompile the changed file and to relink an entire program is obviously wasted. To reclaim this wasted time, we designed InstantC to recompile and relink only the parts of the program that you change. You will notice the difference the first time you make a one-line change to a large program.
With traditional tools, you have to compile the entire file that
contains the change, as well as all of the
#included files. Then
you have to relink the entire program. The larger the application,
the longer it takes to recompile and relink after each change. As
an incremental compiler, InstantC greatly reduces this
recompile-and-relink time. When you load in a program,
InstantC compiles the
code once, as it loads. After that, only the parts of your program
that you change, or that are affected by your change, are recompiled.
In a large program consisting of many files, you can compile and link
after small changes in one or two seconds instead of a few minutes,
thus saving you time whenever you make a change.
As an incremental compiler, InstantC allows you to work interactively. You can try one approach to a problem, run the program immediately, then try another approach and run the program again right away. Yet because InstantC is a true compiler, your program executes at full speed. You get the benefit of both interactivity and practical execution speed.
InstantC also supports background compilation; while the compiler is processing code, InstantC's interface remains active, letting you do other tasks, such as working in the editor, even when a large amount of code has to be compiled (for example, when you first load your program).
With traditional compilers, you need to consider whether code changes
you've made in one file mean that you also need to recompile other
files and relink. If you don't, you may get a run-time error.
InstantC helps you avoid this problem by providing automatic
recompilation of any program areas that need it. Whenever you
make a change that affects more than one file, InstantC recompiles
the affected portions of the edited file, as well as the elements
in all files that contain dependencies on the change. For example,
if you change a parameter in a function definition from an
long, InstantC locates all calls to
the function and recompiles them.
Automatic recompilation means that you don't have to waste time looking
for code that depends on your edits. It ensures that all portions of
your code are always up to date.
As InstantC compiles your code, it also formats it, according to rules you specify. This means that whenever you display source code -- in the editor, in the command window, or in the debug window -- it is indented and spaced consistently, the way you want it. All blocks are neatly indented under their controlling statements, spacing around elements like logical operators and function arguments is consistent, and comments to the right of source statements are vertically aligned.
You can control all aspects of code formatting, from the number of spaces you want between a function name and its opening parenthesis to whether or not opening block braces should appear on the same line as control statements.
Automatic code formatting allows you to create code more quickly, without fussing over the placement of curly braces and other formatting details. It also promotes better comprehension: Each person on a project can look at code written by other team members formatted in his or her own indenting style. You can also use automatic formatting to ensure a uniform formatting style on large projects.
[Previous] * [Tour Index] * [Next]
[Back to the InstantC Home Page]