Review of EZ C
Shawn M. Gordon
The Kompany


As we all know, C is starting to become a dominate language throughout the computer industry. The real problem for us MPE type programmers is how to program in C on the HP 3000 for those common things such as IMAGE database I/O. What about ensuring 32 bit alignment on the variable declarations, while this is a problem in COBOL it is a much bigger problem with C. This is where EZC comes in handy. It will not only check your code for 32 bit alignment, but it will also make IMAGE I/O much easier, provide revision control to your source, provide automatic synchronization between your database, V/Plus form, and your source code, as well as giving you a sophisticated View interface for things such as Pop-up forms, and View in character mode. You also get access to four digit years, which we should all be concerned about now.

tested EZC on my HP 3000 925 running MPE/iX 4.0. The latest version of EZC also provide most of the same functionality with COBOL as well.


Here is an example from the EZC flyer of how much coding and work that they can save you.. The first example is doing a serial read and delete of an IMAGE dataset in C using EZC, the second example is doing a serial read and delete of an IMAGE dataset in C without EZC;

example 1;

while (!dbgetm2(dataset)) dbdeleten(dataset);

example 2;
dbget(base, &dataset_setno, &mode2, status, dataset_item_list, &dataset, &dataset);
if ( != 0 && != 12)
dberror(status, msgbuff, &msg_len);
msgbuff<[>(msg_len/2+1] = 0;
printf(“%s\n”, msgbuf);
else if (status.con == 0)
dbdelete(base, &dataset_setno, &mode1, status);
if (status.con != 0)
dberror(status, msgbuff, &msg_len);
msgbuff<[>(msg_len)/2) + 1] = 0;
printf(“%s\n”, msgbuff);
} while (status.con == 0);

As you can see, using EZC with C is a lot quicker, and more straight forward than having to code each piece of it.

So EZC get’s you a few things here. First off it will check your code and enforce alignment on a 32 bit boundary, which is critical for applications accessing an IMAGE data base. Next, it will ensure that your code is in sync with your database, by keeping a time stamped file of the database definitions. Lastly, it provides a set of routines that make accessing your database much easier.

The second part to EZC is V+AGILITY, which extends the functionality of View to a tremendous degree. You get character mode response, in other words, you can validate fields as they are entered, and not have to validate the screen. You get windowing like functions, and you get cursor key control. Take a look at Figure 1, and you will see a pretty attractive screen for View, the snapshot doesn’t quit do justice to how good it looks on a regular terminal though. Figure 2 shows a spreadsheet like interface, all done with V+AGILITY and View. This application will respond to the cursor keys to move from cell to cell, quit impressive. From what I can tell, there are only 12 calls that give you full access to V+AGILITY. I don’t do View because it is so disgusting, but V+AGILITY makes it pretty darn tempting to use now.

Another neat feature of V+AGILITY is the ability to debug a block mode application on two terminals. This let’s you run the program cleanly on one terminal and view the debug information on another. I have a feeling that this feature won’t work if you are using virtual devices since it requires a device number to run, but I forgot to ask.

So now you want to start using EZC, the first thing you do is run EZCDRIVE and supply it with your database name and password, it will now check for data alignment, and generate a file that contains all the information a program could possibly need to access your database. This is a regular ASCII file that has C type definitions, this file will work for code written in both C and COBOL. The file will look something like this;

