Tips and Tricks - Printable

Q. Why should someone purchase Claw instead of getting another vendor's Windows Ada package? Some of those claim to have a GUI builder that's integrated with the compiler.
A. Here are the primary advantages of Claw over the other stuff:

Portability. Claw is compiler-independent. If your project is based on Claw, you are less likely to be stopped dead by compiler bugs. You can switch to a different compiler and move forward.
All Ada. Claw was designed from the ground up to be an Ada interface. Claw was designed with the sort of reliability that Ada programmers expect. "List-o-pragma" interfaces don't check arguments, don't raise exceptions, and so on.
All of the documentation is written for Ada users, and it is intended to be complete. That is, it is not necessary to refer to any other documentation in order to construct your programs. Most of the other vendor's libraries are documented by referring to Microsoft's documentation, which of course requires being able to read C and to translate the information.
Object-Oriented. Claw is object-oriented through and through. Programming is accomplished by extension; inheritance and finalization are used throughout. Object-orientation allows Claw to manage user-defined objects as well as the ones that it defines. The interface that other builders use is not object-oriented.
The Claw builder is better, and is improving with every new release. It is designed to encourage users to build good Ada and good Windows programs from the start. It includes knowledge / management for the data structures of your application. (This makes it particularly useful for adding user interfaces to existing code). It also includes the connections between the various windows that make up your application, and supports simulating those connections. For instance, if you want a button push to pop up a dialog, the Claw builder will generate the code for that and support simulating it. Finally, it enforces a strict separation between programmer-written code and the builder generated code, so that it should never be necessary to look at the generated code (because of errors or misbehavior), and regeneration of the code can be accomplished at any time. We're used other builders that were limiting in important ways. Unlike them, the Claw builder supports working on multiple windows at a time. In addition, the Claw builder supports generating dialogs and menus both as code and using templates. If your application will need to be localized, especially by another organization, you will need to use templates.
Technical Assistance. See how long it takes for a human to answer your questions with any of the behemouths. Then call us at 800-722-3248 [608-245-0375 if overseas] from 12-8 Central.
Price is a final consideration. The Personal Edition Combo is available for just $295, and it includes both Claw and the Janus/Ada 95 compiler. If you already have our compiler you can get the Claw Personal Edition for just $195. And once you buy from us, you will be able to update your package to the latest and greatest for about $100 regardless of how many releases you skip.

