CSE 423 Lab #5: Drawing Syntax Trees

1. an image of your hand-drawn syntax tree with your name on it (individual), and
2. a pretty PNG image produced from your compiler (group OK)

This week's lab asks you to practice drawing syntax trees by hand, and then implement a tree traversal that generates a graphical representation of your syntax trees or symbol tables. Turn in as far as you get by Sunday evening; preferably a .zip with some sample images and your compiler code base that produced them. You will be graded as having done the lab as long as it looks like you did two or more hours of work.

Part 1: Drawing Syntax Trees by Hand

• You will need a Bison grammar that approximates Kotlin, such as one you are writing for HW. It is possible to do the lab faking this part, but the closer your approximation is to reality, the more useful the lab is.
• Draw a circle or oval for each non-leaf node with two or more children.
• Draw a square or rectangle for each leaf node (token). You can omit punctuation that is implied by the production rule.
• Draw the non-terminal name inside circles/ovals, and the terminal symbol name inside squares/rectangles
• Draw lines connecting parents with children.

fun main(args : Array<String>) { // Print text to the console. println("Hello World!") }

fun main() { var x : Int = 5 x + 1 }

fun main() { var n : Int = 5 if (n < 0) { println("{n} is negative") } else { println("{n} is zero") } }

Check your work by exchanging with a classmate, or do Part 2 and compare your work against the Machine.

Part 2: Dot

The dot language is a human readable ASCII way of describing a graph, which dot will then render in forms such as a PNG image file.

Here is the dot language reference

Prepping your Dot Syntax Trees

struct tree {
  ...
  int id;
  ...
}

int serial;
struct tree *alctree(int label, char *sname, int nkids, ...)
{
   ...
   ptr->id = serial++;
   ...
}

Adding names for token categories

#if YYDEBUG || YYERROR_VERBOSE || 0
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
static const char *const yytname[] =
{
  "$end", "error", "$undefined", "BAD_TOKEN", "ICON", "CCON", "FCON",
  "ENUMERATION_CONSTANT", "IDENTIFIER", "STRING", "SIZEOF", "INCOP",

%%

const char *yyname(int sym)
{
   return yytname[sym-BAD_TOKEN+3];
}

Writing your Dot Syntax Trees

Your solution might look some something like the following (adapted from [Jeffery2021]). You may have to debug this code!

/* add a \ before leading and trailing double quotes */
char *escape(char *s) {
   char *s2 = malloc(strlen(s)+4);
   if (s[0] == '\"') {
      if (s[strlen(s)-1] != '\"') {
	 fprintf(stderr, "What is it?!\n");
	 }
      sprintf(s2, "\\%s", s);
      strcat(s2+strlen(s2)-1, "\\\"");
      return s2;
     }
   else return s;
}

char *pretty_print_name(struct tree *t) {
   char *s2 = malloc(40);
   if (t->leaf == NULL) {
      sprintf(s2, "%s#%d", t->symbolname, t->prodrule%10);
      return s2;
      }
   else {
      sprintf(s2,"%s:%d", escape(t->leaf->text), t->leaf->category);
      return s2;
      }
}

void print_branch(struct tree *t, FILE *f) {
   fprintf(f, "N%d [shape=box label=\"%s\"];\n", t->id, pretty_print_name(t));
}

char *yyname(int);

void print_leaf(struct tree *t, FILE *f) {
   char * s = yyname(t->leaf->category);
   // print_branch(t, f);
   fprintf(f, "N%d [shape=box style=dotted label=\" %s \\n ", t->id, s);
   fprintf(f, "text = %s \\l lineno = %d \\l\"];\n", escape(t->leaf->text),
   t->leaf->lineno);
}

void print_graph2(struct tree *t, FILE *f) {
   int i;
   if (t->leaf != NULL) {
      print_leaf(t, f);
      return;
      }
   /* not a leaf ==> internal node */
   print_branch(t, f);
   for(i=0; i < t->nkids; i++) {
      if (t->kids[i] != NULL) {
         fprintf(f, "N%d -> N%d;\n", t->id, t->kids[i]->id);
	 print_graph2(t->kids[i], f);
	 }
      else { /* NULL kid, epsilon production or something */
         fprintf(f, "N%d -> N%d%d;\n", t->id, t->id, serial);
	 fprintf(f, "N%d%d [label=\"%s\"];\n", t->id, serial, "Empty rule");
	 serial++;
	 }
      }
}

void print_graph(struct tree *t, char *filename){
      FILE *f = fopen(filename, "w"); /* should check for NULL */
      fprintf(f, "digraph {\n");
      print_graph2(t, f);
      fprintf(f,"}\n");
      fclose(f);
}

Adding a command line option

Running the Dot Program

dot -Tpng hello.java.dot >hello.png

Of course, for some other language, your tree should look different.

Wrapping up

// foo.kt
fun foo(x : Int, y : String) : Int {
   return x
   }
fun main() {
   var z : Int
   z = foo(5, ("funf").toString())
}

./k0 -dot foo.kt
dot -Tpng foo.kt.dot >foo.png