--- a/src/pt-id.h
+++ b/src/pt-id.h
@@ -30,11 +30,11 @@
 class octave_value;
 class octave_value_list;
 class octave_function;
-class symbol_record;
 
 class tree_walker;
 
 #include "pt-exp.h"
+#include "symtab.h"
 
 // Symbols from the symbol table.
 
@@ -46,9 +46,9 @@
 public:
 
   tree_identifier (int l = -1, int c = -1)
-    : tree_expression (l, c), sym (0) { }
+    : tree_expression (l, c), sym () { }
 
-  tree_identifier (symbol_record *s, int l = -1, int c = -1)
+  tree_identifier (const symbol_table::symbol_record& s, int l = -1, int c = -1)
     : tree_expression (l, c), sym (s) { }
 
   ~tree_identifier (void) { }
@@ -57,24 +57,48 @@
 
   bool is_identifier (void) const { return true; }
 
-  std::string name (void) const;
+  std::string name (void) const { return sym.name (); }
 
-  tree_identifier *define (octave_function *f, unsigned int sym_type);
+  bool is_defined (void) { return sym.is_defined (); }
+
+  bool is_variable (void) { return sym.is_variable (); }
 
-  void document (const std::string& s);
-
-  bool is_defined (void);
-
-  bool is_function (void);
+  // Try to find a definition for an identifier.  Here's how:
+  //
+  //   * If the identifier is already defined and is a function defined
+  //     in an function file that has been modified since the last time 
+  //     we parsed it, parse it again.
+  //
+  //   * If the identifier is not defined, try to find a builtin
+  //     variable or an already compiled function with the same name.
+  //
+  //   * If the identifier is still undefined, try looking for an
+  //     function file to parse.
+  //
+  //   * On systems that support dynamic linking, we prefer .oct files,
+  //     then .mex files, then .m files.
 
   octave_value
-  do_lookup (bool& script_file_executed, bool exec_script = true);
-
-  void link_to_global (void);
+  do_lookup (bool& script_file_executed, bool exec_script = true)
+  {
+    // FIXME -- SYMTAB: what about executing script files?
+    octave_value_list evaluated_args;
+    bool args_evaluated;
+    return sym.find (0, string_vector (), evaluated_args, args_evaluated);
+  }
 
-  void mark_as_static (void);
+  octave_value
+  do_lookup (tree_argument_list *args, const string_vector& arg_names,
+	     octave_value_list& evaluated_args, bool& args_evaluated)
+  {
+    return sym.find (args, arg_names, evaluated_args, args_evaluated);
+  }
 
-  void mark_as_formal_parameter (void);
+  void mark_global (void) { sym.mark_global (); }
+
+  void mark_as_static (void) { sym.init_persistent (); }
+
+  void mark_as_formal_parameter (void) { sym.mark_formal (); }
 
   // We really need to know whether this symbol referst to a variable
   // or a function, but we may not know that yet.
@@ -89,14 +113,14 @@
 
   void eval_undefined_error (void);
 
-  tree_identifier *dup (symbol_table *sym_tab);
+  tree_identifier *dup (symbol_table::scope_id scope);
 
   void accept (tree_walker& tw);
 
 private:
 
   // The symbol record that this identifier references.
-  symbol_record *sym;
+  symbol_table::symbol_record sym;
 
   // No copying!