Outline

• make
• gdb
• Quiz
• More Syntax

Introduction

• Before the weekend, we had given a very quick introduction to the C programming language.
• We begin today by looking at two command-line tools useful for building larger scale applications in C: make and gdb.
• We then resume our discussion of syntax.

make

• make is a build utility -- a utility to compile and link large software projects -- developed by Stuart Feldman at Bell Labs in 1977.
• It heavily influenced many later build tools such as ant, and it also has been ported to many platforms. For example, Microsoft OS's use nmake.
• make is very similar in some ways to Prolog, and can be viewed as perhaps the most commonly used declarative language.
• Typically, make is run from the command-line with a line like:

  make target
  

  The make utility would then search the current directory for a file called Makefile and then tries to satisfy the target goal.

Makefile Structure

A Makefile consists of rules of the form:

target1: depends_on1 depends_on2 ...
<tab>command1
<tab>command2
...
<blankline>
target2: depends_on1 depends_on2 ... #etc
# is used for a single-line comment

Notice the use of tabs is important!

Some example targets

myprog: myprog.o
	cc -o $@ $<
 
myprog.o: myprog.c
	cc -c -o $@ $<
# $@ refers to the target $< refers to the first dependency
clean:
	rm -f myprog myprog.o

More on Makefiles

You can declare variables in a Makefile using the format varname = value like:

   CC = gcc
   SUBDIRS = io linkedlist

These variables could then be used:

all : $(SUBDIRS)
   $(CC) historylesson.c -o historylesson

An example of a multi-line make rule might be something like:

io :
   @echo "Making io..."
   cd io
   make all

• Make uses the file modification dates to figure out what needs to be re-compiled.
• If the timestamp of the target is less that any dependency then the target is made; typically, it only performs incremental compiles.
• There are various shortcuts you can use for rules that I won't go into very much. For example, if one had the target hello.o . It would match the rule:

  %.o : %.c
  

gdb

• gdb is the GNU command line debugging tool.
• It can be used to debug C programs, debug assembly programs, or debug other targets of the GNU compiler suite.
• Sometimes debuggers in IDEs actually implement the debugging functionality by mapping the GUI interface commands down to the debugger commands.
• To use the debugger, you need to compile your programs in a special way containing additional details for use by the debugger.
• To do this you could type something like:

  gcc -g myprog.c -o myprog

  where -g is the debugging flag.
• To run the debugger you would then type:

  gdb myprog
  

  This would then give you the gdb prompt: (gdb)
• Inside gdb, perhaps the most useful command is "help". This lists out the categories of available commands. If you type "help category_name" you get the commands within that category.

Quiz

Which of the following statements is true?

1. A symbol table could be used to check if a variable is used before it is declared.
2. Abstract syntax tree is the name of the assembly language generated by a compiler.
3. C by default uses a garbage collector to automatically free memory.

Some useful gdb commands

• list -- lists the source code of your program with line numbers
• break line_num_or_func_name -- sets a breakpoint at the given line number or function name.
• clear line_num_or_func_name -- deletes a breakpoint set at the given line number or function name.
• run -- executes the program (uses either current arg values or you can set) until the next breakpoint.
• continue -- continues running the program from the current place it stopped to the next breakpoint
• print expression -- prints the value of expression (for instance, expression might be a variable name) given its value at the current point in program execution.
• step -- executes the program till the end of the next source line. step N executes N steps.
• next -- like step; however, will treat function calls as one line rather than stepping into them.
• set -- can be used to control the gdb environment. it can also be used to set program variables to given values.
• backtrace -- prints the contents of the runtime stack.

Back to Syntax

• Before talking about C, we were talking about the syntax of programming languages.
• We talked about regular expressions as a method that programming language designers can use to specify what constitutes a legal keyword, identifier, symbol, or constants in the language they are designing.
• A regular expression is one of the following:
  1. A character
  2. The empty string, denoted `epsilon`.
  3. Two regular expressions next to each other, meaning any string generated by the first one followed by (concatenated with) any string generated by the second one.
  4. Two regular expressions separated by a vertical bar ( | ), meaning any string generated by the first one or any string generated by the second one
  5. A regular expression followed by a Kleene star (`star`), meaning the concatenation of zero or more strings generated by the expression in front of the star.
• We next look at algorithms for how to detect if a string matches a regular expression.
• To do this we introduce the notion of a nondeterministic finite automata.

Nondeterministic Finite Automaton

• A nondeterministic finite automaton is a 5-tuple `(Q, Sigma, delta, q_0, F)` where:
  1. `Q` is a finite set of states
  2. `Sigma` is an alphabet (for example ASCII symbols)
  3. `delta: Q times Sigma cup {epsilon} rightarrow P(Q)` is the transition function (P(Q) is the power set of Q - the set of all subsets of Q.)
  4. `q_0 in Q` is the start state
  5. `F subseteq Q` is the set of accept states.
• NFAs were proposed in a paper of Rabin and Scott in 1959. (IBM J. Research and Development. Vol. 3 Iss. 2)
• Above is a picture of an NFA that might be suitable for recognizing calculators tokens.
• Nodes in the above are states, the state labeled start corresponds to `q_0`, double circled states correspond to accept states, edges with labels correspond to the `delta` function from a given state and symbol.
• We say such a machine accepts a string `w` if there is some path in the machine's graph from the start state to an accept state where if we read off the labels along the path, we get `w`.

