diff options
Diffstat (limited to 'usr/gri/pretty/ast.go')
| -rw-r--r-- | usr/gri/pretty/ast.go | 206 |
1 files changed, 5 insertions, 201 deletions
diff --git a/usr/gri/pretty/ast.go b/usr/gri/pretty/ast.go index ddcc1af80..b3260a1fa 100644 --- a/usr/gri/pretty/ast.go +++ b/usr/gri/pretty/ast.go @@ -6,16 +6,12 @@ package AST import ( "array"; - "utf8"; - "unicode"; Scanner "scanner"; + SymbolTable "symboltable"; ) type ( - Object struct; - Type struct; - Block struct; Expr interface; Decl struct; @@ -33,91 +29,6 @@ func assert(pred bool) { // ---------------------------------------------------------------------------- -// Objects - -// Object represents a language object, such as a constant, variable, type, etc. - -const /* kind */ ( - BADOBJ = iota; // error handling - NONE; // kind unknown - CONST; TYPE; VAR; FIELD; FUNC; BUILTIN; PACKAGE; LABEL; - END; // end of scope (import/export only) -) - - -func KindStr(kind int) string { - switch kind { - case BADOBJ: return "BADOBJ"; - case NONE: return "NONE"; - case CONST: return "CONST"; - case TYPE: return "TYPE"; - case VAR: return "VAR"; - case FIELD: return "FIELD"; - case FUNC: return "FUNC"; - case BUILTIN: return "BUILTIN"; - case PACKAGE: return "PACKAGE"; - case LABEL: return "LABEL"; - case END: return "END"; - } - return "<unknown Object kind>"; -} - - -type Object struct { - Id int; // unique id - - Pos int; // source position (< 0 if unknown position) - Kind int; // object kind - Ident string; - Typ *Type; // nil for packages - Pnolev int; // >= 0: package no., <= 0: function nesting level, 0: global level - - // attached values - Body *Block; // function body -} - - -func (obj *Object) IsExported() bool { - switch obj.Kind { - case NONE /* FUNC for now */, CONST, TYPE, VAR, FUNC: - ch, size := utf8.DecodeRuneInString(obj.Ident, 0); - return unicode.IsUpper(ch); - } - return false; -} - - -func (obj* Object) String() string { - if obj != nil { - return - "Object(" + - KindStr(obj.Kind) + ", " + - obj.Ident + - ")"; - } - return "nil"; -} - - -var Universe_void_typ *Type // initialized by Universe to Universe.void_typ -var objectId int; - -func NewObject(pos, kind int, ident string) *Object { - obj := new(Object); - obj.Id = objectId; - objectId++; - - obj.Pos = pos; - obj.Kind = kind; - obj.Ident = ident; - obj.Typ = Universe_void_typ; // TODO would it be better to use nil instead? - obj.Pnolev = 0; - - return obj; -} - - -// ---------------------------------------------------------------------------- // All nodes have a source position and a token. type Node struct { @@ -127,112 +38,19 @@ type Node struct { // ---------------------------------------------------------------------------- -// Scopes - -type Scope struct { - Parent *Scope; - entries map[string] *Object; -} - - -func NewScope(parent *Scope) *Scope { - scope := new(Scope); - scope.Parent = parent; - scope.entries = make(map[string]*Object, 8); - return scope; -} - - -func (scope *Scope) LookupLocal(ident string) *Object { - obj, found := scope.entries[ident]; - if found { - return obj; - } - return nil; -} - - -func (scope *Scope) Lookup(ident string) *Object { - for scope != nil { - obj := scope.LookupLocal(ident); - if obj != nil { - return obj; - } - scope = scope.Parent; - } - return nil; -} - - -func (scope *Scope) add(obj* Object) { - scope.entries[obj.Ident] = obj; -} - - -func (scope *Scope) Insert(obj *Object) { - if scope.LookupLocal(obj.Ident) != nil { - panic("obj already inserted"); - } - scope.add(obj); -} - - -func (scope *Scope) InsertImport(obj *Object) *Object { - p := scope.LookupLocal(obj.Ident); - if p == nil { - scope.add(obj); - p = obj; - } - return p; -} - - -func (scope *Scope) Print() { - print("scope {"); - for key := range scope.entries { - print("\n ", key); - } - print("\n}\n"); -} - - -// ---------------------------------------------------------------------------- // Types const /* form */ ( - // internal types - // We should never see one of these. - UNDEF = iota; - - // VOID types are used when we don't have a type. Never exported. - // (exported type forms must be > 0) - VOID; - // BADTYPE types are compatible with any type and don't cause further errors. // They are introduced only as a result of an error in the source code. A // correct program cannot have BAD types. - BADTYPE; - - // FORWARD types are forward-declared (incomplete) types. They can only - // be used as element types of pointer types and must be resolved before - // their internals are accessible. - FORWARD; - - // TUPLE types represent multi-valued result types of functions and - // methods. - TUPLE; - - // The type of nil. - NIL; + BADTYPE = iota; // A type name TYPENAME; - // basic types - BOOL; UINT; INT; FLOAT; STRING; INTEGER; - // composite types - ALIAS; ARRAY; STRUCT; INTERFACE; MAP; CHANNEL; FUNCTION; METHOD; POINTER; + ARRAY; STRUCT; INTERFACE; MAP; CHANNEL; FUNCTION; POINTER; // open-ended parameter type ELLIPSIS @@ -241,25 +59,14 @@ const /* form */ ( func FormStr(form int) string { switch form { - case VOID: return "VOID"; case BADTYPE: return "BADTYPE"; - case FORWARD: return "FORWARD"; - case TUPLE: return "TUPLE"; - case NIL: return "NIL"; case TYPENAME: return "TYPENAME"; - case BOOL: return "BOOL"; - case UINT: return "UINT"; - case INT: return "INT"; - case FLOAT: return "FLOAT"; - case STRING: return "STRING"; - case ALIAS: return "ALIAS"; case ARRAY: return "ARRAY"; case STRUCT: return "STRUCT"; case INTERFACE: return "INTERFACE"; case MAP: return "MAP"; case CHANNEL: return "CHANNEL"; case FUNCTION: return "FUNCTION"; - case METHOD: return "METHOD"; case POINTER: return "POINTER"; case ELLIPSIS: return "ELLIPSIS"; } @@ -277,11 +84,9 @@ const /* channel mode */ ( type Type struct { Id int; // unique id - Ref int; // for exporting only: >= 0 means already exported Form int; // type form Size int; // size in bytes - Obj *Object; // primary type object or nil - Scope *Scope; // locals, fields & methods + Scope *SymbolTable.Scope; // locals, fields & methods // syntactic components Pos int; // source position (< 0 if unknown position) @@ -300,7 +105,6 @@ func NewType(pos, form int) *Type { typ.Id = typeId; typeId++; - typ.Ref = -1; // not yet exported typ.Pos = pos; typ.Form = form; @@ -339,7 +143,7 @@ type ( Ident struct { Pos_ int; - Obj *Object; + Obj *SymbolTable.Object; }; BinaryExpr struct { |