DOC HOME
SITE MAP
MAN PAGES
GNU INFO
SEARCH
PRINT BOOK
Developer's Topics
About this book
Floating point operations
IEEE arithmetic
Single-precision
Double-precision
Extended-precision
Normalized numbers
Denormalized numbers
Maximum and minimum representable floating point values
Special-case values
NaNs and infinities
Rounding control
Exceptions, sticky bits, and trap bits
Single-precision floating point operations
Double-extended-precision
IEEE requirements
Conversion of floating point formats to integer
Square root
Compares and unordered condition
NaNs and infinities in input/output
Complying with standard C
Mixing old and new style functions
Writing new code
Updating existing code
Mixing considerations
Examples
Functions with varying arguments
Example
Promotions: unsigned vs. value preserving
Background
Compilation behavior
First example: using a cast
Bit-fields
Second example: result is the same
Integral constants
Third example: integral constants
Tokenization and preprocessing
ANSI C translation phases
Old C translation phases
Logical source lines
Macro replacement
Stringizing
Token pasting
Using const and volatile
Types for lvalues
Type qualifiers in derived types
Using const to read character values
Examples of const usage
When to use volatile
Examples of volatile usage
Multibyte characters and wide characters
``Asianization'' means multibyte characters
Encoding variations
Wide characters
Conversion functions
C language features
Standard headers and reserved names
Balancing process
Standard headers
Names reserved for implementation use
Names reserved for expansion
Names safe to use
Internationalization
Locales
The setlocale() function
Changed functions
New functions
Grouping and evaluation in expressions
Definitions
The Kernighan and Ritchie C rearrangement license
The ANSI C rules
Parentheses grouping and evaluation
The ``as if'' rule
Incomplete types
Types
Completing incomplete types
Declarations
Expressions
Justification
Examples
Compatible and composite types
Multiple declarations
Separate compilation compatibility
Single compilation compatibility
Compatible pointer types
Compatible array types
Compatible function types
Special cases
Composite type
Constructing and using message catalogs
Creating a message catalog
Code example using a message catalog
Combining the message catalog and the application program
Running the application program
Using trusted facilities
Using protected subsystems
Guidelines for using trusted facilities
Programming examples
subsys.c example
prwarn.c example
loge.c example
Using the event manager API
Operation and semantics overview
Event generating hardware
Using the event queue
Event manager calls
A sample program
Job control under ksh
Common Object File Format (COFF)
Definitions and conventions
Sections
Physical and virtual addresses
Target machine
File header
Magic numbers
Flags
File header declaration
Optional header information
Standard UNIX system
a.out
header
Optional header declaration
Section headers
Flags
Section header declaration
.bss
section header
Sections
Relocation information
Relocation entry declaration
Line numbers
Line number declaration
Symbol table
Special symbols
Inner blocks
Symbols and functions
Symbol table entries
Symbol names
Storage classes
Storage classes for special symbols
Symbol value field
Section number field
Section numbers and storage classes
Type entry
Type entries and storage classes
Structure for symbol table entries
Auxiliary table entries
File names
Sections
Tag names
End of structures
Functions
Arrays
End of blocks and functions
Beginning of blocks and functions
Names related to structures, unions, and enumerations
Auxiliary entry declaration
String table
Access routines
ELF object files
File format
Data representation
Program linking
ELF header
ELF identification
ELF header flags
Section header
Special sections
String table
Symbol table
Symbol values
Relocation
Program execution
Program header
Base address
Segment permissions
Segment contents
Note section
Program loading (processor-specific)
Program interpreter
Dynamic linker
Dynamic section
Shared object dependencies
Hash table
Initialization and termination functions
Enhanced asm facility
Definition of terms
Example
Definition
Use
Using asm macros
Definition
Storage modes
asm body
Writing asm macros
Mapfile option
Using the mapfile option
Mapfile structure and syntax
Segment declarations
Mapping directives
Size-Symbol declarations
Mapping example
Mapfile option defaults
Internal map structure
Error messages
Warnings
Fatal errors
Integrating applications into the Desktop
What you should know
Graphical interface standards and libraries
Backward compatibility
Putting your icon on the Desktop
Create your icon pixmaps
Define icon triggers
Starting your application with the activate trigger
Starting your application with the drop trigger
Popping up a menu with the menu trigger
Install icon files
Removing pixmaps, object files, and application rules
Making applications user-installable
Animating icons
Localizing icon labels and messages
Creating icons for user data files
Adapting to display resolution at run time
Supporting the Desktop color selector
Defining display-dependent colors
Communicating with the session manager
Custom Distribution Mastering Toolkit
Creating custom-installable software distributions
About Software Storage Objects (SSO)
Component identifiers
Advantages of using SSOs
Planning your product structure
Product structure
Determining SSO file attributes
Setting up the distribution tree
Setting up the CDMT environment
Creating CDMT input files
Creating and populating the SSO tree
Creating custom-installable SSO archives
Advanced software installations
About component scripts
Software management phases
LOAD and UNLOAD phases
ATTACH and UNATTACH phases
REGISTER and UNREGISTER phases
CONFIGURE and UNCONFIGURE phases
EXPORT and UNEXPORT phases
Component script guidelines
Component script structure
Component script environment variables
Creating software upgrades
Specifying the upgrade versions
Specifying packages to upgrade
About the SSO Path Mapping API
Using the SSO Path Mapping API
C and C++ programs API
Tcl scripts API
Bourne and Korn shell scripts API
Packaging your software applications
Contents of a package
Required components
Optional package information files
Optional installation scripts
The structural life cycle of a package
The package creation tools
pkgmk
pkgtrans
pkgproto
The installation tools
The package information files
pkginfo
prototype
The description lines
The command lines
compver
copyright
depend
space
pkgmap
The installation scripts
Script processing
Installation parameters
Getting package information for a script
Exit codes for scripts
The request script
Request script naming conventions
Request script usage rules
Soliciting user input in request scripts
The class action script
Class action script naming conventions
Class action script usage rules
Installation of classes
Removal of classes
The special system classes
The sed class script
The awk class script
The build class script
The procedure script
Naming conventions for procedure scripts
Procedure script usage rules
Basic steps of packaging
1. Assigning a package abbreviation
2. Defining a package instance
Identifying a package instance
Accessing the instance identifier in your scripts
3. Placing objects into classes
4. Making package objects relocatable
Defining collectively relocatable objects
Defining individually relocatable objects
5. Writing your installation scripts
Reserving additional space on the installation machine
6. Defining package dependencies
7. Writing a copyright message
8. Creating the pkginfo file
9. Creating the prototype file
Creating the file using pkgproto
10. Distributing packages over multiple volumes
11. Creating a package with pkgmk
Package file compression
Creating a package instance
Helping pkgmk locate package contents
12. Creating a package with pkgtrans
Creating a datastream package
Translating a package instance
Set packaging
Set installation
Set removal
Set information display
The setsize file
The setsizecvt command
Quick reference to packaging procedures
Case studies of package installation
1. Selective installation
Techniques
Approach
pkginfo file
prototype file
request script
2. Device driver installation
3. Create an installation database
Techniques
Approach
pkginfo file
prototype file
space file
Installation class action script (i.admin)
Removal class action script (r.cfgdata)
4. Define package compatibilities and dependencies
Techniques
Approach
pkginfo file
copyright file
compver file
depend file
5a. Modify an existing file using the sed class
Techniques
Approach
pkginfo file
prototype file
sed script (/home/mypkg/inittab.sed)
postinstall script
5b. Modify an existing file using a class action script
Techniques
Approach
pkginfo file
prototype file
Installation class action script (i.inittab)
Removal class action script (r.inittab)
inittab file
5c. Modify an existing file using the build class
Techniques
Approach
pkginfo file
prototype file
build script (/home/case5c/inittab.build)
6. Modify crontab files during installation
Techniques
Approach
pkginfo file
prototype file
Installation class action script (i.cron)
Removal class action script (r.cron)
root crontab file (delivered with package)
sys crontab file (delivered with package)
7a. Create a Set Installation Package
Techniques
Approach
setinfo file
prototype file
preinstall script file
request script file
7b. Split one set into two
Techniques
Approach
Original setinfo file
New setinfo file for SIP 1
New setinfo file for SIP 2
Original prototype file
New prototype file for SIP 1
New prototype file for SIP 2
Bibliography
Books
Periodicals
SCO resources
Index