Any regular expression can be converted to an NFA

• The proof is by induction on the complexity (number of uses of union, `star`, or concatenation) of the regular expression. In the base case, we have regular expressions which make no use of union, `star`, or concatenation.
  1. Let `R = a` for some `a` in `Sigma`. Then the following NFA recognizes the languages contain only a:
     
  2. Let `R = epsilon`. Then the following NFA recognizes it:
     
  3. Let `R = emptyset`. Then the following NFA recognizes it:
     

Proof cont'd

Assume now the result holds for regular expressions for which the total number of uses of union, `\star`, or concatenation is at most `n`. Consider `R` a regular language of complexity `n+1`. There are three cases to consider:

1. `R` is of the form `(R_1 | R_2)` where `R_1` and `R_2` are regular expressions of complexity `leq n`. By induction let `N_1` and `N_2` be the machines for `R_1` and `R_2`. Define `N` for `R` as:
   
   Roughly, we make a new machine that has a copy of each of the two machines `N_1` and `N_2` together with a new start state for the overall machine. From this new start state we have two `epsilon` transitions: one to what had been the start state of `N_1` and one to what had been the start state of `N_2`.
2. `(R_1R_2)` where `R_1` and `R_2` are regular expressions of complexity `leq n`. By induction let `N_1` and `N_2` be the machines for `R_1` and `R_2`. Define `N` for `R` as:
   
   The idea is we make a new machine with copies of `N_1`, `N_2`. In this new machine the start state will be the start state of the copy of `N_1`. The `N_1` copy will no longer have accept states; however, we will have an `epsilon` transition from each former accept state of `N_1` to a what had been the start state of `N_2`.
3. `(R_1)^star` where `R_1` is a regular expression of complexity `leq n`. By induction let `N_1` be the machine for `R_1`. Define `N` for `R` as:
   
   That is, we make a new machine `N` which consists of a new start state that is accepting. From this, we add an `epsilon` transition to what had been the start state of a copy of `N_1`. For each accept state in this `N_1` copy, we add an `epsilon` transition back to what had been the start state of `N_1`.

From Regular Expressions to NFAs - a Second Construction

• The previous slide gives an inductive construction of an NFA from a regular expression. A more direct construction is also possible.
• Suppose we have a regular expression `R = r_1 r_2 ... r_n`, where `r_i` are the symbols in the expression.
• Our NFA will have states `R_j = r_1 ... r_j @ r_{j+1} ... r_n` for `0 <= j <= n`.
• Here `@` intuitively is supposed to represent how much of the regular expression we've matched so far.
• The start state is `R_0 = @ r_1 r_2 ... r_n` and the final state is `R_n = r_1 r_2 ... r_n @`
• Let `a` be a symbol that appears in `R` or `epsilon`. Then two states `R_j` and `R_k` are connected by edge if labeled by `a`, if assuming we were are location `j` in parsing a string matching the regular expression, we could read an `a` and end up at location `k` in parsing the regular expression.
• For example, `a @ (ba)^\star b` has an edge labeled `b` to the two states `a (b @ a)^\star b` and `a (b a)^\star b @`. The state `a @ (ba)^\star b` has an `epsilon` transition/edge to `a (b a)^\star @ b`, the state `a (ba @)^\star b` has an `epsilon` edge to `a (@ ba)^\star b`.
• One can also prove that the NFA given by the above recognizes the same strings as the original regular expression.

An Algorithm to Check if a string is accepted by an NFA

• If our NFA `M` has `n` states `Q`, and the `q_0` is our start state, Let `B` be a bit-vector of length n, a `1` in location `i` in this vector indicates that we could potentially be in state `i`, a 0 indicates we couldn't
• Given such a bit vector let `E(B)` be the algorithm:

  // compute bit vector reachable from B via epsilon transitions
  BitVector E(BitVector B) {
    BitVector oldB := new BitVector (B.length); //all zero bit vector of length n 
    BitVector eB = B;
    while (eB != oldB) {
      oldB = eB;
      for (int i = 0; i < B.length; i++) {
         BitVector tmpB = delta(i, epsilon); //states reachable from i by a single epsilon transition
         eB = BitVector.or(eB, tmpB); //bitwise OR 
      }
    }
    return eB;
  }
  

• Given the above we can check if a string `w` is recognized by `M` using the following pseudo-code:

  // here M =(Q, Sigma, delta, q_0, F)
  boolean checkInNFA(String w, NFA M)
  {
    BitVector B = new BitVector(M.Q.length); // all 0 vector
    B.setBit(0, 1); // indicate we could be in start state
    int i = 0;
    do {
        B = E(B);
        if (i == w.length) {
            if (!BitVector.allZero(BitVector.and(B, M.F)) ) {
               return true;
            }
            return false;
        }
        // w[i] is ith symbol from w
        BitVector tmpB = new BitVector(M.Q.length);
        for (int j =0; j < M.Q.length; j++) {
            if (B.isSet(i)) {
                tmpB = BitVector.or(tmpB, M.delta(i, w[i]));
            }
        }
        B = tmpB;
        i++;
    } while (i <= w.length);
    return false; //shouldn't get here
  }