Software development tools

Programming with the UNIX system shell
        Shell command language
                Filename generation
                        Matching all characters with the asterisk
                        Matching one character with the question mark
                        Matching one of a set with brackets
                Special characters
                        Running a command in background with the ampersand
                        Executing commands sequentially with the semicolon
                        Turning off special meanings with the backslash
                        Turning off special meanings with quotation marks
                        Turning off the meaning of a space with quotes
                Input and output redirection
                        Redirecting input with the < sign
                        Redirecting output with the > sign
                        Appending output to an existing file with the >> symbol
                        Useful applications of output redirection
                        Combining background mode and output redirection
                        Redirecting output to a command with the pipe
                        A pipeline using the cut and date commands
                        Substituting output for an argument
                Executing, stopping and restarting processes
                        Running commands at a later time with the batch and at commands
                        Executing processes at regular intervals
                        Obtaining the status of running processes
                        Terminating active processes
                        Restarting a stopped process
                        Using the nohup command
        Command language exercises
        Shell programming
                Shell programs
                        Executing a shell program
                        Creating a bin directory for executable files
                        Warnings about naming shell programs
                        Positional parameters
                        Special parameters
                        Named variables
                        Assigning a value to a variable
                Shell programming constructs
                        Here documents
                        Using ed in a shell program
                        Return codes
                        Loop constructs: for and while
                        The shell's garbage can: /dev/null
                        Conditional constructs: if and case
                        Unconditional control statements: break and continue
                        Defining a function
                        Executing a function
                Debugging programs
        Modifying your login environment
                Adding commands to your .profile
                Setting terminal options
                Using shell variables
        Shell programming exercises
        Summary of shell command language
                The vocabulary of shell command language
                        Special characters in the shell
                        Redirecting input and output
                        Executing and terminating processes
                        Making a file accessible to the shell
                        Variables used in the system
                Shell programming constructs
                        Here document
                        For loop
                        While loop
                        Case construction
                        Break and continue statements

Programming with awk
        Basic awk
                Program structure
                Formatted printing
                Simple patterns
                Simple actions
                        Built-in variables
                        User-defined variables
                A handful of useful one-liners
                Error messages
                BEGIN and END
                Relational expressions
                Extended regular expressions
                Combinations of patterns
                Pattern ranges
                Built-in variables
                Strings and string functions
                Field variables
                Number or string?
                Control flow statements
                User-defined functions
                Some lexical conventions
                The print statement
                Output separators
                The printf statement
                Output to files
                Output to pipes
                Files and pipes
                Input separators
                Multi-line records
                The getline function
                Command-line arguments
        Using awk with other commands and the shell
                The system function
                Cooperation with the shell
        Example applications
                Generating reports
                Word frequencies
                Random choice
                History facility
                Form-letter generation
        awk summary
                Command line
                Control flow statements
                String functions
                Arithmetic functions
                Operators (increasing precedence)
                Regular expressions (increasing precedence)
                Built-in variables
                Initialization, comparison, and type coercion

Lexical analysis with lex
        Generating a lexical analyzer program
        Writing lex source
                The fundamentals of lex rules
                        Regular expressions
                Advanced lex usage
                        Some special features
                        lex routines
                        Start conditions
                        User routines
        Using lex with yacc
        Summary of source format

Parsing with yacc
        Basic specifications
                Lexical analysis
        Parser operation
        Ambiguity and conflicts
        Error handling
        The yacc environment
        Hints for preparing specifications
                Input style
                Left recursion
                Lexical tie-ins
                Reserved words
        Advanced topics
                Simulating error and accept in actions
                Accessing values in enclosing rules
                Support for arbitrary value types
                yacc input syntax
        A simple example
        An advanced example

Managing file interactions with make
        Basic features
                Parallel make
        Description files and substitutions
                Continuation lines
                Macro definitions
                General form
                Dependency information
                Executable commands
                Extensions of $*, $@, and $<
                Output translations
                Recursive makefiles
                Suffixes and transformation rules
                Implicit rules
                Archive libraries
                Source code control system file names
                The null suffix
                Included files
                SCCS makefiles
                Dynamic dependency parameters
        The make command
        Environment variables
        Suggestions and warnings
        Internal rules

Tracking versions with SCCS
        Basic usage
                Creating an SCCS file with admin
                Retrieving a file with get
                Recording changes with delta
                More on get
                The help command
        Delta numbering
        SCCS command conventions
                x.files and z.files
                Error messages
        SCCS commands
                        ID keywords
                        Retrieval of different versions
                        Updating source
                        Undoing a get -e
                        Additional get options
                        Concurrent edits of different SID
                        Concurrent edits of same SID
                        Keyletters that affect output
                        Creation of SCCS files
                        Inserting commentary for the initial delta
                        Initialization and modification of SCCS file parameters
        SCCS files

Packaging your software applications
        Contents of a package
                Required components
                Optional package information files
                Optional installation scripts
        Quick steps to packaging
        Quick steps to network installation
                Network installation from the command line
                Network installation from the graphical interface
        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 manually
                        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

Documenting your application