1 Problems

Code Variations

• Environment management, (previously identified as common SCM problems):

  Coping with change in

  • hardware environment
  • software environment

• Can lead to need for variant code to support different configurations

The Sad Story of C/C++ Portability

• Both C and C++ existed as popular languages long before being standardized

  • Widespread variations in the “system” headers

• Even after standardization, many common functions are not standardized

  • GUIs
  • multi-threading and distributed operations
  • netowrk communcations

• Even things covered by the standard aren’t covered in enough detail

C Portability Quiz

How would you declare an integer counter capable of holding non-negative values up to one million? Up to one billion?

C Portability Quiz

How would you declare an integer counter capable of holding non-negative values up to one million? Up to one billion?

• C90 requires sizeof(short) \( \leq \) sizeof(int) \( \leq \) sizeof(long)

C Portability Quiz

How would you declare an integer counter capable of holding non-negative values up to one million? Up to one billion?

• C90 requires sizeof(short) \( \leq \) sizeof(int) \( \leq \) sizeof(long)

  • Notice that’s \( \leq \), not <

C Portability Quiz

How would you declare an integer counter capable of holding non-negative values up to one million? Up to one billion?

• C90 requires sizeof(short) \( \leq \) sizeof(int) \( \leq \) sizeof(long)

  • Notice that’s \( \leq \), not <

• A char must hold a “natural” byte (minimum addressable unit) on the machine architecture.

C Portability Quiz

How would you declare an integer counter capable of holding non-negative values up to one million? Up to one billion?

• C90 requires sizeof(short) \( \leq \) sizeof(int) \( \leq \) sizeof(long)

  • Notice that’s \( \leq \), not <

• A char must hold a “natural” byte (minimum addressable unit) on the machine architecture.

• The C99 specification added long long and set minimum sizes as

  char	8
  short	16
  int	16
  long	32
  long long	64

C++ Portability Quiz

How would you declare an integer counter capable of holding non-negative values up to one million? Up to one billion?

C++ Portability Quiz

How would you declare an integer counter capable of holding non-negative values up to one million? Up to one billion?

• The C++ standard followed C90 (not 99!) until C++11

  sizeof(short) \( \leq \) sizeof(int) \( \leq \) sizeof(long)

C++ Portability Quiz

How would you declare an integer counter capable of holding non-negative values up to one million? Up to one billion?

• The C++ standard followed C90 (not 99!) until C++11

  sizeof(short) \( \leq \) sizeof(int) \( \leq \) sizeof(long)

• C++11 adds the C99 standards

Coping With Variants in the C/C++ World

• Configuration headers used to define symbols describing selected variants, e.g.,

  config.h

  #ifndef CONFIG_STD
  #define CONFIG_STD
  
  //
  //  AlgAE Configuration file
  //    
  //  Currently recognizes  g++, version 2.7.2 for Unix and 2.8.0 for GnuWin32
  //  MS Visual C++, version 5.0
  //
  
  
  // Define this if the compiler does not support reassignment of iostream
  // buffers via the function  rdbuf(streambuf&)
  #undef __bad_rdbuf__
  
  
  #ifdef __GNUG__
    /* Compiler is gcc/g++ */
  
  
  #define MEM_INCL <mem.h>
  
  #define USING_STD
  #define STD
  #define USE_FORK
  
  #ifdef __CYGWIN32__
    /* This is the GnuWin32 port for Windows 95/NT
  #define USE_WINSOCK
  #else
    /* This is some other port of g++, probably a Unix system. */
  #endif
  
  #elif defined(_MSC_VER)
  /* compiler is Microsoft Visual C++ */
  
  #define MEM_INCL <alloc.h>
  
  #define USING_STD using namespace std;
  #define STD std::
  
  #define MEMDC
  #define __bad_rdbuf__
  #define USE_WINSOCK
  
  
  #else
  
  #pragma warning "Possible configuration error: Compiler is not recognized."
  
  #define MEM_INCL <mem.h>
  
  #endif
  
  
  #endif
  
  

• Code uses symbols defined in there

  • direct substitution, e.g.

    #include MEM
    
    

    loads <alloc.h> or <mem.h>

  • or conditionally

    #ifdef USE_WINSOCK
    #include <winsock2.h>
    #else
    #include <netinet/in.h>
    #include <sys/socket.h>
    #endif
    
    

2 AUTOCONF

Compiling Software the Unix Way

If you’ve ever installed a Unix/Linux package from a source distribution, you’ve probably gotten used to the two-step process:

./configure
make
make install

• The configure script runs a series of tests on the compilation environment, e.g.,

  • operating system
  • compiler name
  • availability of selected libraries/header files
  • availability and/or behavior of selected functions

• Produces a Makefile and a configuration header config.h based upon the test results

• Source code may use conditional compilation based on the header to select appropriate code

Generating The configure Script

A rough outline:

1. Create a configure.ac
2. Set up config.h.in (template for eventual config.h file)
3. Set up Makefile.am
4. Set up files NEWS README AUTHORS ChangeLog
5. Run autoreconf

2.1 Example

AC_INIT(cppSpreadsheet, 1.0, zeil@cs.odu.edu)
AC_PREREQ([2.68])
AM_INIT_AUTOMAKE([1.16 foreign no-define])
AC_CONFIG_HEADERS([config.h])
AC_PROG_CXX
AC_CONFIG_FILES([Makefile])
AC_OUTPUT

Alternatives

• imake for X code

Java: Abstraction

Java programs are more likely varied be altering entire classes at a time.

For example:

public abstract class OCRLauncher extends Thread {
    /**
     * Launch an OCR process to convert the input 
     * PDF into some kind of File  of OCR output.
     * 
     * @param inputPDFfile The PDF file to be converted to IDM (XML)
     * @param outputFile The raw OCR output
     * @return
     */
    public abstract boolean convertPDFtoOCR 
       (File inputPDFfile, File outputFile)
            throws Exception;

    /**
     * Convert a file of OCR output into IDM
     * 
     * @param inputOCRfile
     * 
     * @return XML (IDM) document
     */
    public abstract Document convertOCRtoIDM 
       (File inputOCRfile) throws Exception;
}

This class has distinct implementations for different OCR programs that might be installed on the running system.

Configuration via Property Files

A property file, loaded at run time, specifies which class is actually desired:

input.OCRLauncherClass=edu.odu.cs.extract.input.OCRBatchLauncher
input.OCRProgram=OCR
input.OCRBatch=Batch
input.ocr.in_dir=c:/Luratech/ocr_in
input.ocr.out_dir=c:/Luratech/ocr_out

Reflection: Dynamic Loading

And the desired class is loaded dynamically:

String OCRLauncherName 
   = p.getProperty(Properties.Names.OCR_LAUNCH_CLASS);
Class<?> ocrLauncherClass 
   = Class.forName(OCRLauncherName);
ocr = (OCRLauncher)ocrLauncherClass.newInstance();
idmDoc = ocr.convertOCRtoIDM(inputOCR);