diff --git a/compiler/cpp/src/parse/t_enum.h b/compiler/cpp/src/parse/t_enum.h
index 4b6fe36..002ca82 100644
--- a/compiler/cpp/src/parse/t_enum.h
+++ b/compiler/cpp/src/parse/t_enum.h
@@ -11,7 +11,8 @@
  */
 class t_enum : public t_type {
  public:
-  t_enum() {}
+  t_enum(t_program* program) :
+    t_type(program) {}
 
   void set_name(std::string name) {
     name_ = name;
diff --git a/compiler/cpp/src/parse/t_function.h b/compiler/cpp/src/parse/t_function.h
index 3d07171..6f06abe 100644
--- a/compiler/cpp/src/parse/t_function.h
+++ b/compiler/cpp/src/parse/t_function.h
@@ -22,7 +22,7 @@
     name_(name),
     arglist_(arglist),
     async_(async) {
-    xceptions_ = new t_struct;
+    xceptions_ = new t_struct(NULL);
   }
 
   t_function(t_type* returntype,
diff --git a/compiler/cpp/src/parse/t_program.h b/compiler/cpp/src/parse/t_program.h
index 5e58654..a3270ad 100644
--- a/compiler/cpp/src/parse/t_program.h
+++ b/compiler/cpp/src/parse/t_program.h
@@ -5,6 +5,10 @@
 #include <string>
 #include <vector>
 
+// For program_name()
+#include "main.h"
+
+#include "t_scope.h"
 #include "t_base_type.h"
 #include "t_typedef.h"
 #include "t_enum.h"
@@ -30,38 +34,26 @@
  */
 class t_program {
  public:
-  t_program(std::string name) :
-    name_(name),
-    namespace_() {
-    type_void   = new t_base_type("void",   t_base_type::TYPE_VOID);
-    type_string = new t_base_type("string", t_base_type::TYPE_STRING);
-    type_bool   = new t_base_type("bool",   t_base_type::TYPE_BOOL);
-    type_byte   = new t_base_type("byte",   t_base_type::TYPE_BYTE);
-    type_i16    = new t_base_type("i16",    t_base_type::TYPE_I16);
-    type_i32    = new t_base_type("i32",    t_base_type::TYPE_I32);
-    type_i64    = new t_base_type("i64",    t_base_type::TYPE_I64);
-    type_double = new t_base_type("double", t_base_type::TYPE_DOUBLE);
+  t_program(std::string path, std::string name) :
+    path_(path), 
+    name_(name) {
+    scope_ = new t_scope();
   }
 
-  ~t_program() {
-    delete type_string;
-    delete type_bool;
-    delete type_byte;
-    delete type_i16;
-    delete type_i32;
-    delete type_i64;
-    delete type_double;
+  t_program(std::string path) :
+    path_(path) {
+    name_ = program_name(path);
+    scope_ = new t_scope();
   }
 
+  // Path accessor   
+  const std::string& get_path() const { return path_; }
+
   // Name accessor
-  const std::string& get_name() const {
-    return name_;
-  }
+  const std::string& get_name() const { return name_; }
 
   // Namespace
-  const std::string& get_namespace() const {
-    return namespace_;
-  }
+  const std::string& get_namespace() const { return namespace_; }
 
   // Accessors for program elements
   const std::vector<t_typedef*>& get_typedefs()  const { return typedefs_;  }
@@ -70,57 +62,67 @@
   const std::vector<t_struct*>&  get_xceptions() const { return xceptions_; }
   const std::vector<t_service*>& get_services()  const { return services_;  }
 
-  // Accessors for global types
-  t_type* get_void_type()   const { return type_void;   }
-  t_type* get_string_type() const { return type_string; }
-  t_type* get_bool_type()   const { return type_bool;   }
-  t_type* get_byte_type()   const { return type_byte;   }
-  t_type* get_i16_type()    const { return type_i16;    }
-  t_type* get_i32_type()    const { return type_i32;    }
-  t_type* get_i64_type()    const { return type_i64;    }
-  t_type* get_double_type() const { return type_double; }
+  // Program elements
+  void add_typedef  (t_typedef* td) { typedefs_.push_back(td);  }
+  void add_enum     (t_enum*    te) { enums_.push_back(te);     }
+  void add_struct   (t_struct*  ts) { structs_.push_back(ts);   }
+  void add_xception (t_struct*  tx) { xceptions_.push_back(tx); }
+  void add_service  (t_service* ts) { services_.push_back(ts);  }
 
-  // Custom data type lookup
-  t_type* get_custom_type(std::string name) {
-    return custom_types_[name];
-  }
+  // Programs to include
+  const std::vector<t_program*>& get_includes() const { return includes_; }
 
-  // New program element addition
-
+  // Scoping and namespacing
   void set_namespace(std::string name) {
     namespace_ = name;
   }
 
-  void add_typedef(t_typedef* td) {
-    typedefs_.push_back(td);
-    add_custom_type(td->get_symbolic(), td);
+  // Scope accessor
+  t_scope* scope() {
+    return scope_;
   }
 
-  void add_enum(t_enum* te) {
-    enums_.push_back(te);
-    add_custom_type(te->get_name(), te);
+  // Includes
+
+  void add_include(std::string path) {
+    includes_.push_back(new t_program(path));
   }
 
-  void add_struct(t_struct* ts) {
-    structs_.push_back(ts);
-    add_custom_type(ts->get_name(), ts);
+  std::vector<t_program*>& get_includes() {
+    return includes_;
   }
 
-  void add_xception(t_struct* tx) {
-    xceptions_.push_back(tx);
-    add_custom_type(tx->get_name(), tx);
+  // Language specific namespace / packaging
+
+  void set_cpp_namespace(std::string cpp_namespace) {
+    cpp_namespace_ = cpp_namespace;
   }
 
-  void add_service(t_service* ts) {
-    services_.push_back(ts);
+  const std::string& get_cpp_namespace() const {
+    return cpp_namespace_;
   }
 
+  void add_cpp_include(std::string path) {
+    cpp_includes_.push_back(path);
+  }
+
+  const std::vector<std::string>& get_cpp_includes() {
+    return cpp_includes_;
+  }
+
+  void set_java_package(std::string java_package) {
+    java_package_ = java_package;
+  }
+
+  const std::string& get_java_package() const {
+    return java_package_;
+  }
+
+
  private:
 
-  // Add custom type for lookup
-  void add_custom_type(std::string name, t_type* type) {
-    custom_types_[name] = type;
-  }
+  // File path
+  std::string path_;
 
   // Name
   std::string name_;
@@ -128,25 +130,28 @@
   // Namespace
   std::string namespace_;
 
-  // Components
-  std::vector<t_typedef*>  typedefs_;
-  std::vector<t_enum*>     enums_;
-  std::vector<t_struct*>   structs_;
-  std::vector<t_struct*>   xceptions_;
-  std::vector<t_service*>  services_;
+  // Included programs
+  std::vector<t_program*> includes_;
 
-  // Type map
-  std::map<std::string, t_type*> custom_types_;
+  // Identifier lookup scope
+  t_scope* scope_;
 
-  // Global base types
-  t_type* type_void;
-  t_type* type_string;
-  t_type* type_bool;
-  t_type* type_byte;
-  t_type* type_i16;
-  t_type* type_i32;
-  t_type* type_i64;
-  t_type* type_double;
+  // Components to generate code for
+  std::vector<t_typedef*> typedefs_;
+  std::vector<t_enum*>    enums_;
+  std::vector<t_struct*>  structs_;
+  std::vector<t_struct*>  xceptions_;
+  std::vector<t_service*> services_;
+
+  // C++ namespace
+  std::string cpp_namespace_;
+
+  // C++ extra includes
+  std::vector<std::string> cpp_includes_;
+
+  // Java package
+  std::string java_package_;
+
 };
 
 #endif
diff --git a/compiler/cpp/src/parse/t_scope.h b/compiler/cpp/src/parse/t_scope.h
new file mode 100644
index 0000000..504393b
--- /dev/null
+++ b/compiler/cpp/src/parse/t_scope.h
@@ -0,0 +1,57 @@
+#ifndef T_SCOPE_H
+#define T_SCOPE_H
+
+#include <map>
+#include <string>
+
+#include "t_type.h"
+#include "t_service.h"
+
+/**
+ * This represents a variable scope used for looking up predefined types and
+ * services. Typically, a scope is associated with a t_program. Scopes are not
+ * used to determine code generation, but rather to resolve identifiers at
+ * parse time.
+ *
+ * @author Mark Slee <mcslee@facebook.com>
+ */
+class t_scope {
+ public:
+  t_scope() {}
+
+  void add_type(std::string name, t_type* type) {
+    types_[name] = type;
+  }
+
+  t_type* get_type(std::string name) {
+    return types_[name];
+  }
+
+  void add_service(std::string name, t_service* service) {
+    services_[name] = service;
+  }
+
+  t_service* get_service(std::string name) {
+    return services_[name];
+  }
+
+  void print() {
+    std::map<std::string, t_type*>::iterator iter;
+    for (iter = types_.begin(); iter != types_.end(); ++iter) {
+      printf("%s => %s\n",
+             iter->first.c_str(),
+             iter->second->get_name().c_str());
+    }
+  }
+
+ private:
+  
+  // Map of names to types
+  std::map<std::string, t_type*> types_;
+
+  // Map of names to services
+  std::map<std::string, t_service*> services_; 
+ 
+};
+
+#endif
diff --git a/compiler/cpp/src/parse/t_service.h b/compiler/cpp/src/parse/t_service.h
index 6bb5e5d..52280a4 100644
--- a/compiler/cpp/src/parse/t_service.h
+++ b/compiler/cpp/src/parse/t_service.h
@@ -4,34 +4,42 @@
 #include "t_function.h"
 #include <vector>
 
+class t_program;
+
 /**
  * A service consists of a set of functions.
  *
  * @author Mark Slee <mcslee@facebook.com>
  */
-class t_service {
+class t_service : public t_type {
  public:
-  t_service() {}
+  t_service(t_program* program) :
+    t_type(program),
+    extends_(NULL) {}
 
-  void set_name(std::string name) {
-    name_ = name;
+  bool is_service() const {
+    return true;
+  }
+
+  void set_extends(t_service* extends) {
+    extends_ = extends;
   }
 
   void add_function(t_function* func) {
     functions_.push_back(func);
   }
 
-  const std::string& get_name() const {
-    return name_;
-  }
-
   const std::vector<t_function*>& get_functions() const {
     return functions_;
   }
 
+  t_service* get_extends() {
+    return extends_;
+  }
+
  private:
-  std::string name_;
   std::vector<t_function*> functions_;
+  t_service* extends_;
 };
 
 #endif
diff --git a/compiler/cpp/src/parse/t_struct.h b/compiler/cpp/src/parse/t_struct.h
index 8768c5f..ce5f752 100644
--- a/compiler/cpp/src/parse/t_struct.h
+++ b/compiler/cpp/src/parse/t_struct.h
@@ -7,6 +7,9 @@
 #include "t_type.h"
 #include "t_field.h"
 
+// Forward declare that puppy
+class t_program;
+
 /**
  * A struct is a container for a set of member fields that has a name. Structs
  * are also used to implement exception types.
@@ -15,11 +18,12 @@
  */
 class t_struct : public t_type {
  public:
-  t_struct() :
+  t_struct(t_program* program) :
+    t_type(program),
     is_xception_(false) {}
 
-  t_struct(const std::string& name) :
-    t_type(name),
+  t_struct(t_program* program, const std::string& name) :
+    t_type(program, name),
     is_xception_(false) {}
 
   void set_name(const std::string& name) {
diff --git a/compiler/cpp/src/parse/t_type.h b/compiler/cpp/src/parse/t_type.h
index 1d0a2ed..9589f02 100644
--- a/compiler/cpp/src/parse/t_type.h
+++ b/compiler/cpp/src/parse/t_type.h
@@ -3,6 +3,8 @@
 
 #include <string>
 
+class t_program;
+
 /**
  * Generic representation of a thrift type. These objects are used by the
  * parser module to build up a tree of object that are all explicitly typed.
@@ -16,7 +18,13 @@
  public:
   virtual ~t_type() {}
 
-  virtual const std::string& get_name() const { return name_; }
+  virtual void set_name(std::string name) {
+    name_ = name;
+  }
+
+  virtual const std::string& get_name() const {
+    return name_;
+  }
 
   virtual bool is_void()      const { return false; }
   virtual bool is_base_type() const { return false; }
@@ -28,13 +36,26 @@
   virtual bool is_list()      const { return false; }
   virtual bool is_set()       const { return false; }
   virtual bool is_map()       const { return false; }
+  virtual bool is_service()   const { return false; }
+
+  t_program* get_program() {
+    return program_;
+  }
 
  protected:
   t_type() {}
 
-  t_type(std::string name) :
+  t_type(t_program* program) :
+    program_(program) {}
+
+  t_type(t_program* program, std::string name) :
+    program_(program),
     name_(name) {}
 
+  t_type(std::string name) :
+    name_(name) {}
+    
+  t_program* program_;
   std::string name_;
 };
 
diff --git a/compiler/cpp/src/parse/t_typedef.h b/compiler/cpp/src/parse/t_typedef.h
index 8973201..cc7f25c 100644
--- a/compiler/cpp/src/parse/t_typedef.h
+++ b/compiler/cpp/src/parse/t_typedef.h
@@ -14,8 +14,8 @@
  */
 class t_typedef : public t_type {
  public:
-  t_typedef(t_type* type, std::string symbolic) :
-    t_type(symbolic),
+  t_typedef(t_program* program, t_type* type, std::string symbolic) :
+    t_type(program, symbolic),
     type_(type),
     symbolic_(symbolic) {}