Code Generation: Variables, Assignment, and Expressions
Lecture 10

• the per-component approach
  • waterfall method leads to pain (in this and other large, complex software)
    • if you are trying code everything before you even build much less test, you are setting yourself up for a lot of time and pain
  • creating a minimal test
  • checking reachability
• the stepwise refinement approach
  • get the spec, use comments to plan your code (spent no time actually coding yet; building a house, you wouldn't start with the roof; planning is key; take time to make it easy, constructive laziness)
  • take a step and break it down even more
  • use references to figure out how to do each piece
  • put the pieces together to solve the step
  • move on to next step
  • test with the minimal test, create more tests
    • paper, wirth (recently passed away)

static void check_unaryexpr(T_expr expr) {
// 1. check the type of the subexpression (the thing being deref)
check_expr(expr->unaryexpr.expr); // expr->unaryexpr.expr->type

switch(expr->unaryexpr.op) {
case E_op_ref:
  // 2. create new pointer type to the type of the subexpression, e.g., pointer<int>
  T_type subexpr_type = expr->unaryexpr.expr->type;
  expr->type = create_pointertype(subexpr_type);
  break;
case E_op_deref:
        // 2. make sure it's a pointer type (otherwise a type error)
        if (expr->unaryexpr.expr->type->kind == E_pointertype) {
        // 3. unbox the type, i.e., get the type that is being pointed to
                T_type unboxed_type = expr->unaryexpr.expr->type->pointertype;
        // 4. update the type of the unaryexpr that we just checked
                expr->type = unboxed_type;
        } else {
                type_error("tried to dereference something that wasn't a type");
        }
  break;