Guide to Software Development Kits on Xinuos Systems
C and C++
Compilers and ABIs
Which Compilers to Choose?
UnixWare OpenServer Development Kit, Open UNIX Development Kit
OpenServer Development System
Binary Compatibility Modules and Runtime Library Packages
Still Not Sure?
I want to develop an application for a Xinuos platform or port an
existing application to a Xinuos platform. What development system
should I use?
A good question, and we're glad you're interested in building applications
The answer can sometimes get a little complicated.
Xinuos has several different
operating system product lines:
- UnixWare 7 and Open UNIX 8
- OpenServer 5
and several different development systems
packages that can be used on those operating systems. But this guide
will help you
figure out what is the right one to use.
To begin with, what language(s) are you developing in?
If you are developing in Java, the answer is simple. Use the
Java 2 Standard Edition, Software Development Kit for either
UnixWare 7, OpenServer 5, or OpenServer 6).
It's free, and if the version you want isn't already
pre-installed on your system,
it can be downloaded
from our web site.
Of course, if your application is 100% Java and already exists on another
platform, you may well not need to modify or port it at all for Xinuos; just
take the bytecodes and move them onto a Xinuos machine and run them.
Most current Xinuos operating systems come with a Java 2 Standard Edition runtime environment
pre-installed on them.
There are multiple choices of C and C++ compilers for many of Xinuos's
operating system platforms.
The following chart shows what C/C++
development kits are available on what Xinuos
operating system platforms,
and what ABI each development kit's compiler
generates and supports.
An ABI (application binary interface) is the binary layout of structures,
stack frames, register assignments, etc. that a compiler
generates, as well as the
compiled representation of system header file constants, function
calls, and directory locations.
ABIs are a function of the underlying machine architecture,
the operating system, and the compiler.
Within a single process it is usually not possible to mix object files
compiled with different ABIs, meaning you cannot link together
.so files that
were generated with different ABIs.
||Open UNIX 8
|Open UNIX Development Kit [OUDK]
|UnixWare OpenServer Development Kit [UDK]
|OpenServer Development System
|ABI key: || |
| U ||UnixWare/SVID i386 ABI |
| O ||OpenServer i386 ABI |
*UnixWare ABI programs can run on OpenServer 5 when the
OSRcompat compatibility package is installed.
The above ABIs refer to what is generated for the C programming language.
For C++, every compiler has a different ABI; you can never combine
the object code from two different C++ compilers.
The following sections will describe the different C and C++ compilers
available on Xinuos platforms, the advantages and limitations of
each of them, and how you obtain them.
GCC is the
GNU Compiler Collection
set of compilers and tools such as gcc and g++.
These are well-known, high-quality, open source tools that are heavily
used on many platforms.
As you can see from the chart above, the GNU GCC compilers are the one
choice that is available on all SCO platforms.
If you use GCC on other platforms, you'll experience no learning
curve in using it on a SCO platform.
If your application has been built with
GCC on other platforms, it will be quickest to port if you use GCC on
a SCO platform.
The C++ compiler in GCC implements many of the new C++ language and library
features from the 1998 ANSI/ISO C++ standard.
GCC is free.
The GCC compilers
are idiosyncratic in language interpretation, and you must be careful
if you want source code built with them to be portable to non-GCC compilers.
The C compiler in GCC only implements a few of the new C language and
library features from the 1999 ANSI/ISO C standard.
Debugging with multi-threaded and multi-process applications can be problematic.
Performance of generated code
is generally not as good as with the other SCO compilers discussed here,
although only very performance-sensitive applications will notice the
Using GCC to build UnixWare 7 or OpenServer 5
device drivers is possible but not recommended.
GCC cannot be used to build JNI native code on OpenServer 5,
and it cannot be used to build JNI Invocation native code on UnixWare 7.
On SCO OpenLinux and UnixWare 7 with LKP,
GCC is available as part of the rpm packages contained on the distribution.
On UnixWare 7, the official and best GCC version may be
found in the Open Source Tool Kit at
On SCO OpenServer 5, GCC may be found in the Skunkware collection at
http://www.sco.com/skunkware/ in the development tools area.
As of SCO OpenServer Release 5.0.7, an official version of GCC will be included
as part of the operating system.
SCO provides the
UnixWare and OpenServer Development Kit (UDK, sometimes also referred
to as UODK) for UnixWare 7.
(During the Open UNIX 8 period of this product, this was known as the
Open UNIX 8 Development Kit, or OUDK.
This was very similar to the UDK except that it could not be used on or for OpenServer 5.)
As suggested by its full name, the UDK also has to ability to be installed
and used on OpenServer 5. In order for a UDK-built application to execute
on OpenServer, the
OSRcompat Binary Compatibility Module
package must be installed on both development
and application deployment systems.
This is the choice if you want the generated code of your applications to have
the best performance,
especially on Pentium Pro, Pentium II, and subsequent IA-32 machines;
performance is usually superior to either GCC
or the OpenServer Development System.
The UDK C and C++ compilers support almost
all of the language and library features in the 1999 C and 1998 C++
On OpenServer 5,
you must use the UDK compiler if you are writing Java
native code (JNI).
The UDK debugger is generally the strongest debugger of all these choices.
The UDK/OUDK should be used if you are
writing an UnixWare 7 or Open UNIX 8 device driver.
The UDK cannot be used for OpenServer device drivers.
The UDK cannot be used on OpenServer
that are not common to both OpenServer and UnixWare 7.
Most significantly, the UDK cannot be used on OpenServer if you need to
link against existing third-party object files or libraries that were
built with the OpenServer compiler.
The UDK and OUDK are licensed products from SCO;
discounts are available if you join the
SCO Developer Network.
The UDK is available as part of the UnixWare 7 media kit,
and can also be installed on Open UNIX 8 and the older UnixWare 7.1.1.
SCO OpenServer Development System is the development
system specifically designed for use with OpenServer; it is sometimes
referred to as the "native" OpenServer development system.
This is the best development system to use if you are
writing an OpenServer 5 device driver.
It also provides the best integration with OpenServer
system headers and system libraries, and with existing third-party objects
and libraries. It is the compiler to use when generating older object
These compilers do not produce code specifically optimized
for Pentium Pro, Pentium II, or later IA-32 architectures.
The C compiler represents the 1990 level of the language and does not
include any of the new language or library features of the
1999 ANSI/ISO C standard.
The C++ compiler represents
the 1992 level of the language and does not include
any of the new language
or library features of the 1998 ANSI/ISO C++ standard.
of C++ is weak. These compilers lack the 64-bit long long integer type
and have limited flexibility in incorporating inline assembly code.
Java JNI native code cannot be built with these compilers.
No enhancements have been made to these compilers in a number of years
and none are planned.
This is a licensed product available from the OpenServer media kit;
discounts are available if you join the
SCO Developer Network.
It is important to avoid confusion between this and the UnixWare and
OpenServer Development Kit (UDK), since both are included in the
OpenServer 5 media kit.
Using one when the other is required will always lead to failure!
Here are a couple of cases where you may need to install an additional
package to enable your development system of choice.
In order for either Java applications or for UDK-built applications to
run on OpenServer 5, the
appropriate Binary Compatibility Module (package OSRcompat) must be
installed on the OpenServer system.
The Binary Compatibility Module is free and you may redistribute it
with your application.
The latest version of the Binary Compatibility Module for OpenServer 5
is available from the UnixWare 7 media kit and also from the
SCO download site.
In order for some UDK-built applications
to run on older UnixWare 7 systems, the UDK runtime libraries
must be installed on the UnixWare 7 system.
These libraries are free and you may redistribute them with your
application. The libraries are available from the UnixWare 7 media kit.
Thanks for all this information, but I'm still a bit confused about
which C and C++ compilers I should be using.
OK, let's look at it from a different angle. What operating system are
you developing on or for?
If it's UnixWare 7, you have two choices, GCC or
the UDK. Most of the time this is a matter of personal preference;
both are good toolsets. If you are interfacing at the object code
level with an existing application, use the compiler that was used to
build that. If you are writing device drivers or a certain kind
of Java JNI native code, UDK is the better choice. If you are
building open source code, GCC is often the path of least resistance.
If it's OpenServer 5, then you have three choices, and this is where
people tend to experience the most uncertainty. But your circumstances
will often narrow your choices down:
If you are writing
device drivers, use the OpenServer 5 Development System.
If you are generating COFF, use the OpenServer 5 Development System.
If you are writing Java JNI native code, use the UDK.
If you linking against legacy or third-party libraries, don't use the UDK.
If you are using an API that doesn't exist in UnixWare, don't use the UDK.
If you are writing in C++, avoid the OpenServer 5 Development System.
If you are building open source code, GCC usually works best.
If none of these considerations apply, then the decision is often
just a matter of personal preference.
if you are writing Java native code to interface to a third-party
library, you have a problem! Split your native code into a separate
process and communicate via a socket.
Languages other than Java, C, and C++,
such as Fortran, COBOL, and Ada, as well as fourth-generation
languages associated with databases and scripting languages, aren't
discussed here. Development tools for these languages are provided by
third-party vendors for SCO.
Also there may be open source solutions that you can use,
such as the GNU g77 Fortran compiler or the
GNU-based GNAT Ada 95 compiler.
There are some older SCO operating systems that pre-date OpenServer
and UnixWare 7, such as UnixWare 2, SCO UNIX, and Xenix, that are
still in use.
Development systems for these are not covered here,
but you can find out about some of them in the
These older operating systems are no longer supported by SCO,
and we recommend that you upgrade your platform and your development
tools to currently supported SCO products if possible.
So that's the whole story?
Well, it's the introduction. Additional material about each of the
development systems can be found by following the links shown above.
Also, consult the appropriate SCO product documentation, all of
which is based at
The Usenet newsgroups
are also a good place to read about these development systems and to ask
questions about their use.
We hope you enjoy your experience in developing on SCO platforms!