Claw Capabilities
Q. I am not a Windows programmer, but I would like to write Windows applications in Ada. Will Claw allow me to do anything in Ada 95 that a Windows programmer can do, or do I still need to learn the Windows architecture and Win32 API?
A. The long term goal for Claw is to be able to do almost anything possible in Windows. (There are of course some capabilities which are of doubtful value, and those will continue to be omitted).
Claw 1.3 supports most GUI functions of Windows. There are other useful capabilities outside of the GUI which aren't supported in this version (Multimedia, ODBC, DirectX, etc.)
In that portion of the GUI functions supported, you can build programs using only Claw and its documentation. Nothing else (other than an Ada compilation system) is required. Of course, you may find it helpful to refer to other Windows documentation, but it is NOT required.
The Claw architecture is similar to Window's for obvious reasons, so it probably is helpful (but again, not necessary) to understand the Windows architecture while using Claw. You should not need to understand anything about Win32 itself unless you need some advanced capability not supported by Claw.
Q. I have just installed Rational Apex for NT, and was looking at the Claw Introductory version that comes with it. What does the full version have that the intro doesn't have?
A. All of the Introductory versions contain the same functionality, so this answer applies to any Introductory version of Claw, whether it came with Rational Apex for NT, Aonix ObjectAda for Windows, or was downloaded from our website.
The full Claw includes many more packages supporting most of the GUI functionality of Windows. A quick comparison of the source shows that the demo has about 90 source files totaling 2.5 Megabytes; the full version (for Claw 1.3) has 169 source files totaling 5.6 Megabytes. Important functionality like the File Open dialog are supported only in the full Claw. It also includes many additional sample programs (there are about 45 in the full Claw). The documentation for the full Claw includes a printed manual, on-line tutorials, and reference documentation for the claw packages. And last, but by no means least, the full builder is included, without the nagware splash screen and support for additional controls such as list boxes.
Q. Could you explain the difference between the personal edition and "regular" edition of Claw?
A. The personal edition only includes the support for a single compiler, and has an install tailored to that compiler. For instance, the Apex personal edition automatically creates the subsystems and views to contain Claw and its examples. The generic edition contains support for all of the compilers supported, and a generic install. That means you have to set up Claw for your compiler by hand. The generic edition makes it easier to change to a different compiler (including one that hasn't been created yet), so it decreases risk, especially for long-running projects.
Installing Claw for GNAT
Q. We recently installed Claw for GNAT. The install appeared to complete properly, but there were only a couple of files in the Claw\Source directory. What is wrong here?
A. One thing that could have happened is that Gnatchop was not able to run properly for some reason. Since the install cleans up the original files after installation and chopping, a failure to chop properly would leave your source directory empty and example directory partially empty. The setup program verifies that it can find and run Gnatchop, but it has no way to verify that the running actually works. Gnatchop is just a batch file which calls other programs, and a problem with one of the other programs would go undetected. In this case, we suggest the following remedy:
Open a DOS box.
Set up GNAT to run in the DOS box. Verify that Gnatchop actually functions and writes result files.
Insert the Claw installation disk, and type A:Setup to run the setup program (assuming your floppy disk is A: ).
Install normally.

A. Also, some versions of GNAT come with a Gnatchop.Bat that doesn't run on Windows 95. To fix it, simply load it into your favorite editor and resave it. This changes the line end characters to the <CR><LF> pairs that Windows 95 is expecting.
Q. I have just installed Claw 1.1, and the help files do not appear to work properly. Can you help?
A. There is a bug in the help that shows up on some systems and not others. It causes the help to dump you directly into a "Find" screen when you click on ClawHelp or ClawHlp in the explorer. If this happens to you, just let Find make its index. A single topic will be displayed; just click on "Display", and you'll be transported to the opening page.
A more permanent fix is to download the corrected ClawHelp.Cnt file from our web page. Install this into your \Claw\Help directory. Then, clicking on ClawHelp will take you to an appropriate table of contents. (Once you've done this, always enter help via ClawHelp, not via ClawHlp).
Of course, the best fix of all is to upgrade to Claw 1.3. Contact us for details on doing that at info@rrsoftware.com.
Downloading the Introductory version
Q. I've tried to download the CLAW Introductory version. Everytime I download it, it's a different size. And when I run it through WinZip to decompress it, it tells me that it apparently is not an archive file.
A. I suspect that you have (or your browser is) trying to download the file as a text file instead of a binary one. We have made that mistake ourselves. If you tried downloading it using a FTP program, sending the command "Binary" before sending the "Get" command usually does the trick.
Claw Serial Number
Q. Your support people asked me for my Claw serial number when I called. I don't know it, how can I find it?
A. The serial number is always found on the label of the first floppy disk or on the card with the CD key. If the product was purchased directly from us, you'll also find it on the invoice.
However, we know most users put those things away immediately. Therefore, we've also provided an easy way to find out the number. Simply open the Claw Builder, and select "About Claw Builder" from the "Help" menu. You'll find your serial number in the box.
This won't work if you have received a beta or patch version of the builder from us; in that case the serial number will appear as RRS1-00000. In this case, you'll have to go back to the original disks.
Errors using Bitmaps
Q. I've created a program using bitmaps using the Claw Builder. When I run the program, it raises Windows_Error. What's wrong?
A. This is a common problem. (And you don't need to be using the builder - or bitmaps - to run into it.) The most likely problem is with the resource file for your program.
The resource file (generally ending with .RC) contains data related to your program. Among other things, it defines the bitmaps and icons for your program. You might wonder what this is a separate file. Supposedly, it is separate so it can be changed without changing the rest of the program. Practically, hardly anybody takes advantage of this capability. So we think its purpose these days is primarily to frustrate developers and justify the price of support contracts.
The resource file is compiled a by a tool called the resource compiler. The resource compiler generally is included in your compilation system - it is not part of Claw. The exact steps needed to compile resource files depend on the compiler you are using, and are described in the Claw manual.
The Windows linker does not check for missing or out-of-date resource files. Therefore, such programs can be compiled and linked. However, when the program tries to use something in the resource file, it will raise Claw.Windows_Error (to represent a Windows failure not detected specifically by Claw). Often, the Windows error code will be 0 (no error!), which will further confuse matters.
Thus, we recommend that you insure that the resource file is properly compiled and linked with your application if you are getting unexplained Windows_Errors, especially if the errors occur from a bitmap, icon, menu, or dialog creation operation.
Q. I've compiled the resource file, but I'm stilling having problems. I'm using Rational Apex Ada 85.
A. Some special requirements apply to Rational Apex Ada 95:

The application must contain a "pragma Link_With" for the compiled resource file (a ".res" file with the same name as the ".rc" file). If you're using the Claw Builder to create the application, make sure that the Builder Option "Add Rational Apex pragmas to main subprogram" is checked. (It can be found on the "Miscellaneous" page.) This will add the appropriate pragma Link_With to your application. If the pragma is not given, Apex will not include the resource file in your application at all.
The "Build" command in Rational Apex does not check whether resource files are up to date. Therefore, it is easy to link an out of date resource file to your application. When using Rational Apex, you must remember to compile the resource file (with the "Compile|Resource" command) every time it changed. If you are using the Claw Builder, the file can potentially be changed each time you generate code.
If the resource file is omitted, or an out-of-date file is used (by failing to recompile it), you could have the same sort of problems noted in the previous question. These usually appear as mysterious Claw.Windows_Error occurrences.

Using Console Mode
Console mode is discussed in clause 2.3 of the Janus/Ada manual. Console mode requires a special version of the runtime, and this needs to be set up in your project.
If most or all of your applications are going to be console mode (rather than GUI applications), then you probably would want to set the default link to console mode. If this is done, the compiler will automatically use the console mode runtime library with any NEW projects.
To change the default link, run the following command:
Jmanager Add_Default (D:\Ada95\Rts\Console, JNT_RTS_CONSOLE)
where D:\Ada95 is your compiler directory.
For reference, the command to set the default link for GUI programs is
Jmanager Add_Default (D:\Ada95\Rts, JNT_RTS)
and to make Claw the default for programs:
Jmanager Add_Default (D:\Claw\Object, CLAW)
assuming that D:\Claw is the directory where Claw is installed.
If you only want to use console mode for a few programs, with most being GUI programs, change the project's link. For a new project, this can be done by manually creating the project, then manually creating the appropriate link.
To create a new project named "New_Project" in the current directory:
Jmanager Add_Project (., New_Project)
Note: If you are using JawsII, the project must be named "Default".
To create a link to the console runtime for New_Project:
Jmanager Add_Link (., New_Project, D:\Ada95\Rts\Console, JNT_RTS_CONSOLE)
where D:\Ada95 is the directory Janus/Ada is installed in, as above.
Similarly, to create a link to the GUI runtime for New_Project:
Jmanager Add_Link (., New_Project, D:\Ada95\Rts, JNT_RTS)
or to Claw:
Jmanager Add_Link (., New_Project, D:\Claw\Object, CLAW)
Warning: Run only ONE of these commands for any particular project!!
If creating console mode programs inside of Jaws, be sure to set the Jaws project to use console mode. (You will find this in the project options).

8-Character Limit in JAWS II
Q. I'm getting file not found errors when running Bind in JAWS II. My source file is named My_Test.Adb and the main subprogram is named My_Test_Main.
A. The Janus/Ada Binder (Jbind) requires the full name of the main subprogram, while the SDK tools must only be given the first 8 characters. Unfortunately, JAWS II doesn't know this. (We've submitted it as a bug to the supplier, hopefully it will be fixed in the next version of JAWS II). The only workaround is to insure that your source name and main subprogram name match, and are 8 or fewer characters long. This only needs to be done to your main subprogram; other packages can be named as needed. This is not a restriction when using Janus/Ada from the command line.
Printing with Janus/Ada 95 for Windows
Q. I would like to print from a simple program. I used Text_IO to open the "Prn" file (and various other names), but I always get a Name_Error exception or an ordinary file is written to. I'm running Windows 95. How can I print using Text_IO?
A. Unfortunately, the Windows 95 support for file printing is uneven. You can always print via the Windows printer support, but this is very complex. (Claw simplifies that somewhat, but it still is messy.) Printer support via Text_IO does work, but you probably will have to experiment with your machine to get it to work. (In the following, we assume you have a printer installed on your machine. If there is no printer installed in Windows 95, you'll have to do that first! Check the Windows 95 help file for information on doing that.)
If your printer is directly connected to your machine, the technique you tried should work. That is, open a Text_IO file with the special name "Prn". Then, just use Text_IO to write to the file. Note that most laser printers don't print until you eject the page, so it is usually a good idea to include a New_Page at the end of your printing.
If that doesn't work, you probably have a network printer. Windows does NOT support the special "Prn" file name for network printers. An attempt to open it will raise Name_Error. In order to print to a network printer, you will need to specify the network name of the printer. The easiest way to find the network name is to open the printers settings folder (found under "Settings" on the start menu); right-click on the printer icon; select "Properties"; select the Details page. Under "Print to the following port", there should be something like "\\ignitor\hp-laserjet". ("ignitor" is the name of the machine, "hp-laserjet" is the name of the printer on that machine.) Use that name (in the example, "\\ignitor\hp-laserjet") in place of "Prn". That will send the output directly to the printer.
This procedure will only work on a particular network, unfortunately. You could also try capturing a port such as LPT1 (see the Windows 95 help for instructions), and writing to that. We haven't been able to get that procedure to work for us, but perhaps your results will vary.
It should be pointed out that some printers simply cannot handle printing ordinary text. Such "Windows-only" printers can only be printed to using the complex Windows GUI procedure. Hopefully, you don't have one of those.
Using the Jaws II Library command
Q. The libraries menu in Jaws II is either greyed out or seems to show the files in the root of my hard disk. Why doesn't it work?
A. Jaws II is a third-party product, and as such, we didn't understand all of the nuances of it. In particular, Jaws II requires a different setup for specifications than the installation of Janus/Ada uses. (We figured out the details of this by disassembling the Jaws II program.)
Therefore, in order to use the "Libraries" menu in Jaws II with Janus/Ada 3.1.1, it is necessary to rearrange some of the files in the Janus/Ada compiler directory. (Later versions of Janus/Ada should install these files into the correct place for Jaws II.)
Using Windows Explorer, navigate to the Janus/Ada compiler directory (that is, the directory where you installed Janus/Ada).

In that directory, create a new directory (folder) by selecting "File" | "New" | "Folder" from the menu. Type the name "specs" into the box.

Select the new "specs" directory.

Create five new directories in "specs", named "nt", "user", "adauser", "adagraph", and "std".
Drag the following files from the "libs" folder (found at the same level as "specs") into "std":
CALENDAR.LIB    CHAR.LIB        COMM.LIB
C_STR.LIB       DIRECT_I.LIB    GEF.LIB         HANDLING.LIB    INTER_C.LIB
LATIN1.LIB      MAPCON.LIB      MAPS.LIB        NRANDINT.LIB    NRANDOM.LIB
NUMERICS.LIB    RENAMES.LIB     SEQUENTI.LIB    STRINGS.LIB     STRINGSB.LIB
STRINGSF.LIB    STRINGSU.LIB    TEXT_IO.LIB     WTEXT_IO.LIB
Drag the following files from the "libs" folder into "nt":
MS_LOW1_.LIB    MS_LOW2_.LIB    MS_LOW3_.LIB
MS_LOW4_.LIB    MS_LOW5_.LIB    MS_LOW6_.LIB    MS_LOW7_.LIB    MS_WINDO.LIB
MS_WIN_B.LIB    MS_WIN_C.LIB    MS_WIN_D.LIB    MS_WIN_O.LIB    MS_WIN_P.LIB
NT_CONSO.LIB    NT_CORE.LIB     NT_ERROR.LIB    NT_EXCEP.LIB    NT_IO.LIB
NT_MEMOR.LIB    NT_SERVI.LIB    NT_TYPES.LIB
Drag the remaining files from the "libs" folder into "adauser". The "adagraph" and "user" folders remain empty. If you like, you can copy the Claw specifications (Claw*.Ads) into "adagraph". "User" is intended for your personal set of reusable Ada packages.
After doing these steps, the "Libraries" menus in Jaws II should display appropriate files for each item.
Linking with Visual C++ 6.0
Q. I cannot get programs to link properly, even after following the directions in your manual. I have Visual C++ 6.0. Can you help?
A. The directions in the manual and on the disk with Janus/Ada 3.1.1 were designed for Visual C++ 4.0 through 4.2. As is typical with Microsoft, newer versions of Visual C++ shuffle all of the files around. Therefore is it necessary to modify Pathwin.Bat, or Autoexec.Bat to reflect the changes.
We will assume that Visual C++ is installed on C: into the default directory name, and that Janus/Ada is installed into C:\Ada95. If either are different, you should modify the suggestions below appropriately.
For Visual C++ 6.0:
Check the short name of the directory that Visual C++ is installed in by typing the following command in a MS-DOS window:
dir C:\Progra~1\Micro* then look in the resulting directory listing for "Microsoft Visual Studio". The short will be something like MICROS~1; if it differs on your system, use the value on your system in place of MICROS~1 below.
The PATH line in Pathwin.Bat should be changed to:
Path %PATH%;C:\Ada95;C:\Progra~1\MICROS~1\VC98\BIN; C:\Progra~1\MICROS~1\Shared~1\BIN
The INCLUDE line in Pathwin.Bat should be changed to:
Set Include=C:\PROGRA~1\MICROS~1\VC98\INCLUDE;C:\Ada95
The LIB line in Pathwin.Bat should be changed to: Set Lib=C:\PROGRA~1\MICROS~1\VC98\LIB
If you prefer, you can also make these changes to Autoexec.Bat, which will make them "permanent" for your system.
For Visual C++ 5.0:
The PATH line in Pathwin.Bat should be changed to:
Path %PATH%;C:\Ada95;C:\Progra~1\DEVSTU~1\VC\BIN; C:\Progra~1\DEVSTU~1\Shared~1\BIN
The INCLUDE line in Pathwin.Bat should be changed to:
Set Include=C:\PROGRA~1\DEVSTU~1\VC\INCLUDE;C:\Ada95
The LIB line in Pathwin.Bat should be changed to:
Set Lib=C:\PROGRA~1\DEVSTU~1\VC\LIB
If you prefer, you can also make these changes to Autoexec.Bat, which will make them "permanent" for your system.
Missing KERNEL32 function on Windows 95
Q. Until today, we have been developing, compiling, and testing our program under Windows NT. Today, we decided to try our program on a Windows 95 machine. First, we tried running the NT executable file (uucp.exe) directly. The program died in *very* early stages with 2 messagebox messages from Win95:

The UUCP.EXE file is linked to missing export KERNEL32.DLL:IsDebuggerPresent
C:\Win95UC\Uc95\uucp.exe
A device attached to the system is not functioning.
What is wrong with this???
A. This indicates that the "IsDebuggerPresent" routine is not defined.� Pulling out the current MSDN CD, and searching it for "IsDebuggerPresent" quickly shows that Windows 95 does not support it at all.
Anyway, now the question is, why is it looking for this?� There seem to be two possible answers:

You are calling it somewhere.� If so, CUT IT OUT!� :-)
You didn't link the program with /T to remove unused subprograms.� In that case, an unused definition of the routine would cause Windows to look for it.

Replacing Janus/Ada 83 Exception_Info
Q. I was adapting the util package to implement a replacement for your Ada 83 Exception_Info routine, but it will not compile with the Ada95 forms. The identifiers are not defined (Info, Text_io etc.). How should Info be declared? What is the format of the string returned from Exception_Information?
A. Exception Infomation contains a complete walkback and other information, separated by CR-LF pairs. There is a LOT more information in the Ada 95 item than in Ada 83 Exception_Info. The format is not intended to used by program tools, so it wasn't designed with fields. What I would recommend is replacing the uses of Ada83 Exception_Info with Ada95 Ada.Exceptions.Exception_Information.
That's assuming that the primary use was to output a message. In that case, just outputting the string result from Ada.Exceptions.Exception_Information is much easier. (I.e. Put_Line (Ada.Exceptions.Exception_Information (stuff));
Note that your intended replacement routine for Util cannot work, because is does not have an Exception_Occurrence parameter. So no matter how you proceed, you're going to have to rewrite the calls.
Instead of:
when others => Util.Exception_Info (x, y, z, w); You would use:
when Info:others => Put_Line(Ada.Exception_Information (Info));
WMake colors does not work
Q. I tried to run the WMake utility on colors like the installation directions said, but I get an error stating that the body of MS_WIN_BASIC.lib cannot be found. I have tried adding the path for the libraries to my autoexec.bat, but that did not help. Could you please let me know what I am doing wrong?
A. It looks to me like you have a problem with either your default link or with setting up the project file. Note that the default link is used only the first time a project is created, so if it is wrong, it stays wrong.
So, try deleting the _Janus.Prj file in the directory you're compiling to. Then retry. If that doesn't work, Delete the _Janus.Prj again, then check the default link:
Jmanager View_Default if it's not there or incorrect, reset it by JManager Add_Default C:\Jnt311\Rts\, Jnt_Rts (use your compiler directory, not C:\Jnt311\Rts). Or, perhaps the Rts install script failed for some reason. Run "JManager /D View_All C:\Jnt311\Rts" and verify that the project directory for the project name (stored in record #2) matches your compiler path. That is, if you installed into D:\Ada95, then the path stored in the file should be D:\Ada95\Rts.
If that fails, you probably ought to reinstall.
Does Janus/Ada support UNC filenames?
Q. Do the Janus/Ada tools understand UNC filenames (like: \\Server1\Janus\Ada95), or must a network drive be mapped to some file letter (like: G:\Janus\Ada95) ?
A. I believe that the tools and runtime should support UNCs. (All of the tools are compiled with earlier versions of our compiler [except JAWS II]).
Use.error
Q. We are having a problem where Ada95 is raising an Ada.IO_Exceptions.Use_Error error when we try to create a file using the 'open procedure' in an instantiated Direct_IO. Can use tell me under what circumstances use error is raised by open?
A. As it says in section 3.8.5 of the Janus/Ada manual, Direct_IO of non-simple types is not supported, and raises Use_Error. Use_Error is also raised for any error return from the operating system other than File not found error. In particular, sharing violations raise Use_Error.
Most of these cases have additional information in the exception message, which can be read with Ada.Exceptions.Exception_Message.
Using COrder with Version 3.1.1.
Q. I made the switch from Ada 83 to Ada95, and I don't quite see how to use COrder these days. One of my existing batches gives a "missing project name" error message.
A. In order so COrder would be consistent with the other tools, we had to change the existing "/P" option to "/N". Therefore, any existing "/P"s in old batches need to be changed to "/N". Adding a (new) /P and /R similar to those used by the compiler will also be a good idea (unless, of course, you aren't using those options with the compiler).
Q. If I run COrder on something in \examples, I'd like it to also recompile as necessary any changed stuff in \source, but seemingly the compiler's /p and /r options would have to be different in those cases. What am I supposed to do?
A. Assuming you are using the /Z option to compile files in linked libraries, COrder will put appropriate /P and /R options on the command line. You can look in the generated batch file to verify this before running it.
Invocation Parameters
Q. I would like to get the arguments which are passed from operating system at the invocation. In C-Language, these would be "ARGC" and "ARGV". How can I get the invocation parameters?
A. You want to use the Ada 95 standard package Ada.Command_Line. See clause A.15 in the Ada reference manual for its definition.
If you are using Ada 83, you can get at the command line via the Util package. (See chapter 10 in the compiler manual). That package is also supported for Ada 95, but Ada.Command_Line should be used instead.
Janus/Ada Serial Number
Q. Your support people asked me for my Janus/Ada serial number when I called. I don't know it, how can I find it?
A. The serial number is always found on the label of the first floppy disk or on the card with the CD key. If the product was purchased directly from us, you'll also find it on the invoice.
However, we know most users put those things away immediately. Therefore, many of our programs report their serial number in some way. For Janus/Ada, the serial number is reported by Janus and JBind when you run them from the command line. You don't actually need to compile anything, just run either of them. You'll find your right below the R.R. Software copyright message.
This won't work if you have received a beta or patch version of the compiler from us; in that case the serial number will appear as RRS1-00000. In this case, you'll have to go back to the original disks.
Interfacing pragmas and "Unsupported Mode or Type"
Q. I'm getting the error message "Unsupported Mode or Type used for language convention" on a pragma Exported subprogram. The same subprogram works if I use pragma Import, and the parameter type is one declared in Interfaces.C. Is this a compiler bug?
    procedure My_Info (Data : in Interfaces.C.Char_Array);
    pragma Export (C, My_Info);
A. No, this isn't a bug. While the implementation advice in the Ada reference manual implies that this sort of parameter should be supported, it actually is impossible for pragma Export.
The problem is that Interfaces.C.Char_Array is an unconstrained array type. That means that the object can be any length, with the actual bounds and length available via the array attributes (for instance, Data'Last in your example). However, C passes arrays as a pointer, without any length information. Therefore, the compiler has no idea how long the actual object is and therefore cannot determine the correct value to use for the Last and Length attributes. Since we can't apply meaningful values to these attributes, we have to reject the declaration of the subprogram.
There is no problem supporting this type for pragma Import (the item has stored bounds, but C doesn't need them, so we can just remove them), thus your example subprogram will work as an Imported routine, but will not work as an Exported routine.
A constrained array can be used in place of the unconstrained array:
    subtype My_Array is Interfaces.C.Char_Array (0 .. 1000);
    procedure My_Info (Data : in My_Array);
    pragma Export (C, My_Info);
If you don't actually know the length of the C array when it is passed (for instance when the length is passed as a second parameter, or when it is a nul-terminated string), you can simply set the length to a very large value. However, in that case, you have lost the ability of Ada to detect out-of-range accesses to the array: any access beyond the end of the object could crash the program by scrambling memory. Use extreme care and extensive comments if it is necessary to do this.
Similar problems can arise for access types that designate an unconstrained array. For example:
    type My_Chars_Ptr is access all Interfaces.C.Char_Array;

    procedure My_Info (Data : in My_Chars_Ptr); -- Not supported.
    pragma Export (C, My_Info);

    function My_Data return My_Chars_Ptr; -- Not supported.
    pragma Import (C, My_Data);
In both of these cases, we cannot determine the bounds to use for the designated object coming from C, so they are not supported. However, you can Import a procedure like My_Info, and Export a function like My_Data, as then we're removing information.
Unix Compatibility for Janus/Ada
Q. I have Red Hat Linux 2.0.36. Will Janus/Ada 95 for Unix work on this system?
A. Janus/Ada 95 for Unix conforms to the Intel ABI for Unix. Systems that are known to conform are SCO UNIX and older versions of Sun Solaris for Intel processors. Other systems claim to support the ABI, including some of the free systems. However, there are as many versions of Unix out there as there as there are computers -- we simply can't test them all. Therefore, we've created a simple compatibility test for Unix and Unix-like systems.
The test consists of a pair of test programs compiled with Janus/Ada 95 for Unix. Since the compiler is an Ada program compiled with Janus/Ada 95 itself, if the example programs work, it is very likely that the compiler also will work properly.
Click here to download the tqsort program, and here to download the ACATS multiply test. The files are both compressed executables; they are named .zip to fool our provider's web server to send them as binary files rather than text.
To test the Tqsort program:

Download the tqsort.Zip file.
Change the file name to tqsort.Z with the "mv" command: mv tqsort.Zip tqsort.Z.
Decompress the file: uncompress tqsort.
Make the file executable: chmod 755 tqsort.
Run the file: ./tqsort
If the program works, it will write a random list of numbers to standard output, sort them, write the sorted list, and finally the time taken.
To test the ACATS multiply test program:

Download the c45504a.Zip file.
Change the file name to c45504a.Z with the "mv" command: mv c45504a.Zip c45504a.Z.
Decompress the file: uncompress c45504a.
Make the file executable: chmod 755 c45504a.
Run the file: ./c45504a
If the program works, it will display a series of messages ending with "Passed".
We've provided two programs so that we can check exception handling separately from the normal operation of programs.
If both programs work as expected, then Janus/Ada 95 should work on your system. If they don't work, Janus/Ada 95 probably won't work. We'd be interested in your results, especially exactly how the programs fail (if they fail); send them to randy@rrsoftware.com.

Claw 1.2 bug list

(Builder) If a window is created (via New Window) while in simulation mode, a walkback (rather than the window) appears. No data is lost, the project still can be saved.
(Builder) If a menu item is activates a dialog box, and the dialog box is deleted, a later attempt to edit the menu item will produce a walkback.
(Builder) When a project is loaded by double-clicking in Explorer (or by giving its name on the command line), a walkback message appears. The error can be ignored; it is self-correcting. Or the problem can be avoided completely by loading projects with "Open".
(Builder) When a radio button set having the default "Claw generates" identifier is simulated, clicking some of the buttons may cause the window to vanish or other erratic behavior.
(Builder) The case of radio button labels is improperly simulated, so that the labels may appear differently in the generated program.
If a Claw listbox (any type derived from Claw.Listbox.Root_Listbox_Type) is destroyed and recreated using the same object, the second Create will raise Claw.Not_Valid_Error for no reason.
Claw.Bitmaps.IO cannot read some 24-bit color bitmaps. This also affects the builder: problem bitmaps will not display in the sample box or in graphics.
Claw.Tooltips.Set_Durations uses the wrong word to set the timeouts. The result is that all of the timeouts are set to zero, not matter what the arguments are.
For a basic listbox, setting the key value when using Add_Text, Add_Text_to_End, and Insert_Text does not work. (It does work for a drop-down listbox and for comboboxes). To workaround the problem, use Add_Key to set the key value for basic listboxes.
(Builder) For an integer edit control with a subtype (rather than a type), if the initial value is negative, the generated code will not compile.
(Builder) Sometimes, after editing a menu item label, any access key is rejected as not being in the label. Workaround: set the access key to blank; then edit the label again and key in the entire label; finally, set the access key appropriately.
(Builder) If more than 20 top-level windows are created, the Builder crashes.
(Builder) If a child control of a group box uses a font (other than that of the group box), the font object may not be generated.
(Builder) If a radio button set is used in the application window, the selected value is never read and stored into the value component. Work around the problem by calling the Get_Selection in the appropriate instantiation to get the value before using it.
(Builder) A default sized radio button set is displayed differently (shorter with the buttons closer together) than it is the compiled, generated code. This problem can be worked around by simply using a fixed size radio button set: clear the "Use Default Size" box on the location page.
Claw.Radio_Button_Set.Move incorrectly calculates the size of a default sized set, using a size that is too small (but still readable). This means that the size calculated by Move is different than the size calculated by Create.
Calling Claw.Tooltip.Add_Tooltip for a rectangle without an Id or with a Claw-generated Id don't show a tooltip. Work around the problem by calling the Claw.Tooltip.Add_Tooltip with the Id parameter.
If the file list returning version of Open_File is called without the Explorer_Format flag, Windows always uses an old style dialog. However, Claw sometimes thinks that a new-style dialog was used, and thus fails to parse the returned list properly. Work around the problem by always specifying the Explorer_Format flag or by setting Autoposition to True.
(Builder) If the last item (or submenu) in a menu is deleted (leaving an empty menu), CBuild may crash or pop up error messages.
(Builder) If a project contains more than one menu, the builder may assign the same Id number to more than one menu item. (This will only happen when the second or later menus are initially created.) That means that only one of the actions will be executed when the program is generated and run; both items will execute that action. If you suspect this is happening, use the Identifier page to check the values of the menu identifier. (It is the number at the bottom; it may be displayed in grey, but it will display the number being used.) If there is a problem, manually correct it by clearing "Best way" and selecting "Manual Identifier Selection".
(Builder) If a menu does not contain an exit command (that is, a command with the standard action Exit), or the exit command is moved to a new command, the builder may generate code that either does not exit properly, or raises an exception when run. (In the latter case, the program will never appear when started.) The problem can be worked around by always having an exit command in your menus (a good idea anyway), and showing the application window just before generating code.
(Builder) The Builder allows entering a reserved word into an box that requires an Ada identifier, but the generated code will not compile.
(Builder) Integer and Float edit controls reset justification to Default when the project is loaded from a file, if the target OS is not Windows 98/2000 and (for Integer edit controls) the up-down arrow is off. Work around the problem by using Default justification, which is right justification for these targets (but see the next bug).
(Builder) Integer and Float edit controls use the wrong justification in the generated code for Default justification. The resulting program does not match the simulated program. Work around the problem by specifying Right justification (but see the previous bug).
(Builder) If the application window is cut or deleted, and the project properties is opened (main page), an application error will appear.
(Builder) RC cannot compile a menu with empty submenus. Either avoid empty submenus, or set "Use Claw code whenever possible" in the project properties (in which case the menus will not be defined in the resource file).
If an modal dialog object is reused, and it contains a radio button set component, Already_Valid_Error is raised incorrectly. Is_Valid would return False for the set component. Work around the problem by avoiding reuse of the object, or by explicitly Destroying the radio button set component.
(Builder) If the default menu is used, and a custom exit handler is used, the application cannot be exited. Work around the problem by explicitly defining a menu for the application.
(Builder) Edit controls may lose their initial values. This occurs if the control is used in other than a dialog box, or if validation handlers are used for other controls in the dialog. The control will always be filled with blanks, no matter what value is specified.
For string edit controls, the problem can be worked around by specifying a control size, rather than letting Claw select a size. No workaround is available for numeric edit controls.
(Builder) The (specified, non-default) location of a dialog box is relative to the parent. The documentation implies that it is relative to the screen. (The documentation is incorrect.)
The Boolean function Claw.Tree_View.Is_Root_Item returns the wrong answer in all cases.
The function Claw.Window_Operations.Get_Desktop leaves a "lost" window behind after it is called; this window may raise an exception, hang the program, or do something else bad (depending on the compiler used) when the program exits.
If a DLL_Object is reused (that is Load is called after a previous Free), Already_Valid_Error will be raised for no reason.

Claw 1.1 bug list

The default title for Claw.Dialog.Save_as_File is "Open", it should be "Save As".
The Initial_Directory parameters for Claw.Dialog.Open_File and Claw.Dialog.Save_as_File have no effect.
The system command Close (that is, the Close button on the title bar) is not passed to When_Command for Frame_Window_Type.
Sometimes the help files open a Find box instead of the table of contents. If this happens to you, select the topic offered, then select Contents.
Claw.Menus.Item_Count raises Windows_Error when passed a valid menu.
Creating a top-level window (that is, a window without a parent or owner) inside of an action routine takes at least 10 seconds during which nothing else can happen.
If a window with a popup menu is destroyed before the menu is destroyed, an exception (typically, Constraint_Error) may be raised within Claw.
Claw.Dialog.Modal.Set_Background_Brush and Claw.Dialog.Modeless.Set_Background_Brush raise Not_Valid_Error when passed a valid brush.
Claw.Window_Operations.Position may raise an unexpected exception when used on Windows NT.
Claw.Window_Operations.Size and Claw.Window_Operations.Client_Size return answers which are 1 pixel too large. If these are then used in Claw.Move, the window will grow a bit larger.
If Set_Text_Color is used to set the text color for an edit control or list box, the wrong background color will be used. Work around the problem by using Set_Colors instead of Set_Text_Color.
On Windows NT 3.51, Get_System_Font returns a Logical_Font_Type full of garbage. The function works properly on Windows 95 and Windows NT 4.0.
Claw.Edit.Multiline.Get_Text loses all of the line breaks (<CR><LF> pairs) in the returned text, and sometimes includes garbage characters on the end of the returned text. The problem can be worked around by getting a single line of text at a time and inserting the needed returns.
When Claw is compiled with GNAT, the Testcomm sample program fails with "error code 1" when Choose Printer is selected. This can be fixed by changing the right-hand side of line 215 of Claw-Dialog-Printer.Adb from "Dialog.CPR'Size/8" to "66", then recompiling the file.
On some systems, clicking on ClawHelp via the explorer brings up a Find box, not help. There are two workarounds: Download a replacement ClawHelp.Cnt file from our web page. This will eliminate the problem with ClawHelp. Or, failing that, let the Find box create an index. It will show only one topic. Select that topic, and press "Display". You will be sent to the contents page for Claw help.
When a Claw application is run on Windows NT 4.0, static controls which display icons or bitmaps intermittently raise Constraint_Error.

Janus/Ada 3.1.1 Bug List
Bugs are found in the Janus/Ada compiler unless otherwise noted.

If an object name containing a type conversion and following dot notation or indexing is passed to an In Out or Out parameter, the compiler will crash (typically with a GP fault). Such a call could look like:
Get (Edit, Dialog_Type(Edit.Parent).Point_Size);
This type of conversion can be necessary in cases involving child packages and private components.� It will work in other cases (i.e. assignment, in parameters, etc.)
(Found in versions 3.1.1 and 3.1.1a)
Discriminant parts which conform properly may be reported as incorrect if the partial view has inherited discriminants or components.
(Found in versions 3.1.1 and 3.1.1a)
A discrete range which contains a call on a primitive function of a tagged type will cause the compiler to crash. Work around the problem by putting the result of the primitive function into a temporary object, then using that in the discrete range.
(Found in versions 3.1.1 and 3.1.1a)
If a non-simple component (such as a dynamic array) has controlled subcomponents, finalization may fail or cause a GP fault.
(Found in versions 3.1.1 and 3.1.1a)
(Corder) If Corder has been run previously on a program, and a unit contains subunits, Corder may fail to load the subunits and GP fault.
(Found in version 3.1.1a)
If the function version of Ada.Strings.Fixed.Trim (and Ada.Strings.Wide_Fixed.Trim) is called with a string whose 'First value is not 1, an incorrect answer may be returned.
(Found in version 3.1.1a)
(Syntax) The wrong source code was used to construct Syntax.Exe; therefore, several old bugs reappeared. The most important of these are:

Some legal real numbers are rejected.
Pretty printer indentation after a "null record" is incorrect.
Some Ada 95 pragmas aren't recognized.
(Found in version 3.1.1a, Windows 95/NT only)
The compiler may generate an internal error for a renames-as-body of a function. The problem is most likely for a rename of a generic function instantiation. Work around the problem by using a full subprogram body rather than the renames.
(Found in versions 3.1.1 and 3.1.1a)
Janus3 or Janus4 may generate an internal error if the new-style address clause is used.
for Something'Address use Expr;
Use the old style address clause with the compiler versions listed below.
for Something use at Expr;
(Found in versions 3.1.1, 3.1.1a, and 3.1.1b)
If a function returns an object of a limited controlled type, the generated code will call Adjust, which doesn't exist for limited controlled types. Some other routine will be called, with varying results.
(Found in versions 3.1.1, 3.1.1a, and 3.1.1b)
Storage_Error may be raised when an object is returned from a function whose return type is an unconstrained discriminated type, most likely occurring for class-wide types. The problem will be intermittent, as the allocator is using an uninitialized size.
(Found in versions 3.1.1, 3.1.1a, and 3.1.1b)
If 'Access is used on a renamed subprogram, the compiler will generate internal errors. Use 'Access on the original subprogram to work around the problem.
(Found in versions 3.1.1, 3.1.1a, and 3.1.1b)
The discriminants for a stand-alone task object are not initialized properly; random values may be read. (Found in versions 3.1.1, 3.1.1a, and 3.1.1b)
Array length checking used the Ada 83 rule, rather than the more restrictive Ada 95 rule. This means that some multi-dimensional array assignments which ought to raise Constraint_Error were allowed.
(Found in versions 3.1.1, 3.1.1a, and 3.1.1b)
(Windows NT only) Allocation of objects larger than about 512K will always raise Storage_Error on Windows NT, even if plenty of space is available. This is caused by a quirk in the Windows heap manager; the quirk does not appear on Windows 95. The bug can affect the compiler, binder and other tools when run on Windows NT; you should not have problems unless you try to process very large program units.
(Found in versions 3.1.1, 3.1.1a, and 3.1.1b)
If an aggregate containing a "null record" part is used in a package specification, the compiler may give spurious errors (especially "symbol table full" when the specification is withed. This can happen both for extensions and regular aggregates.
(Found in versions 3.1.1, 3.1.1a, 3.1.1b, and 3.1.1c)
If a record representation clause is given on a type extension with discriminants and dependent components, wrong code can be generated. Spurious Storage_Errors or Constraint_Errors can occur.
(Found in versions 3.1.1, 3.1.1a, 3.1.1b, and 3.1.1c)
If a type extension's parent type used floating point, "Floating point library not withed" messages may occur. If the problem does occur, adding a declaration like "Bug_Fix : Float := 1.0;" to the offending package specification will work around the problem.
(Found in versions 3.1.1, 3.1.1a, 3.1.1b, and 3.1.1c)
(Corder) The upper limit on the 'K' option is smaller than intended, which prevents using the option to support long source file names.
(Found in versions 3.1.1, 3.1.1a, 3.1.1b, and 3.1.1c)
If an access type points at an incomplete type later completed by a controlled type or a type with controlled components, the wrong master will be used for finalization. This may cause allocated objects to get finalized while they still exist.
(Found in versions 3.1.1, 3.1.1a, 3.1.1b, and 3.1.1c)
An enumeration type with an enumeration representation clause which forces a signed representation may give spurious errors when used in a case statement.
(Found in versions 3.1.1, 3.1.1a, 3.1.1b, and 3.1.1c)
(Syntax) Expressions like "for I in 1..100 loop" don't pretty print properly; the first dot is duplicated.
(Found in versions 3.1.1 thru 3.1.1c.)
If a tagged private type appears in a generic library package, the compiler may crash when the unit is withed. (This does not apply to formal generic private types, only to type declared in the generic specification).
(Found in versions 3.1.1 thru 3.1.1c.)
A return statement in an accept statement will cause the compiler to abort if the task is declared directly in a package. (Found in versions 3.1.1 thru 3.1.1c.)
(Corder) Corder fails to close all of the files it uses when checking subprogram units without specifications. If enough such units are used, Corder may crash or refuse to recognize source files. (This problem can be worked around by giving the units in question specifications).
Corder also will crash if a subunit is ignored. Always specify a source name for a subunit.
(Found in versions 3.1.1 thru 3.1.1c.)
To_Unbounded_String in Ada.Strings.Unbounded (as well as some other routines) allocate memory that they never deallocate. Therefore, long running programs using Unbounded_Strings may run out of memory. The problem is also found in the Ada.Strings.Wide_Unbounded package.
(Found in versions 3.1.1 thru 3.1.1c.)
Linking the profiler to a program may cause the program to GP fault immediately when it is run.
(Windows versions only)
(Found in version 3.1.1a only)
(Syntax) Expressions like "A:Integer range 0..3:=0;" don't pretty print properly; the colon is duplicated.
(Found in versions 3.1.1 thru 3.1.1c.)
A program which overflows the stack while allocating more than 4K of local variables at one time may GP fault rather than raise Storage_Error.
(Windows versions only)
(Found in versions 3.0.7, 3.1.1, 3.1.1a, 3.1.1d)
If the actual parameter to a procedure or entry call is a protected component with no selection or indexing, and the formal parameter mode is in out or out, the compiler may get internal errors or the resulting code may crash.
(Found in versions 3.1.1 thru 3.1.1d.)
Selection/indexing of a discriminant doesn't work. Work around the problem by making a copy of the discriminant.
(Found in versions 3.1.1 thru 3.1.1d.)
A slice assignment from a primitive function of a tagged type causes the compiler to crash. The problem can be avoided by declaring the function result as a constant in a declare block, then assigning the constant into a slice.
(Found in versions 3.1.1 thru 3.1.1d.)
Universal fixed multiplies and divides may give incorrect results if the result is directly used. Avoid the problem by type converting the result (as in Ada83) or by using one of the fixed*integer or fixed/integer operations. (The latter generate better code, too.)
A program which creates many tasks but only has a few active at a time may raise Storage_Error when plenty of memory is available.
(Windows versions only)
(Found in versions 3.1.1 thru 3.1.1d.)
Abstract subprograms in a library package specification cause the linker to require a body for the package, even though no completions are required.
(Found in versions 3.1.1 thru 3.1.1d.)

Resetting a file may cause a general protection fault. The problem only happens on Windows 95 (not Windows 98 or Windows NT) and only to GUI applications (not console applications). Close the file and re-open it to work around the bug.
(Found in versions 3.1.1 thru 3.1.1d.)

If a source file name or path contains blanks, Corder mistakenly removes them when writing a batch file. This can cause problems with Make and WMake as well as Corder. While all versions of Corder contain the offending code, problems occur mainly on Windows NT or Windows 95.
Avoid paths and file names with blanks, or request a repaired version of Corder from technical support.
(Found in versions 3.1.1 thru 3.1.1d.)

If a function declared in an instantiation of a generic unit returns a classwide type or an access to classwide type, internal compiler errors will occur on any call.
(Found in versions 3.1.1 thru 3.1.1d.)

If an exception is raised and not handled early (during elaboration) in a tasking program, a GP fault may occur as the program is exiting. The fault is harmless (all needed cleanup has been completed).
(Found in versions 3.1.1 thru 3.1.1d.)

If a private type derived from a tagged type which has a subprogram with a controlling access parameter, overriding of the subprogram may not happen properly. The result could be that the program could get an 'undefined label' error when compiling; it could fail to link with an 'undefined entry'; or the routine could simply fail to be dispatched to.
(Found in versions 3.1.1 thru 3.1.1d.)

If an object name containing a type conversion and following dot notation or indexing is passed to an In Out or Out parameter, additional junk code may be generated. This most commonly happens for components that are strings. Such a call could look like:
Move (Source => New_Name, Target => Dialog_Type(Dialog).Item_Name);
The junk code often is harmless (especially for small components), but it can cause trash to be written into heap-allocated items, including unrelated ones.
(Found in versions 3.1.1 thru 3.1.1d.)

If an unsupported 'Size clause is given on an array or record type, later operations on that type may cause compiler errors or even a compiler hang.
(Found in versions 3.1.1 thru 3.1.1d.)

(Syntax) If the trailing '\' is omitted from the output path for pretty printed text, Syntax will use a garbage output file name. In particular, this causes the "AdaReformat" command in Jaws II to fail.
(Found in versions 3.1.1 thru 3.1.1d.)

(Jaws II) (Windows 98 only) The output of compiles and links is not visible on Windows 98 (the output window is empty, although the compile or link runs). This only happens on Windows 98, not on Windows 95 or Windows NT. A patched version of Jaws II is available, click here to download it.
To install the patch, unzip the file into the compiler installation directory, overwriting the existing Jawsii.Exe file. An unzip utility can be found on disk 4 of the compiler installation disks if you don't have one.
(Jaws II) (Windows NT/2000 only) Jaws hangs when Open Project is used on Windows NT or Windows 2000. This problem does not happen on Windows 95 or 98. A patched version of Jaws II is available, click here to download it, and see the previous item for installation instructions.

(Jaws II) (Windows only) The "Library" commands either are greyed out or show files in the root. This can be worked around by moving files in the compiler directory; see the FAQ.

(Corder) Corder generates a spurious syntax error if a unit of the program contains a task type declaration with a discriminant part. This error is harmless unless a subunit stub appears after the task declaration (then the stub would be ignored and not compiled as needed).
(Found in versions 3.1.1 thru 3.1.1d.)

If a generic formal specification contains a reference to 'Class of a formal type, the compiler may reject the program unnecessarily.
(Found in versions 3.1.1 thru 3.1.1d.)

If a generic specification contains a type derived from a generic formal type, the type declared in an instantiation will match the actual type. This will cause type errors to be ignored, and may cause the wrong operators or subprograms to be called.
(Found in versions 3.1.1 thru 3.1.1d.)

An illegal (ambiguous) program may compile successfully if a classwide routine is overloaded with a specific routine of another composite type and an unqualified aggregate is given in a call. The problem is harmless but would be a portability problem.
(Found in versions 3.1.1 thru 3.1.1d.)

Ada.Text_IO.Set_Col(File, 1) incorrectly skips blank lines. Set_Col works properly when setting to other column numbers.
(Found in versions 3.1.1 thru 3.1.1d.)

The compiler incorrect accepts abstract subprogram declarations in protected types, generic formal parts, and library unit declarations. These are not allowed by the standard.
(Found in versions 3.1.1 thru 3.1.1d.)

A dereference of an In parameter used as the prefix of the Access attribute sometimes is incorrectly considered constant. You are most likely to see this bug when the prefix end with an explicit .all or an array reference with a dereference (explicit or implicit).
(Found in versions 3.1.1 thru 3.1.1d.)

(Syntax) The /AT option causes identifiers to be written in upper case rather than title case.
(Found in versions 3.1.1 thru 3.1.1d.)

(Syntax) Protected types and entry bodies pretty print with incorrect indentation.
(Found in versions 3.1.1 thru 3.1.1d.)

(Windows only) If any directory in the path of a project is a long file name, or contains multiple dots or any spaces, the compiler, linker, assembler, and project manager may intermittently fail to work. This happens because Windows sometimes returns the short name in GetCurrentDirectory and sometimes the long name, confusing the project manager which expects names to be the same for each run. This problem prevents installing Janus/Ada 3.1.1 into a path with a long name, such as "Program Files", on Windows NT/2000/XP. (The problem can occur, but much less frequently, on Windows 95/98/ME).
(Found in versions 3.1.1 thru 3.1.1d.)

If the first declaration of a visible child's private part references the full view of a private type in the parent, errors occur.
(Found in versions 3.1.1 thru 3.1.1d.)

If a Component_Size clause is used to set an array to an unnatural (but still byte-aligned) size, bad code is generated.
(Found in versions 3.1.1 thru 3.1.1d.)

If a discrete subtype is declared in a generic specification, and the bounds include an attribute of a formal type, then uses of the subtype from an instance may use the wrong bounds.
(Found in versions 3.1.1 thru 3.1.1d.)

The sets in Ada.Strings.Maps.Constants are missing various Latin-1 letters (the ASCII portions are correct). As a workaround, use the similar functions in Ada.Characters.Handling, or the similar sets in Ada.Strings.Wide_Maps.Constants (except for Upper_Set, which inexplicably included lower case letters).
(Found in versions 3.1.1 thru 3.1.1d.)

If a type is derived from a private type declared in the grandparent unit, and the parent unit have no private part, overriding does not work properly. The wrong routines may be called, or link errors may occur (if the grandparent has abstract routines). Work around the problem by adding a dummy private part to the parent unit.
(Found in versions 3.1.1 thru 3.1.1d.)

If a package P.C is withed in some unit that is withed (but is not withed itself) in a unit U, and some child of the parent P is withed by U, P.C may be visible in U, meaning that references to it would not be detected as errors.
(Found in versions 3.1.1 thru 3.1.1d.)

The Valid attribute can give incorrect results if the prefix contains entities with multiple definitions. (One example is if a record component C occurs in more than one record definition; the properties of any of the components named C might be used.)
(Found in versions 3.1.1 thru 3.1.1d.)

If a named subtype is created for a classwide type (that is, subtype Sub is T'Class), the type is considered specific in various legality checks (including those checking for the legality of the profile of a primitive subprogram of a tagged type); this usually causes bogus error messages.
(Found in versions 3.1.1 thru 3.1.1d.)

If a type includes a component of Unbounded_String, and the predefined equality is used for the type, it will always return False unless the same object is compared to itself. The value of the component does not matter. More generally, any private untagged type with a user-defined "=" whose full type is tagged will use the predefined rather than primitive equality.
(Found in versions 3.1.1 thru 3.1.1d.)

If the PATH environment variable has more than 1023 characters, the entire PATH is ignored. This will have various effects: the most obvious is that the compiler will not run from other than its installation directory. This problem also will affect any program compiled with Janus/Ada that Opens files using the PATH.
(Found in versions 3.1.1 thru 3.1.1d.)