Bcc55-JFE   Tutorial  
 Using the Compiler and Development Environment 

This page presents a tutorial for C programmers on the use of the free IDE made up of the Borland C/C++ 5.5 commandline tools, the JFE editor, and the Makegen and Bclean development tools.

As an example, a C program composed of several files is compiled, debugged and linked into a DOS executable.

Download a Sample C Program

StackDemo is a small program used in class to demonstrate the working of C stacks.
Download the self-extracting executable  (37KB).
Extract the executable into its own directory.

The program itself is composed of eight source code files, four header files (.h) and four implementation files (.c):
StackDemo.c is the main program (the driver).
CharStack.h a header file which declares a character stack.
CharStack.c implements the character stack functions.
StackScreen.h header file - declares the functions available to draw the screen.
StackScreen.c implements the screen drawing functions.
Util.h header file - declares input/output utility functions.
Util.c implements input/output utility functions.
C99.C declares types of the 1999 C standards not yet implemented by Bcc55.

There is another file in the directory, StackDemo.wsp, which is a JFE workspace file. It contains the information, used by the JFE editor, that the ".c" files are part of the "StackDemo" workspace, or software project.

Start the JFE editor, then open the "StackDemo" workspace (File->Open Workspace).

The four ".c" files and "CharStack.h" are loaded and pop up onto the screen. A workspace window shows up on the left, and a toolbar constaining the C/C++ development tools buttons appears. Examine the source files briefly. You may also load (or Open) the other header files into the editor if you are curious to see what they look like.

Using the Development Tools:


As you develop program files one by one,  you will need to compile each file and correct its syntax errors. Let's practice doing this:

- Make "StackDemo.c" the current file in the editor (if it is not already) by, for example, clicking on its file tab in the toolbars.

- Click on the "compile1" button. This button allows compilation of individual files.
  The output window appears and displays the output of the compiler. One error is displayed.

- Double-click on the error line. The cursor jumps to the corresponding line in the source code.
 The error message says "Statement missing ; ..". The cursor is blinking on the line just after the error (all C statements must be terminated by a ';').

Fix the error and recompile... Success this time!


If our program was a very basic program, self-contained in one single file, all we would have to do in order to complete the process would be to click onto the "link1" button. This would generate an executable (".exe" file) in the current directory. We would then be able to run this program by clicking onto the "run" button.


When a project is composed of several files (the general case), the compilation and linking process is usally controlled by a utility called "make".

"make" reads a special file called a "makefile" to determine what source files it needs to compile and link, and what software libraries it needs to use in order to complete the project. 

It is possible to write a makefile manually using an editor like JFE, and this is indeed what most programmers do. However, this requires a fair amount of knowledge, and is tedious.

The make utility distributed by Borland requires a special makefile syntax. You can learn about it by clicking on the "Help" button, and looking for help on "Make" in the "Command-line tools" in the contents.

Writing makefiles manually is only acceptable in industry, where programmers work for weeks if not months-on-end on the same project and do not have therefore to write too many Makefiles.


Since you are going to write many small projects, you will need many Makefiles. The "makegen" utility has been created to simplify the work of creating Borland Makefiles.
(Note that commercial "Integrated Development Environments" -IDE for short-, like Borland C++ builder, include the equivalent of  makegen for the control of software projects.)

- Click on the "makegen" button.
The blue "Options" screen of Makegen appears. We will not dwell further at this stage on the details of the options and of other Makegen screens. You will play with these later. Just press [Enter]. Makegen creates a valid Borland makefile for you.

Makegen builds makefiles with the following defaults:
 - It includes all the ".c" and ".cpp" files in the current directory as part of your project.

 - It also assumes that the name of the executable is to be the name of the source file that contains the "main()" function (or "WinMain()", etc.. for Windows programs), and simply replaces the ".c" or ".cpp" extension, with ".exe" to obtain the name of the executable.

- It assumes that you want to compile a DOS console application rather than a Windows program.

- It places all the output files into the current directory.

- It links the produced executable with the static libraries, rather than the dynamic libraries.

- It writes a makefile called "makefile.b" into the current directory.

