• source code
• object code

• Pro: Can modify to suit new context
• Con: MUST modify to suit new context

• Pro: No compilation required; just header file and lib
• Con: No ability to change functionality; Arch-specific

• a collection of object files, used for some purpose
  • e.g. math libraries, graphics libraries, etc.

• The rules of marshaling (covered in last lecture) ensure that the compiler knows how to call the object code contained in the library
  • Remember that object code is architecture-specific

• The .o files are stored in the archive such that they can be extracted at a later time
• This allows a linker to be smart about using the object code in libraries
  • i.e. only those functions used are placed in the linked executable

• main.h

  int subject();
  int verb();

• main.c

  #include “main.h”
  main(){
      subject();
      verb();
  }

• subject1.c

  int subject() {
      printf("Jane ");
  }

• subject2.c

  int subject() {
      printf("Ken ");
  }

• verb1.c

  int verb() {
      printf("codes.");
  }

• verb2.c

  int verb() {
      printf("debugs.");
  }

• cc -c subject1.c
• cc -c subject2.c
• cc -c verb1.c
• cc -c verb2.c

• ar -r libLec23-1.a subject1.o verb1.o
• ar -r libLec23-2.a subject2.o verb2.o

• These files are Unix libraries containing the generated .o files
• You can check the contents of these files in a number of ways:
  • ar -t libLec23-1.a
    • ...
    • subject1.o
    • verb1.o
  • ar -t libLec23-2.a
    • …
    • subject2.o
    • verb2.o
  • strings libLec23-1.a
    • …
    • Jane
    • codes.
    • …
  • strings libLec23-2.a
    • …
    • Ken
    • debugs.
    • …
• Third, compile main
  • cc -c main.c
• Fourth, link executable twice, one for each library
  • cc main.o -o jane -I. -L. -lLec23-1
  • cc main.o -o ken -I. -L. -lLec23-2
• Fifth, run programs
  • jane → "Jane codes."
  • ken → "Ken debugs."

• The ar command works only with .o files
• The command flags and behavior of ar and tar are often quite different

• ar (d|q|r|t) archive [files…]
  • r – Replace
    • replace .o files in the archive with the specified files
  • q – quick append
    • append specified files to archive
  • d – delete
    • delete specified files from archive
  • t – table of contents
    • print the archive's table of contents
• Note: This is just a sample of ar’s functionality; see the ar man page for more details

• the location of the library (.a)
• the location of its include file (.h)
• its name

• -I Directory for include files (uppercase i)
• -L Directory for Libraries
• -l Name of library (lowercase L)

• Any source file that wants to make use of a library, must include its header file
• The -I flag can be used to specify a directory that contains relevant header files
• A single compile command can include multiple -I flags
• When a compiler encounters a “#include” statement, it looks in the current directory as well as any directories specified by the -I flag(s)

• Any source file that wants to make use of a library, must include its .a file
• The -L flag can be used to specify a directory that contains relevant library files
• A single compile command can include multiple -L flags
• When a linker needs to locate a library (in order to link it into an executable), the linker will look in the current directory as well as any directories specified by the -L flag(s)

• The -l flag (lowercase L) specifies the name of a Unix library
• The compiler assumes that all libraries begin with “lib” and end in “.a”
• As such, you write “-lmath” rather than“-llibmath.a”
  • The latter would cause the compiler to look for a file called liblibmath.a.a!
• You saw this in action in our previous example when we linked the jane executable with the following command
  • cc main.o -o jane -I. -L. -lLec23-1
  • This command explicitly defined the current directory as a place to find .h and .a files
  • The -l flag specified the library name Lec23-1 which caused the compiler to use the libLec23-1.a library

• “cc main.o -o jane -I. -L. -lLec23-1 -lLec23-2” produces "Jane codes."
• “cc main.o -o jane -I. -L. -lLec23-2 -lLec23-1” produces "Ken debugs."
• The object code in the second library is ignored because the linker found matches for the functions subject() and verb() in the first library

• To address this, scripting languages will typically allow developers to extend their capabilities via shared libraries
• A developer writes a compute-intensive function in C, compiles it, places the .o file in a library and then includes the library into the interpreter
  • When the user invokes the function within a script, the C-based code is executed for maximum performance

• This example is taken from the 3rd edition of the book Python Essential Reference by David M. Beazley

/* file: spam.c */

/* Compute the greatest common divisor of positive integers x and y */
#include <stdio.h>

int gcd(int x, int y) {
    int g;
    g = y;
    while (x > 0) {
        g = x;
        x = y % x;
        y = g;
    }
    return g;
}

/* Print some data */
void print_data(char *name, char *email, char *phone) {
    printf("Name   : %s\n", name);
    printf("Email  : %s\n", email);
    printf("Phone  : %s\n", phone);
}

/* file: spamwrapper.c */
/* Defines a "spam" Python extension module */

/* Include the Python C API */
#include "Python.h"

/* External declarations to functions in spam.c */
extern int gcd(int,int);
extern void print_data(char *, char *, char *);

/* Wrapper for the gcd() function */
PyObject *spam_gcd(PyObject *self, PyObject *args) {
    int x, y, g;
    /* Get Python arguments */
    if (!PyArg_ParseTuple(args, "ii", &x, &y)) {
        return NULL;
    }
    /* Call the C function */
    g = gcd(x,y);
    return Py_BuildValue("i", g);
}

/* Wrapper for the print_data() function */
PyObject *spam_print_data(PyObject *self, PyObject *args, PyObject *kwargs) {
    char *name = "None";
    char *email = "None";
    char *phone = "None";
    static char *argnames[] = {"name","email","phone",NULL};

    /* Get Python arguments */
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|sss", argnames, &name, &email, &phone)) {
        return NULL;
    }

    /* Call the C function */
    print_data(name,email,phone);
    return Py_BuildValue(""); /* returns Python's None data type */
}

/* Method table mapping names to wrappers */
static PyMethodDef spammethods[] = {
    {"gcd", spam_gcd, METH_VARARGS},
    {"print_data", spam_print_data, METH_VARARGS | METH_KEYWORDS },
    {NULL, NULL}
};

/* Module initialization function */
void initspam() {
    Py_InitModule("spam", spammethods);
}

• Python is told that we are creating a module called spam that contains two methods gcd and print_data.
• In order for Python to call those methods, they each have the same basic signature: accepting two or three pointers to PyObjects and returning a pointer to a PyObject.
• Inside each function, the code first parses the input being passed from Python and converts it to C data types. Then the C functions are called and then any return values are converted into Python form before being passed back. The conversions are all handled by routines supplied by Python's C API.

# setup.py
from distutils.core import setup, Extension

setup(name="spam", version="1.0",
      ext_modules=[Extension("spam", ["spam.c", "spamwrapper.c"])])

python setup.py build

sudo python setup.py install

• Invoke Python: python
• Import Module: import spam
• Invoke Function: spam.gcd(63, 56)
• Invoke Function: spam.print_data(email="kena@cs.colorado.edu", name="Ken")