Developer's Topics

About this book

Floating point operations
        IEEE arithmetic
                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
        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
        Functions with varying arguments
        Promotions: unsigned vs. value preserving
                Compilation behavior
                First example: using a cast
                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
                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
                The setlocale() function
                Changed functions
                New functions
        Grouping and evaluation in expressions
                The Kernighan and Ritchie C rearrangement license
                The ANSI C rules
                Parentheses grouping and evaluation
                The ``as if'' rule
        Incomplete types
                Completing incomplete types
        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
                Physical and virtual addresses
                Target machine
        File header
                Magic numbers
                File header declaration
        Optional header information
                Standard UNIX system a.out header
                Optional header declaration
        Section headers
                Section header declaration
                .bss section header
        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
                Tag names
                End of structures
                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
        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
        Using asm macros
                        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
                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
        The installation tools
        The package information files
                        The description lines
                        The command lines
        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
                        pkginfo file
                        prototype file
                        request script
                2. Device driver installation
                3. Create an installation database
                        pkginfo file
                        prototype file
                        space file
                        Installation class action script (i.admin)
                        Removal class action script (r.cfgdata)
                4. Define package compatibilities and dependencies
                        pkginfo file
                        copyright file
                        compver file
                        depend file
                5a. Modify an existing file using the sed class
                        pkginfo file
                        prototype file
                        sed script (/home/mypkg/inittab.sed)
                        postinstall script
                5b. Modify an existing file using a class action script
                        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
                        pkginfo file
                        prototype file
                        build script (/home/case5c/
                6. Modify crontab files during installation
                        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
                        setinfo file
                        prototype file
                        preinstall script file
                        request script file
                7b. Split one set into two
                        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

        SCO resources