- These assumptions will be valid for most of your curriculum projects.
In the large majority of cases, after "makegen" finishes, you will immediately be able to build your project by clicking on the "make" button.

- If you are not happy with the makefile produced, makegen allows you to modify these defaults (for example to remove some source files from the project, or to rename the executable produced). Makegen stores your chosen project configuration into a project configuration file "Project.gen" in the current directory. The next time you open Makegen in this directory Makegen will retrieve the saved configuration.

Alternatively, you could directly edit the makefile "Makefile.b" produced by makegen... good luck!

You can call "Makegen /?" at a DOS prompt to view some brief help about what Makegen does.

BTW: The C++ source code for "makegen" is public domain. It has been written with Bcc55.
If you want to adapt makegen to your purposes (modify the defaults, or generate makefiles for other compilers), you are welcome to it. Grab it here.


We now have a working makefile. All we need to do is call "make" to compile and link all the source files in the project with a single click.

- Click on the "make" button...
Oops! we now have 2 syntax errors and one warning, this time in "StackScreen.c": Type mismatch in redeclaration of 'drawStackScreen'...
This means that "drawStackScreen" must be declared differently in the header file. 

The second error line confirms this. It's about "StackScreen.h":
Type mismatch in redeclaration of 'drawStackScreen'...
Double-click on the second error. This opens the header file and places the cursor on the offending line.

We can see that the original declaration of the "drawStackScreen()" function (in the header) did not have an "int" parameter. The warning line also tells us that parameter "a" is never used in the function.

So: Go back to the ".c" file by clicking on the 1st error line. Get rid of "int a", and replace with "void" as it was in the header.

Note: You can make "StackScreen.h" part of your JFE workspace, so that the file will be loaded automatically next time you open the workspace.
You do this by right-clicking onto the "StackScreen.h" name in the workspace window, then selecting "Add file to the project".

-Click on "make" again...Compile...Link...SUCCESS!!

There is however a nagging warning while some files are being compiled, that the function "_getch() is declared but never used". This is a function that is defined "_inline" within the Borland header "conio.h". This is nothing to worry about. If you want to extinguish that warning however, start Makegen (press [Enter] to accept the 1st query), then add the following compiler flag -w-use in the options screen (press 4). "Clean", then press "Make" again. The warning is gone.

Run / DOS

We now have an executable in the current directory. We can execute it by clicking on "run" when the file that contains the "main()" function is in focus.
-Click on "run" now.

Note: If your program does not run now, go to the section on JFE Workspaces, and read the section on "Transferring Workspaces between Operating Systems". If this is not the cause, skip further down this section and read the "Note" about programs "blinking" on-then-off.

- The program asks you to press the down-arrow key...
      Push it.
- The program asks for alphabetical characters...
      Press on letters... (anything)

Oops! Nothing happens. This program is not working!

After fixing the syntax problems we must now fix the logic errors of our program. This is a normal part of the development process:

Go to the main() function of the StackDemo.c file (Notice how you can go there quickly by expanding the "StackDemo" icon by clicking on the little "+" sign, then selecting "main" in the workspace window).

On line 68 there is a clause for when the key is alphabetic. Why doesn't it work?..
I'll give you the answer:

"The function "isalpha(ch)" returns true when the character is alphabetic. The condition has a !(not) in front, which means that the characters will be pushed onto the stack when they are NOT alphabetical. This is obviously wrong.

Get rid of that ! (not).

Now click on "make" again...

Click on "run"... At last everything runs fine!
Now you can play with the stack demo.

- If one of your programs just blinks on the screen and disappears, it could be because of a few things:
1) You are calling "run" with a file other than the one containing "main()" in focus on the screen.
     fix: Change focus to the file containing main() and call "run" again.
2) There is no code to pause at the end of your program.
    fix: Add such code (for example add a call to getch() or getchar()).
3) Your program is crashing for some internal reason.

     fix: Debug your program.

Alternatively you may want to run your program directly from a DOS console. The console does not disappear after the program exits. This may be handy if your program dies without trace and you want to have some clue as to why this happens. To do this:

- Click on "DOS"

In the MSDOS console that appears, enter the name of your executable (e.g. "StackDemo"). The console will not disappear when your program finishes, so you can always see the final output.