imagexl ~base = {” SPARK.PUB.SMGA; “};
imagexl ~password = {“:7//+2”};
struct status_type ~status;

#define ~control_mset &~status,&~base,\
short ~control_m_set = -10;
struct ~control_m_type {
char control_key<[>2];
char descr<[>50];
char date_stamp<[>6];
char time_stamp<[>8];
char scan_date<[>6];
char scan_time<[>8];
char flags<[>30];
} ~control_m;
short ~control_m_list<[>2]=16443;

It generates a #define for each dataset, as well as creating item lists. I won’t go into all the details since the manual does a pretty good job of that. You won’t ever have to actually deal with this file, but I thought you would be curious.

Now you can write a program that uses the EZC commands as I showed you in the first code sample, when you are all done writing the code, you will run it through EZCIDENT to generate the include file, then run the source through your compiler. Now you have a program that you can use.

The EZC database access commands provide for each call and mode. You can also specify if the call will hard abort when it hits an error, or return to the program. So “dbgetn7” will do a calculated read on a master dataset, and abort if the status is not zero, “dbgetm7” will do a calculated read, and return the status that applies, in this case 0 or 17, anything else, it aborts. This convention goes for all the database calls. This makes remembering the syntax very simple.

An MPE Variable can be set before the run of the program, this will provide a variety of debug information, and even dump you into debug if you want. It’s nice that this can be turned on and off at run time.

I have only scratched the surface of what EZC can do for you, and how easy it is to use. These kinds of products are notoriously hard to accurately get across in a review, because you can’t really get a sense of how much it is doing for you, until you use it yourself.

Usability (also installation)

Installation is the standard tape restore deal, and the process goes smoothly enough, but I am not that thrilled about the accounting structure it put’s in. First you have an EZC group in the SYS account, which always tends to make me a bit nervous. The it creates a whole separate account for the demo C accounting structure called CDEMO, and on for the COBOL demo called COBLDEMO. I felt everything should have been in one account, and separated out by groups to keep it clean, but that’s just sort of a personal opinion.

The software is very simple to deal with, you may spend a week getting so you don’t have to look up the commands, but since the manual is so slim, this shouldn’t be much of a problem either way.


Other than a screen hang running one of the V+AGILITY sample programs (and I think this was more due to my network connection than the program) everything seems to run and work as advertised.


Performance on the support programs, like EZCIDENT is very fast, you won’t spend more than a few seconds while it scans and generates it’s include files. What is nice about how a lot of this is implemented, is that it uses Macros in both COBOL and C. This causes all the data to be resolved at compile time instead of having to branch at run time all over the place. There is some overhead involved in calling the EZC routines in the EZCXL, but overall they seem to execute quickly.

Supportability (including Doc)

The support isn’t bad, but it’s not great. I almost never got someone directly on the phone, and it could be up to a day before I got a call back. Once I got a response it was usually correct, and concise. The documentation strikes me as being both g
ood, and incomplete at the same time. I like the evolutionary information on the development of the product, because this helps you to understand the use of it, but it doesn’t really step you through a demo in as complete a fashion as I would like.

I am not real thrilled with the pricing for support at $100 per block of five calls, but since you get five freebies when you purchase the product, and it’s pretty easy to use, I don’t know if this will be a problem or not. After all the product is pretty inexpensive. It’s also important to note that the company does supply software updates for free, even if they are enhancements to the product. I thought this was pretty generous on their part.

The manual is pretty slim and broken apart between the IMAGE stuff for COBOL and C, and the V+AGILITY stuff. There is a very good Table of Contents at the front, but no Index at the back. So the net result here is O.K., but not great.


While there are a number of contributed programs floating around that can help generate COBOL code, I don’t think any of them get anywhere near the level of what EZC is providing. In the C language arena, I am quit sure that there is nothing that provides this type of support. Anything that saves you some time, and add’s greater resiliency to your code, it’s a good thing. The modest of price of EZC should pay for itself in a week or so of saved time by your programmers. Granted, if you are an entrenched COBOL shop, you may not be able to make use of some of EZC because it will probably conflict with how you are already doing things, but it wouldn’t hurt to try it out. I think this is a great idea for C shops to help enforce standards, and make the code cleaner and easier to maintain.

Although it would have been non-standard as far as us old IMAGE coders are concerned, it might have been nice to implement the macros so they worked like standard SQL type access. Something like READ, READNEXT, READPREV, that kind of thing. If they did that, then you could implement the code to read KSAM and MPE files with the same program syntax, and just have the Macros handle it. Now that would be slick, maybe we will see it in a later version.

The V+AGILITY is really pretty wild. I really don’t understand how they are getting View to do pop-up windows, and all the other fancy stuff. If you use View (I don’t normally), then the price of EZC is worth it just to get this kind of functionality. So if your coding in 3GL’s, then EZC is definitely worth a look.

At-a-Glance box

EZC version 3.1

N.A.Hills Computing Services Limited
336 Piccadilly St.
London, Ontario Canada N6A 1S7
(519) 672-1731

Call or write to get a demo, or to buy a copy. They require your HPSUSAN number to send out a copy. Price is $750 per copy, additional copies are $250, and support is billed at $100 per five support calls, initial purchase provides five support calls.