Comp 210 Lab 8: Equality; From Scheme to C

Table of Contents

Miscellany

|- (define s (/ 1.0 6))
|- (= 1 (+ s s s s s s))
#f

Equality

Somebody broke into my apartment, stole all my furnishings, and replaced them with exact duplicates.
-- Steven Wright

The rules given in Monday's lecture show how to hand-evaluate set-bike-location!, and why it's different from set!. Here is the same explanation again.

1. When you see any make-structure, the hand-evaluation rule is to re-write it at the top level as

   (define uniqueVar^ (make-bike 5))
   

   and replace the original with uniqueVar^.
2. As always, when figuring out what (define z ...) means, we must evaluate the ... so it is a value (not placeholder). As of this week, we modify this rule: these special "hat" placeholders which correspond to structures will themselves count as values. (This is a hand-evaluation convention; Dr. Scheme itself does not treat ^ in any way special.) This new rule is the fundamental reason why structures have different properties than (say) numbers or symbols.
3. Then, when hand-evaluating (set-bike-location! uniqueVar^ 7), change the "define" line of uniqueVar^ to be

   (define uniqueVar^ (make-bike 7))
   

(define x (make-bike 5))
(define y x)
(set-bike-location! x 7)
y

(define x 5)
(define y x)
(set! x 7)
y

Another way of thinking of this whole subtlety:
set! changes a binding, nothing else; set-particle-x! doesn't change any binding (which is why uniqueVar^ is used), though it does reach inside a structure and changes the structure's innards (which is changing the make-bike in the above example).

From Scheme to C

A Sample Program

;; (f n)
;; given an integer n,
;; return 3n^2 +4n + 2
;;
(define f
  (lambda (n)
     (+ (* 3 n n)
        (* 4 n)
        2)))

(f 7)	

#include <stdio.h>        /* include standard input/output library header */

/* f( n )
 * return 3n^2 + 4n + 2
 */
int f( int n ) {             /* A function which takes int n, returns an int. */
  int result = 3*n*n + 4*n + 2;
  return result;             /* You have to "return" explicitly. */
  }


int main() {                 /* Every program needs one function named "main" */
  printf( "f at 7 is %d\n",
           f(7) );           /* Nothing prints by iteslf. */

  return 0;                  /* Return a value...to where?  Who called main?
                                Always return 0 from main, to UNIX. */
  }

#include <stdio.h>

bool biggern( int a, int b ) {      /* "bool" is C's Boolean type */
  return (a > b);
  }

int main() {
  int income = 7;
  int outgo  = 9;

  if (biggern( income, outgo ))
    printf( "Woo-hoo!  Made a profit!\n" );
  else {
    printf( "Uh-oh, in the red.\n" );
    printf( "Must raise $%d quickly!\n", outgo-income );
    }
    
  return 0;
  }

For more introduction to the C language, see the Extended C Primer (html or ps)

The Process of Creating a C Program

1. Type your program into a text file. The filename should end with .c, for example hello.c. You can use whatever text editor you like to create this file; we'll use emacs since it has some nice features for using C.

2. Compile your file, that is translate it from a text file to a binary format the machine can understand directly.

   Translating your program to machine code would be tedious by hand, but fortunately there is a program which will do it automatically.

      owl%  g++ hello.c
   

   If you are using emacs, you can compile the file with M-c (meta-c), or select "compile" under the C menu. You'll see that emacs invokes g++ for you, but with some useful extra arguments. (If emacs doesn't invoke g++ when you type M-c, or there isn't a C menu, type "M-x c-mode" and everything should be set aright.)

3. If your program had any syntax errors (i.e., it wasn't legal C), then g++ will inform you. You must go back to Step 1, and fix your source file.

4. If you didn't have any syntax errors, g++ will create a new executable file, named hello if you compiled with those extra arguments, or a.out (booo) if you didn't.

   Run your program as if it were any other UNIX program: just type in the name of the executable file.

5. Test your program on different inputs. If you have any mistakes...you guessed it: back to Step 1.

6. Celebrate!

Using emacs

To edit a file first.c, type emacs first.c & at the UNIX prompt.

In the emacs window, you can start typing text as normal, except for the delete key. If you are running on X, you can also use commands from the menus. Finally, you can use the control and meta keys to invoke special emacs commands.

Exercise 1: Copy the file ~comp210/Labs/lab08/income.c or ~comp210/Labs/lab08/prog.c to your own directory, and then start editing it from emacs. Compile the file and run it.
Exercise 2: (due to Dan Grossman) Change one character of the program at random, and compile again. Discuss the various error messages with the TA.

Here are some common keyboard commands.
Notation: C-x means control-x; M-c means meta-c.

C-x C-c     to quit
C-x C-f     to open a file
M-x info    to get help
C-_         undo (can be repeated to undo several commands)

M-c         to compile (only if the file you are editing ends in .c)
C-x 1       to make the current emacs window the only one
             (useful to get rid of the second window M-c opens)

C-p, C-n  for previous/next line
C-f, C-b  for forward/back a character
C-d       delete one character
C-k       kill (delete) the line,
C-y       to yank back the last killed text

You can run an emacs tutorial from the "Help" menu. For further commands, see the emacs reference card.