Working with HackC Parse Trees

Table of contents.

HackC List Overview

New features are added to HackC by programs that directly manipulate the internal representation. All HackC constructs are internally represented in a simple list structure. This structure is made of only two classes: zList and zAtom.

The zList class represents lists. The top level parse tree is a zList. zLists have child zLists, and optionally, an attached zAtom. A list of three elements "A", 5, and true would be written as: 

    ("A" 5 true)

A list of no elements is written as (). If an empty list has an atom, the value of the atom is written instead. So, an empty list pointing to the atom "foo" is written "foo".

A list with both elements and an atom is written with the atom, and the listed items in brackets. For example, a list pointing to the atom "aListOfIntegers", and containing the elements 3 5 and 9 would be written as 

    "aListOfIntegers"{3 5 9}

The Binding System

Identifiers in the HackC parse tree are bound with a lazy evaluation. To simplify identifier binding, the following rules are applied to the parse tree:

  1. Name scopes are identified with "subScope" lists, which can be named
  2. Identifiers declared within a scope are declared with a "defIdent" list
  3. Identifier references are declared with a "refIdent" list
  4. Name scopes can be imported with an "importScope" list

Identifiers are bound by looking for matching (case sensitive) identifiers defined within the subScope containing the identifier. If no identifier is found, any imported scopes within the containing scope are checked next. Scopes are searched in the order they are imported, assuming a depth first search order. If still no match is found, the process is repeated at the next higher scope level. It is an error to fail to find a matching identifier. An identifier reference ("refIdent" list) can contain a list of symbols, rather than just one. In this case, the same process is used, starting with the first symbol, which must resolve to a scope name. Then, each remaining symbol is used to locate sub-scopes of the scope, until the last symbol is reached, which can refer to any identifier definition.

It is up to the semantic checkers to determine if an illegal access has occurred, such as accessing a private field of a non-friend class.

Here's a simple example list: 

(subScope{main (
    importScope{library}
    identRef{foo bar})})
(subScope{library (
    subScope{foo
        identDef{bar}})

Last changed: 04/06/2003, 13:07:48