- Click on "DOS" and enter "dir" to look up the files in the current directory.

We started with 8 files. Now look at all this garbage!
There are:
-  ".obj" files, which are the output of the compilation of each ".c" files,
-  "StackDemo.exe", our executable.
-  "Project.gen" and "Makefile.b" produced by makegen.
- ".bak" and ".org" files produced by JFE for each file edited.
- ".ilc", ".ild", ".ilf", "ils", ".tds" files produced by the compiler and linker.

Some of these temporary files are not small. You cannot afford to keep all this.. its confusing, and you would soon fill-up your hard disk. When you have finished with a project, get rid of all the unwanted junk by pressing "clean".
The "clean" button calls a special utility called "Bclean". A blue "Bclean" screen appears, press [Enter]. This removes all of the files above, except "Project.gen" and "Makefile.b" which may be needed later to recompile and re-link the executable, and the editor temporary files that you may need to retrieve the last version of your program.

You can get some brief help on how Bclean works by calling "Bclean /?" at the DOS prompt.

Note that Bclean is called in interactive mode by the "clean"  editor button. This allows you to prevent deletion of files with a particular extension (the 3 letters after the '.' in the file name) if you wish.

Just before handing in an assignment you may want to clean up your directory of all except perhaps the source code, the executable (.exe) file, the workspace file (.wsp) and your project file and Makefile. In order to do this, go to the DOS screen by clicking on the "DOS" button, and call Bclean in interactive mode:
"Bclean -i".

Bclean in non-interactive mode (just call "Bclean") also does a good job of removing unwanted files.You only need to use the interactive mode if you want to rescue some types of files from deletion.

BTW: The C++ source code for "Bclean" is public domain. It has been written with Bcc55.
If you want to adapt makegen to your purposes (modify the defaults, or generate makefiles for other compilers), you are welcome to it. Grab it here.


- The JFE " ? " button offers help only on JFE.

- The "Help" tools button offers help on the C language, the C++ language, and the Borland development tools. Since this help is designed for Borland C++ Builder, rather than Bcc55, a small section of it is not relevant to this system (the QuickStart Tutorial). Most of it is relevant, though, and you will find the C and C++ language help highly valuable.

There is some extra help which is more rarely needed and is not accessible via the help button:

If some day you receive a compiler or linker error message that you do not comprehend, go to the C:\Apps\Bcc55JFE\Help directory with Explorer and double-click on the "Bcb5errs.hlp" file. You may find the further explanations there useful.

JFE Workspaces

- JFE can save the state of your work on a project into a "workspace" file (ending with extension ".wsp") in the current directory.
This file contains information on what files are in the project, where was the cursor at the time of the last edit, where were the bookmarks, what tools (the buttons) were available, etc...
For multi-file projects, workspaces are essential labour-saving devices. You should create one for any program that contains more than one ".c" file.

Creating a Workspace:
When you begin a project in a new directory, you create a workspace for your project by clicking on File->Save Workspace, whenever you have a file opened in the editor. Make sure that you save the workspace file into your project directory, otherwise many things will go wrong.

Workspace Window:
You can see what files are included within your workspace by clicking on view->C/C++-function list. This opens a workspace window to the left of the screen.
All open files, whether part of the project or not, are visible there. If you right-click on the name of a file, you can alternatively "Add it to the project" or "Remove it from the project".

Transferring Workspaces Between Computers:
You can transfer workspace files between computers together with the other files in the project directory without any problem (if both computers use the same Win32 operating systems).
Just load the transferred workspace into JFE on the new computer and everything will work as on the original machine.

Transferring Workspaces Between Operating Systems:
Transferring workspace files between computers running different Win32 systems is almost as troublefree. However if you move a project from Windows 98/95, say, to Windows NT or 2000, then you need to make a slight change for the [Run] and [DOS] buttons to work.

Right-click on the [DOS] button... This opens up the "Application start settings" dialog.
 The application name under Windows 98/95 should be "command.com". Under Windows NT or 2000 it should be "cmd". Make the appropriate change to that entry, then click OK.

Right-click on the [Run] button... Apply the same changes.

Modified: August 2001    -    Maintained by: cutter@codecutter.net