Synopsis - Cross-Reference

  1//
  2// Copyright (C) 2005 Stefan Seefeld
  3// All rights reserved.
  4// Licensed to the public under the terms of the GNU LGPL (>= 2),
  5// see the file COPYING for details.
  6//
  7#include <Synopsis/PTree.hh>
  8#include <boost/python.hpp>
  9
 10namespace bpl = boost::python;
 11using namespace Synopsis;
 12using namespace Synopsis::PTree;
 13
 14namespace
 15{
 16
 17class VisitorWrapper : public Visitor
 18{
 19public:
 20  VisitorWrapper(PyObject *s) : self(s) {}
 21
 22  virtual void visit_node(Node *) {}
 23  virtual void visit_atom(Atom *a) { apply("visit_node", a);}
 24  virtual void visit_list(List *l) { apply("visit_node", l);}
 25
 26  virtual void visit_literal(Literal *a) { apply("visit_atom", a);}
 27  virtual void visit_commented_atom(CommentedAtom *a) { apply("visit_atom", a);}
 28  virtual void visit_dup_atom(DupAtom *a) { apply("visit_atom", a);}
 29  virtual void visit_identifier(Identifier *a) { apply("visit_atom", a);}
 30  virtual void visit_keyword(Keyword *a) { apply("visit_atom", a);}
 31//   virtual void visit_this(Kwd::This *a) { apply("visit_keyword", a);}
 32//   virtual void visit_auto(Kwd::Auto *a) { apply("visit_keyword", a);}
 33//   virtual void visit_boolean(Kwd::Bool *a) { apply("visit_keyword", a);}
 34//   virtual void visit_char(Kwd::Char *a) { apply("visit_keyword", a);}
 35//   virtual void visit_wchar(Kwd::WChar *a) { apply("visit_keyword", a);}
 36//   virtual void visit_const(Kwd::Const *a) { apply("visit_keyword", a);}
 37//   virtual void visit_double(Kwd::Double *a) { apply("visit_keyword", a);}
 38//   virtual void visit_extern(Kwd::Extern *a) { apply("visit_keyword", a);}
 39//   virtual void visit_float(Kwd::Float *a) { apply("visit_keyword", a);}
 40//   virtual void visit_friend(Kwd::Friend *a) { apply("visit_keyword", a);}
 41//   virtual void visit_inline(Kwd::Inline *a) { apply("visit_keyword", a);}
 42//   virtual void visit_int(Kwd::Int *a) { apply("visit_keyword", a);}
 43//   virtual void visit_long(Kwd::Long *a) { apply("visit_keyword", a);}
 44//   virtual void visit_mutable(Kwd::Mutable *a) { apply("visit_keyword", a);}
 45//   virtual void visit_namespace(Kwd::Namespacec *a) { apply("visit_keyword", a);}
 46//   virtual void visit_private(Kwd::Private *a) { apply("visit_keyword", a);}
 47//   virtual void visit_protected(Kwd::Protected *a) { apply("visit_keyword", a);}
 48//   virtual void visit_public(Kwd::Public *a) { apply("visit_keyword", a);}
 49//   virtual void visit_register(Kwd::Register *a) { apply("visit_keyword", a);}
 50//   virtual void visit_short(Kwd::Short *a) { apply("visit_keyword", a);}
 51//   virtual void visit_signed(Kwd::Signed *a) { apply("visit_keyword", a);}
 52//   virtual void visit_static(Kwd::Static *a) { apply("visit_keyword", a);}
 53//   virtual void visit_unsigned(Kwd::Unsigned *a) { apply("visit_keyword", a);}
 54//   virtual void visit_using_(Kwd::Using *a) { apply("visit_keyword", a);}
 55//   virtual void visit_virtual(Kwd::Virtual *a) { apply("visit_keyword", a);}
 56//   virtual void visit_void(Kwd::Void *a) { apply("visit_keyword", a);}
 57//   virtual void visit_volatile(Lwd::Volatile *a) { apply("visit_keyword", a);}
 58
 59  virtual void visit_brace(Brace *l) { apply("visit_list", l);}
 60  virtual void visit_block(Block *l) { apply("visit_brace", l);}
 61  virtual void visit_class_body(ClassBody *l) { apply("visit_brace", l);}
 62  virtual void visit_typedef(Typedef *l) { apply("visit_list", l);}
 63  virtual void visit_template_decl(TemplateDecl *l) { apply("visit_list", l);}
 64  virtual void visit_template_instantiation(TemplateInstantiation *l) { apply("visit_list", l);}
 65  virtual void visit_extern_template(ExternTemplate *l) { apply("visit_list", l);}
 66  virtual void visit_metaclass_decl(MetaclassDecl *l) { apply("visit_list", l);}
 67  virtual void visit_linkage_spec(LinkageSpec *l) { apply("visit_list", l);}
 68  virtual void visit_namespace_spec(NamespaceSpec *l) { apply("visit_list", l);}
 69  virtual void visit_declaration(Declaration *l) { apply("visit_list", l);}
 70  virtual void visit_namespace_alias(NamespaceAlias *l) { apply("visit_declaration", l);}
 71  virtual void visit_using_directive(UsingDirective *l) { apply("visit_declaration", l);}
 72  virtual void visit_parameter_declaration(ParameterDeclaration *l) { apply("visit_declaration", l);}
 73  virtual void visit_function_definition(FunctionDefinition *l) { apply("visit_declaration", l);}
 74  virtual void visit_using_declaration(UsingDeclaration *l) { apply("visit_list", l);}
 75  virtual void visit_declarator(Declarator *l) { apply("visit_list", l);}
 76  virtual void visit_name(Name *l) { apply("visit_list", l);}
 77  virtual void visit_fstyle_cast_expr(FstyleCastExpr *l) { apply("visit_list", l);}
 78  virtual void visit_class_spec(ClassSpec *l) { apply("visit_list", l);}
 79  virtual void visit_enum_spec(EnumSpec *l) { apply("visit_list", l);}
 80  virtual void visit_access_spec(AccessSpec *l) { apply("visit_list", l);}
 81  virtual void visit_access_decl(AccessDecl *l) { apply("visit_list", l);}
 82  virtual void visit_user_access_spec(UserAccessSpec *l) { apply("visit_list", l);}
 83  virtual void visit_if_statement(IfStatement *l) { apply("visit_list", l);}
 84  virtual void visit_switch_statement(SwitchStatement *l) { apply("visit_list", l);}
 85  virtual void visit_while_statement(WhileStatement *l) { apply("visit_list", l);}
 86  virtual void visit_do_statement(DoStatement *l) { apply("visit_list", l);}
 87  virtual void visit_for_statement(ForStatement *l) { apply("visit_list", l);}
 88  virtual void visit_try_statement(TryStatement *l) { apply("visit_list", l);}
 89  virtual void visit_break_statement(BreakStatement *l) { apply("visit_list", l);}
 90  virtual void visit_continue_statement(ContinueStatement *l) { apply("visit_list", l);}
 91  virtual void visit_return_statement(ReturnStatement *l) { apply("visit_list", l);}
 92  virtual void visit_goto_statement(GotoStatement *l) { apply("visit_list", l);}
 93  virtual void visit_case_statement(CaseStatement *l) { apply("visit_list", l);}
 94  virtual void visit_default_statement(DefaultStatement *l) { apply("visit_list", l);}
 95  virtual void visit_label_statement(LabelStatement *l) { apply("visit_list", l);}
 96  virtual void visit_expr_statement(ExprStatement *l) { apply("visit_list", l);}
 97  virtual void visit_expression(Expression *l) { apply("visit_list", l);}
 98  virtual void visit_assign_expr(AssignExpr *l) { apply("visit_list", l);}
 99  virtual void visit_cond_expr(CondExpr *l) { apply("visit_list", l);}
100  virtual void visit_infix_expr(InfixExpr *l) { apply("visit_list", l);}
101  virtual void visit_pm_expr(PmExpr *l) { apply("visit_list", l);}
102  virtual void visit_cast_expr(CastExpr *l) { apply("visit_list", l);}
103  virtual void visit_unary_expr(UnaryExpr *l) { apply("visit_list", l);}
104  virtual void visit_throw_expr(ThrowExpr *l) { apply("visit_list", l);}
105  virtual void visit_sizeof_expr(SizeofExpr *l) { apply("visit_list", l);}
106  virtual void visit_typeid_expr(TypeidExpr *l) { apply("visit_list", l);}
107  virtual void visit_typeof_expr(TypeofExpr *l) { apply("visit_list", l);}
108  virtual void visit_new_expr(NewExpr *l) { apply("visit_list", l);}
109  virtual void visit_delete_expr(DeleteExpr *l) { apply("visit_list", l);}
110  virtual void visit_array_expr(ArrayExpr *l) { apply("visit_list", l);}
111  virtual void visit_funcall_expr(FuncallExpr *l) { apply("visit_list", l);}
112  virtual void visit_postfix_expr(PostfixExpr *l) { apply("visit_list", l);}
113  virtual void visit_dot_member_expr(DotMemberExpr *l) { apply("visit_list", l);}
114  virtual void visit_arrow_member_expr(ArrowMemberExpr *l) { apply("visit_list", l);}
115  virtual void visit_paren_expr(ParenExpr *l) { apply("visit_list", l);}
116
117  virtual void visit(Node *n) { apply("visit_node", n);}
118  virtual void visit(Atom *n) { apply("visit_atom", n);}
119  virtual void visit(List* n) { apply("visit_list", n);}
120  virtual void visit(Literal *n) { apply("visit_literal", n);}
121  virtual void visit(CommentedAtom *n) { apply("visit_commented_atom", n);}
122  virtual void visit(DupAtom *n) { apply("visit_dup_atom", n);}
123  virtual void visit(Identifier *n) { apply("visit_identifier", n);}
124  virtual void visit(Keyword *n) { apply("visit_keyword", n);}
125//   virtual void visit(This *n) { apply("visit_this", n);}
126//   virtual void visit(Kwd::Auto *n) { apply("visit_auto", n);}
127//   virtual void visit(Kwd::Bool *n) { apply("visit_boolean", n);}
128//   virtual void visit(Kwd::Char *n) { apply("visit_char", n);}
129//   virtual void visit(Kwd::WChar *n) { apply("visit_wchar", n);}
130//   virtual void visit(Kwd::Const *n) { apply("visit_const", n);}
131//   virtual void visit(Kwd::Double *n) { apply("visit_double", n);}
132//   virtual void visit(Kwd::Extern *n) { apply("visit_extern", n);}
133//   virtual void visit(Kwd::Float *n) { apply("visit_float", n);}
134//   virtual void visit(Kwd::Friend *n) { apply("visit_friend", n);}
135//   virtual void visit(Kwd::Inline *n) { apply("visit_inline", n);}
136//   virtual void visit(Kwd::Int *n) { apply("visit_int", n);}
137//   virtual void visit(Kwd::Long *n) { apply("visit_long", n);}
138//   virtual void visit(Kwd::Mutable *n) { apply("visit_mutable", n);}
139//   virtual void visit(Kwd::Namespace *n) { apply("visit_namespace", n);}
140//   virtual void visit(Kwd::Private *n) { apply("visit_private", n);}
141//   virtual void visit(Kwd::Protected *n) { apply("visit_protected", n);}
142//   virtual void visit(Kwd::Public *n) { apply("visit_public", n);}
143//   virtual void visit(Kwd::Register *n) { apply("visit_register", n);}
144//   virtual void visit(Kwd::Short *n) { apply("visit_short", n);}
145//   virtual void visit(Kwd::Signed *n) { apply("visit_signed", n);}
146//   virtual void visit(Kwd::Static *n) { apply("visit_static", n);}
147//   virtual void visit(Kwd::Unsigned *n) { apply("visit_unsigned", n);}
148//   virtual void visit(Kwd::Using *n) { apply("visit_using_", n);}
149//   virtual void visit(Kwd::Virtual *n) { apply("visit_virtual", n);}
150//   virtual void visit(Kwd::Void *n) { apply("visit_void", n);}
151//   virtual void visit(Kwd::Volatile *n) { apply("visit_volatile", n);}
152  virtual void visit(Brace *n) { apply("visit_brace", n);}
153  virtual void visit(Block *n) { apply("visit_block", n);}
154  virtual void visit(ClassBody *n) { apply("visit_class_body", n);}
155  virtual void visit(Typedef *n) { apply("visit_typedef", n);}
156  virtual void visit(TemplateDecl *n) { apply("visit_template_decl", n);}
157  virtual void visit(TemplateInstantiation *n) { apply("visit_template_instantiation", n);}
158  virtual void visit(ExternTemplate *n) { apply("visit_extern_template", n);}
159  virtual void visit(MetaclassDecl *n) { apply("visit_metaclass_decl", n);}
160  virtual void visit(LinkageSpec *n) { apply("visit_linkage_spec", n);}
161  virtual void visit(NamespaceSpec *n) { apply("visit_namespace_spec", n);}
162  virtual void visit(NamespaceAlias *n) { apply("visit_namespace_alias", n);}
163  virtual void visit(UsingDirective *n) { apply("visit_using_directive", n);}
164  virtual void visit(Declaration *n) { apply("visit_declaration", n);}
165  virtual void visit(FunctionDefinition *n) { apply("visit_function_definition", n);}
166  virtual void visit(ParameterDeclaration *n) { apply("visit_parameter_declaration", n);}
167  virtual void visit(UsingDeclaration *n) { apply("visit_using_declaration", n);}
168  virtual void visit(Declarator *n) { apply("visit_declarator", n);}
169  virtual void visit(Name *n) { apply("visit_name", n);}
170  virtual void visit(FstyleCastExpr *n) { apply("visit_fstyle_cast_expr", n);}
171  virtual void visit(ClassSpec *n) { apply("visit_class_spec", n);}
172  virtual void visit(EnumSpec *n) { apply("visit_enum_spec", n);}
173  virtual void visit(AccessSpec *n) { apply("visit_access_spec", n);}
174  virtual void visit(AccessDecl *n) { apply("visit_access_decl", n);}
175  virtual void visit(UserAccessSpec *n) { apply("visit_user_access_spec", n);}
176  virtual void visit(IfStatement *n) { apply("visit_if_statement", n);}
177  virtual void visit(SwitchStatement *n) { apply("visit_switch_statement", n);}
178  virtual void visit(WhileStatement *n) { apply("visit_while_statement", n);}
179  virtual void visit(DoStatement *n) { apply("visit_do_statement", n);}
180  virtual void visit(ForStatement *n) { apply("visit_for_statement", n);}
181  virtual void visit(TryStatement *n) { apply("visit_try_statement", n);}
182  virtual void visit(BreakStatement *n) { apply("visit_break_statement", n);}
183  virtual void visit(ContinueStatement *n) { apply("visit_continue_statement", n);}
184  virtual void visit(ReturnStatement *n) { apply("visit_return_statement", n);}
185  virtual void visit(GotoStatement *n) { apply("visit_goto_statement", n);}
186  virtual void visit(CaseStatement *n) { apply("visit_case_statement", n);}
187  virtual void visit(DefaultStatement *n) { apply("visit_default_statement", n);}
188  virtual void visit(LabelStatement *n) { apply("visit_label_statement", n);}
189  virtual void visit(ExprStatement *n) { apply("visit_expr_statement", n);}
190  virtual void visit(Expression *n) { apply("visit_expression", n);}
191  virtual void visit(AssignExpr *n) { apply("visit_assign_expr", n);}
192  virtual void visit(CondExpr *n) { apply("visit_cond_expr", n);}
193  virtual void visit(InfixExpr *n) { apply("visit_infix_expr", n);}
194  virtual void visit(PmExpr *n) { apply("visit_pm_expr", n);}
195  virtual void visit(CastExpr *n) { apply("visit_cast_expr", n);}
196  virtual void visit(UnaryExpr *n) { apply("visit_unary_expr", n);}
197  virtual void visit(ThrowExpr *n) { apply("visit_throw_expr", n);}
198  virtual void visit(SizeofExpr *n) { apply("visit_sizeof_expr", n);}
199  virtual void visit(TypeidExpr *n) { apply("visit_typeid_expr", n);}
200  virtual void visit(TypeofExpr *n) { apply("visit_typeof_expr", n);}
201  virtual void visit(NewExpr *n) { apply("visit_new_expr", n);}
202  virtual void visit(DeleteExpr *n) { apply("visit_delete_expr", n);}
203  virtual void visit(ArrayExpr *n) { apply("visit_array_expr", n);}
204  virtual void visit(FuncallExpr *n) { apply("visit_funcall_expr", n);}
205  virtual void visit(PostfixExpr *n) { apply("visit_postfix_expr", n);}
206  virtual void visit(DotMemberExpr *n) { apply("visit_dot_member_expr", n);}
207  virtual void visit(ArrowMemberExpr *n) { apply("visit_arrow_member_expr", n);}
208  virtual void visit(ParenExpr *n) { apply("visit_paren_expr", n);}
209
210private:
211  void apply(char const *f, Node* n) { bpl::call_method<void>(self, f, bpl::ptr(n));}
212
213  PyObject *self;
214};
215
216std::string as_string(Encoding const &e) 
217{
218  std::ostringstream oss;
219  oss << e;
220  return oss.str();
221}
222
223void accept(Node *n, Visitor *v) { n->accept(v);}
224std::string atom_value(Atom *a) { return std::string(a->position(), a->length());}
225Node *car(List *l) { return l->car();}
226Node *cdr(List *l) { return l->cdr();}
227Node *first_(List *l) { return PTree::first(l);}
228Node *second_(List *l) { return PTree::second(l);}
229Node *third_(List *l) { return PTree::third(l);}
230Node *nth_(List *l, size_t k) { return PTree::nth(l, k);}
231Node *rest_(List *l) { return PTree::rest(l);}
232Node *tail_(List *l, size_t k) { return PTree::tail(l, k);}
233
234}
235
236BOOST_PYTHON_MODULE(PTree)
237{
238  bpl::class_<Encoding> encoding("Encoding");
239  encoding.def("__str__", as_string);
240  encoding.def("unmangled", &Encoding::unmangled);
241  encoding.add_property("is_simple_name", &Encoding::is_simple_name);
242  encoding.add_property("is_global_scope", &Encoding::is_global_scope);
243  encoding.add_property("is_qualified", &Encoding::is_qualified);
244  encoding.add_property("is_function", &Encoding::is_function);
245  encoding.add_property("is_template", &Encoding::is_template);
246
247  bpl::class_<Visitor, boost::noncopyable, VisitorWrapper> visitor("Visitor");
248  visitor.def("visit_node", &VisitorWrapper::visit_node);
249  visitor.def("visit_atom", &VisitorWrapper::visit_atom);
250  visitor.def("visit_list", &VisitorWrapper::visit_list);
251  visitor.def("visit_literal", &VisitorWrapper::visit_literal);
252  visitor.def("visit_commented_atom", &VisitorWrapper::visit_commented_atom);
253  visitor.def("visit_dup_atom", &VisitorWrapper::visit_dup_atom);
254  visitor.def("visit_identifier", &VisitorWrapper::visit_identifier);
255  visitor.def("visit_keyword", &VisitorWrapper::visit_keyword);
256//   visitor.def("visit_this", &VisitorWrapper::visit_this);
257//   visitor.def("visit_auto", &VisitorWrapper::visit_auto);
258//   visitor.def("visit_boolean", &VisitorWrapper::visit_boolean);
259//   visitor.def("visit_char", &VisitorWrapper::visit_char);
260//   visitor.def("visit_wchar", &VisitorWrapper::visit_wchar);
261//   visitor.def("visit_const", &VisitorWrapper::visit_const);
262//   visitor.def("visit_double", &VisitorWrapper::visit_double);
263//   visitor.def("visit_extern", &VisitorWrapper::visit_extern);
264//   visitor.def("visit_float", &VisitorWrapper::visit_float);
265//   visitor.def("visit_friend", &VisitorWrapper::visit_friend);
266//   visitor.def("visit_inline", &VisitorWrapper::visit_inline);
267//   visitor.def("visit_int", &VisitorWrapper::visit_int);
268//   visitor.def("visit_long", &VisitorWrapper::visit_long);
269//   visitor.def("visit_mutable", &VisitorWrapper::visit_mutable);
270//   visitor.def("visit_namespace", &VisitorWrapper::visit_namespace);
271//   visitor.def("visit_private", &VisitorWrapper::visit_private);
272//   visitor.def("visit_protected", &VisitorWrapper::visit_protected);
273//   visitor.def("visit_public", &VisitorWrapper::visit_public);
274//   visitor.def("visit_register", &VisitorWrapper::visit_register);
275//   visitor.def("visit_short", &VisitorWrapper::visit_short);
276//   visitor.def("visit_signed", &VisitorWrapper::visit_signed);
277//   visitor.def("visit_static", &VisitorWrapper::visit_static);
278//   visitor.def("visit_unsigned", &VisitorWrapper::visit_unsigned);
279//   visitor.def("visit_using_", &VisitorWrapper::visit_using_);
280//   visitor.def("visit_virtual", &VisitorWrapper::visit_virtual);
281//   visitor.def("visit_void", &VisitorWrapper::visit_void);
282//   visitor.def("visit_volatile", &VisitorWrapper::visit_volatile);
283  visitor.def("visit_brace", &VisitorWrapper::visit_brace);
284  visitor.def("visit_block", &VisitorWrapper::visit_block);
285  visitor.def("visit_class_body", &VisitorWrapper::visit_class_body);
286  visitor.def("visit_typedef", &VisitorWrapper::visit_typedef);
287  visitor.def("visit_template_decl", &VisitorWrapper::visit_template_decl);
288  visitor.def("visit_template_instantiation", &VisitorWrapper::visit_template_instantiation);
289  visitor.def("visit_extern_template", &VisitorWrapper::visit_extern_template);
290  visitor.def("visit_metaclass_decl", &VisitorWrapper::visit_metaclass_decl);
291  visitor.def("visit_linkage_spec", &VisitorWrapper::visit_linkage_spec);
292  visitor.def("visit_namespace_spec", &VisitorWrapper::visit_namespace_spec);
293  visitor.def("visit_namespace_alias", &VisitorWrapper::visit_namespace_alias);
294  visitor.def("visit_using_directive", &VisitorWrapper::visit_using_directive);
295  visitor.def("visit_declaration", &VisitorWrapper::visit_declaration);
296  visitor.def("visit_parameter_declaration", &VisitorWrapper::visit_parameter_declaration);
297  visitor.def("visit_using_declaration", &VisitorWrapper::visit_using_declaration);
298  visitor.def("visit_declarator", &VisitorWrapper::visit_declarator);
299  visitor.def("visit_name", &VisitorWrapper::visit_name);
300  visitor.def("visit_fstyle_cast_expr", &VisitorWrapper::visit_fstyle_cast_expr);
301  visitor.def("visit_class_spec", &VisitorWrapper::visit_class_spec);
302  visitor.def("visit_enum_spec", &VisitorWrapper::visit_enum_spec);
303  visitor.def("visit_access_spec", &VisitorWrapper::visit_access_spec);
304  visitor.def("visit_access_decl", &VisitorWrapper::visit_access_decl);
305  visitor.def("visit_user_access_spec", &VisitorWrapper::visit_user_access_spec);
306  visitor.def("visit_if_statement", &VisitorWrapper::visit_if_statement);
307  visitor.def("visit_switch_statement", &VisitorWrapper::visit_switch_statement);
308  visitor.def("visit_while_statement", &VisitorWrapper::visit_while_statement);
309  visitor.def("visit_do_statement", &VisitorWrapper::visit_do_statement);
310  visitor.def("visit_for_statement", &VisitorWrapper::visit_for_statement);
311  visitor.def("visit_try_statement", &VisitorWrapper::visit_try_statement);
312  visitor.def("visit_break_statement", &VisitorWrapper::visit_break_statement);
313  visitor.def("visit_continue_statement", &VisitorWrapper::visit_continue_statement);
314  visitor.def("visit_return_statement", &VisitorWrapper::visit_return_statement);
315  visitor.def("visit_goto_statement", &VisitorWrapper::visit_goto_statement);
316  visitor.def("visit_case_statement", &VisitorWrapper::visit_case_statement);
317  visitor.def("visit_default_statement", &VisitorWrapper::visit_default_statement);
318  visitor.def("visit_label_statement", &VisitorWrapper::visit_label_statement);
319  visitor.def("visit_expr_statement", &VisitorWrapper::visit_expr_statement);
320  visitor.def("visit_expression", &VisitorWrapper::visit_expression);
321  visitor.def("visit_assign_expr", &VisitorWrapper::visit_assign_expr);
322  visitor.def("visit_cond_expr", &VisitorWrapper::visit_cond_expr);
323  visitor.def("visit_infix_expr", &VisitorWrapper::visit_infix_expr);
324  visitor.def("visit_pm_expr", &VisitorWrapper::visit_pm_expr);
325  visitor.def("visit_cast_expr", &VisitorWrapper::visit_cast_expr);
326  visitor.def("visit_unary_expr", &VisitorWrapper::visit_unary_expr);
327  visitor.def("visit_throw_expr", &VisitorWrapper::visit_throw_expr);
328  visitor.def("visit_sizeof_expr", &VisitorWrapper::visit_sizeof_expr);
329  visitor.def("visit_typeid_expr", &VisitorWrapper::visit_typeid_expr);
330  visitor.def("visit_typeof_expr", &VisitorWrapper::visit_typeof_expr);
331  visitor.def("visit_new_expr", &VisitorWrapper::visit_new_expr);
332  visitor.def("visit_delete_expr", &VisitorWrapper::visit_delete_expr);
333  visitor.def("visit_array_expr", &VisitorWrapper::visit_array_expr);
334  visitor.def("visit_funcall_expr", &VisitorWrapper::visit_funcall_expr);
335  visitor.def("visit_postfix_expr", &VisitorWrapper::visit_postfix_expr);
336  visitor.def("visit_dot_member_expr", &VisitorWrapper::visit_dot_member_expr);
337  visitor.def("visit_arrow_member_expr", &VisitorWrapper::visit_arrow_member_expr);
338  visitor.def("visit_paren_expr", &VisitorWrapper::visit_paren_expr);
339
340  bpl::class_<Node, Node *, boost::noncopyable> node("Node", bpl::no_init);
341  // no idea why we can't pass &Node::accept here, but if we do,
342  // the registry will complain that there is no lvalue conversion...
343  node.def("accept", accept);
344  bpl::class_<Atom, bpl::bases<Node>, Atom *, boost::noncopyable> atom("Atom", bpl::no_init);
345  atom.def("__str__", atom_value);
346  atom.add_property("position", &Atom::position);
347  atom.add_property("length", &Atom::length);
348  bpl::class_<List, bpl::bases<Node>, List *, boost::noncopyable> list("List", bpl::no_init);
349  // The PTree module uses garbage collection so just ignore memory management,
350  // at least for now.
351  list.def("car", car, bpl::return_value_policy<bpl::reference_existing_object>());
352  list.def("cdr", cdr, bpl::return_value_policy<bpl::reference_existing_object>());
353  list.def("first", first_, bpl::return_value_policy<bpl::reference_existing_object>());
354  list.def("second", second_, bpl::return_value_policy<bpl::reference_existing_object>());
355  list.def("third", third_, bpl::return_value_policy<bpl::reference_existing_object>());
356  list.def("nth", nth_, bpl::return_value_policy<bpl::reference_existing_object>());
357  list.def("rest", rest_, bpl::return_value_policy<bpl::reference_existing_object>());
358  list.def("tail", tail_, bpl::return_value_policy<bpl::reference_existing_object>());
359  list.add_property("name", &List::encoded_name);
360  list.add_property("type", &List::encoded_type);
361
362  // various atoms
363
364  bpl::class_<Literal, bpl::bases<Atom>, Literal *, boost::noncopyable> literal("Literal", bpl::no_init);
365  bpl::class_<CommentedAtom, bpl::bases<Atom>, CommentedAtom *, boost::noncopyable> comment_atom("CommentedAtom", bpl::no_init);
366  bpl::class_<DupAtom, bpl::bases<CommentedAtom>, DupAtom *, boost::noncopyable> dup_atom("DupAtom", bpl::no_init);
367  bpl::class_<Identifier, bpl::bases<CommentedAtom>, Identifier *, boost::noncopyable> identifier("Identifier", bpl::no_init);
368  bpl::class_<Keyword, bpl::bases<CommentedAtom>, Keyword *, boost::noncopyable> reserved("Keyword", bpl::no_init);
369//   bpl::class_<This, bpl::bases<Reserved>, This *, boost::noncopyable> this_("This", bpl::no_init);
370//   bpl::class_<AtomAUTO, bpl::bases<Reserved>, AtomAUTO *, boost::noncopyable> atom_auto("AtomAUTO", bpl::no_init);
371//   bpl::class_<AtomBOOLEAN, bpl::bases<Reserved>, AtomBOOLEAN *, boost::noncopyable> atom_boolean("AtomBOOLEAN", bpl::no_init);
372//   bpl::class_<AtomCHAR, bpl::bases<Reserved>, AtomCHAR *, boost::noncopyable> atom_char("AtomCHAR", bpl::no_init);
373//   bpl::class_<AtomWCHAR, bpl::bases<Reserved>, AtomWCHAR *, boost::noncopyable> atom_wchar("AtomWCHAR", bpl::no_init);
374//   bpl::class_<AtomCONST, bpl::bases<Reserved>, AtomCONST *, boost::noncopyable> atom_const("AtomCONST", bpl::no_init);
375//   bpl::class_<AtomDOUBLE, bpl::bases<Reserved>, AtomDOUBLE *, boost::noncopyable> atom_double("AtomDOUBLE", bpl::no_init);
376//   bpl::class_<AtomEXTERN, bpl::bases<Reserved>, AtomEXTERN *, boost::noncopyable> atom_extern("AtomEXTERN", bpl::no_init);
377//   bpl::class_<AtomFLOAT, bpl::bases<Reserved>, AtomFLOAT *, boost::noncopyable> atom_float("AtomFLOAT", bpl::no_init);
378//   bpl::class_<AtomFRIEND, bpl::bases<Reserved>, AtomFRIEND *, boost::noncopyable> atom_friend("AtomFRIEND", bpl::no_init);
379//   bpl::class_<AtomINLINE, bpl::bases<Reserved>, AtomINLINE *, boost::noncopyable> atom_inline("AtomINLINE", bpl::no_init);
380//   bpl::class_<AtomINT, bpl::bases<Reserved>, AtomINT *, boost::noncopyable> atom_int("AtomINT", bpl::no_init);
381//   bpl::class_<AtomLONG, bpl::bases<Reserved>, AtomLONG *, boost::noncopyable> atom_long("AtomLONG", bpl::no_init);
382//   bpl::class_<AtomMUTABLE, bpl::bases<Reserved>, AtomMUTABLE *, boost::noncopyable> atom_mutable("AtomMUTABLE", bpl::no_init);
383//   bpl::class_<AtomNAMESPACE, bpl::bases<Reserved>, AtomNAMESPACE *, boost::noncopyable> atom_namespace("AtomNAMESPACE", bpl::no_init);
384//   bpl::class_<AtomPRIVATE, bpl::bases<Reserved>, AtomPRIVATE *, boost::noncopyable> atom_private("AtomPRIVATE", bpl::no_init);
385//   bpl::class_<AtomPROTECTED, bpl::bases<Reserved>, AtomPROTECTED *, boost::noncopyable> atom_protected("AtomPROTECTED", bpl::no_init);
386//   bpl::class_<AtomPUBLIC, bpl::bases<Reserved>, AtomPUBLIC *, boost::noncopyable> atom_public("AtomPUBLIC", bpl::no_init);
387//   bpl::class_<AtomREGISTER, bpl::bases<Reserved>, AtomREGISTER *, boost::noncopyable> atom_register("AtomREGISTER", bpl::no_init);
388//   bpl::class_<AtomSHORT, bpl::bases<Reserved>, AtomSHORT *, boost::noncopyable> atom_short("AtomSHORT", bpl::no_init);
389//   bpl::class_<AtomSIGNED, bpl::bases<Reserved>, AtomSIGNED *, boost::noncopyable> atom_signed("AtomSIGNED", bpl::no_init);
390//   bpl::class_<AtomSTATIC, bpl::bases<Reserved>, AtomSTATIC *, boost::noncopyable> atom_static("AtomSTATIC", bpl::no_init);
391//   bpl::class_<AtomUNSIGNED, bpl::bases<Reserved>, AtomUNSIGNED *, boost::noncopyable> atom_unsigned("AtomUNSIGNED", bpl::no_init);
392//   bpl::class_<AtomUSING, bpl::bases<Reserved>, AtomUSING *, boost::noncopyable> atom_using("AtomUSING", bpl::no_init);
393//   bpl::class_<AtomVIRTUAL, bpl::bases<Reserved>, AtomVIRTUAL *, boost::noncopyable> atom_virtual("AtomVIRTUAL", bpl::no_init);
394//   bpl::class_<AtomVOID, bpl::bases<Reserved>, AtomVOID *, boost::noncopyable> atom_void("AtomVOID", bpl::no_init);
395//   bpl::class_<AtomVOLATILE, bpl::bases<Reserved>, AtomVOLATILE *, boost::noncopyable> atom_volatile("AtomVOLATILE", bpl::no_init);
396//   bpl::class_<AtomUserKeyword2, bpl::bases<Reserved>, AtomUserKeyword2 *, boost::noncopyable> atom_user_kwd2("AtomUserKeyword2", bpl::no_init);
397
398  // various lists
399
400  bpl::class_<Brace, bpl::bases<List>, Brace *, boost::noncopyable> brace("Brace", bpl::no_init);
401  bpl::class_<Block, bpl::bases<Brace>, Block *, boost::noncopyable> block("Block", bpl::no_init);
402  bpl::class_<ClassBody, bpl::bases<Brace>, ClassBody *, boost::noncopyable> class_body("ClassBody", bpl::no_init);
403  bpl::class_<Typedef, bpl::bases<List>, Typedef *, boost::noncopyable> typedef_("Typedef", bpl::no_init);
404  bpl::class_<TemplateDecl, bpl::bases<List>, TemplateDecl *, boost::noncopyable> template_decl("TemplateDecl", bpl::no_init);
405  bpl::class_<TemplateInstantiation, bpl::bases<List>, TemplateInstantiation *, boost::noncopyable> template_instantiation("TemplateInstantiation", bpl::no_init);
406  bpl::class_<ExternTemplate, bpl::bases<List>, ExternTemplate *, boost::noncopyable> extern_template("ExternTemplate", bpl::no_init);
407  bpl::class_<MetaclassDecl, bpl::bases<List>, MetaclassDecl *, boost::noncopyable> meta_class_decl("MetaclassDecl", bpl::no_init);
408  bpl::class_<LinkageSpec, bpl::bases<List>, LinkageSpec *, boost::noncopyable> linkage_spec("LinkageSpec", bpl::no_init);
409  bpl::class_<NamespaceSpec, bpl::bases<List>, NamespaceSpec *, boost::noncopyable> namespace_spec("NamespaceSpec", bpl::no_init);
410  bpl::class_<Declaration, bpl::bases<List>, Declaration *, boost::noncopyable> declaration("Declaration", bpl::no_init);
411  bpl::class_<NamespaceAlias, bpl::bases<Declaration>, NamespaceAlias *, boost::noncopyable> namespace_alias("NamespaceAlias", bpl::no_init);
412  bpl::class_<UsingDirective, bpl::bases<Declaration>, UsingDirective *, boost::noncopyable> using_directive("UsingDirective", bpl::no_init);
413  bpl::class_<UsingDeclaration, bpl::bases<Declaration>, UsingDeclaration *, boost::noncopyable> using_declaration("UsingDeclaration", bpl::no_init);
414  bpl::class_<FunctionDefinition, bpl::bases<Declaration>, FunctionDefinition *, boost::noncopyable> function_definition("FunctionDefinition", bpl::no_init);
415  bpl::class_<ParameterDeclaration, bpl::bases<List>, ParameterDeclaration *, boost::noncopyable> parameter_declaration("ParameterDeclaration", bpl::no_init);
416  bpl::class_<Declarator, bpl::bases<List>, Declarator *, boost::noncopyable> declarator("Declarator", bpl::no_init);
417  declarator.add_property("initializer", 
418			  bpl::make_function(&Declarator::initializer, 
419					     bpl::return_internal_reference<>()));
420  bpl::class_<Name, bpl::bases<List>, Name *, boost::noncopyable> name("Name", bpl::no_init);
421  bpl::class_<FstyleCastExpr, bpl::bases<List>, FstyleCastExpr *, boost::noncopyable> fstyle_cast_expr("FstyleCastExpr", bpl::no_init);
422  bpl::class_<ClassSpec, bpl::bases<List>, ClassSpec *, boost::noncopyable> class_spec("ClassSpec", bpl::no_init);
423  bpl::class_<EnumSpec, bpl::bases<List>, EnumSpec *, boost::noncopyable> enum_spec("EnumSpec", bpl::no_init);
424  bpl::class_<AccessSpec, bpl::bases<List>, AccessSpec *, boost::noncopyable> access_spec("AccessSpec", bpl::no_init);
425  bpl::class_<AccessDecl, bpl::bases<List>, AccessDecl *, boost::noncopyable> access_decl("AccessDecl", bpl::no_init);
426  bpl::class_<UserAccessSpec, bpl::bases<List>, UserAccessSpec *, boost::noncopyable> user_access_spec("UserAccessSpec", bpl::no_init);
427  bpl::class_<UserdefKeyword, bpl::bases<List>, UserdefKeyword *, boost::noncopyable> user_def_kwd("UserdefKeyword", bpl::no_init);
428
429  // statements
430
431  bpl::class_<IfStatement, bpl::bases<List>, IfStatement *, boost::noncopyable> if_statement("IfStatement", bpl::no_init);
432  bpl::class_<SwitchStatement, bpl::bases<List>, SwitchStatement *, boost::noncopyable> switch_statement("SwitchStatement", bpl::no_init);
433  bpl::class_<WhileStatement, bpl::bases<List>, WhileStatement *, boost::noncopyable> while_statement("WhileStatement", bpl::no_init);
434  bpl::class_<DoStatement, bpl::bases<List>, DoStatement *, boost::noncopyable> do_statement("DoStatement", bpl::no_init);
435  bpl::class_<ForStatement, bpl::bases<List>, ForStatement *, boost::noncopyable> for_statement("ForStatement", bpl::no_init);
436  bpl::class_<TryStatement, bpl::bases<List>, TryStatement *, boost::noncopyable> try_statement("TryStatement", bpl::no_init);
437  bpl::class_<BreakStatement, bpl::bases<List>, BreakStatement *, boost::noncopyable> break_statement("BreakStatement", bpl::no_init);
438  bpl::class_<ContinueStatement, bpl::bases<List>, ContinueStatement *, boost::noncopyable> continue_statement("ContinueStatement", bpl::no_init);
439  bpl::class_<ReturnStatement, bpl::bases<List>, ReturnStatement *, boost::noncopyable> return_statement("ReturnStatement", bpl::no_init);
440  bpl::class_<GotoStatement, bpl::bases<List>, GotoStatement *, boost::noncopyable> goto_statement("GotoStatement", bpl::no_init);
441  bpl::class_<CaseStatement, bpl::bases<List>, CaseStatement *, boost::noncopyable> case_statement("CaseStatement", bpl::no_init);
442  bpl::class_<DefaultStatement, bpl::bases<List>, DefaultStatement *, boost::noncopyable> default_statement("DefaultStatement", bpl::no_init);
443  bpl::class_<LabelStatement, bpl::bases<List>, LabelStatement *, boost::noncopyable> label_statement("LabelStatement", bpl::no_init);
444  bpl::class_<ExprStatement, bpl::bases<List>, ExprStatement *, boost::noncopyable> expr_statement("ExprStatement", bpl::no_init);
445
446  // expressions
447
448  bpl::class_<Expression, bpl::bases<List>, Expression *, boost::noncopyable> expression("Expression", bpl::no_init);
449  bpl::class_<AssignExpr, bpl::bases<List>, AssignExpr *, boost::noncopyable> assign_expr("AssignExpr", bpl::no_init);
450  bpl::class_<CondExpr, bpl::bases<List>, CondExpr *, boost::noncopyable> cond_expr("CondExpr", bpl::no_init);
451  bpl::class_<InfixExpr, bpl::bases<List>, InfixExpr *, boost::noncopyable> infix_expr("InfixExpr", bpl::no_init);
452  bpl::class_<PmExpr, bpl::bases<List>, PmExpr *, boost::noncopyable> pm_expr("PmExpr", bpl::no_init);
453  bpl::class_<CastExpr, bpl::bases<List>, CastExpr *, boost::noncopyable> cast_expr("CastExpr", bpl::no_init);
454  bpl::class_<UnaryExpr, bpl::bases<List>, UnaryExpr *, boost::noncopyable> unary_expr("UnaryExpr", bpl::no_init);
455  bpl::class_<ThrowExpr, bpl::bases<List>, ThrowExpr *, boost::noncopyable> throw_expr("ThrowExpr", bpl::no_init);
456  bpl::class_<SizeofExpr, bpl::bases<List>, SizeofExpr *, boost::noncopyable> sizeof_expr("SizeofExpr", bpl::no_init);
457  bpl::class_<TypeidExpr, bpl::bases<List>, TypeidExpr *, boost::noncopyable> typeid_expr("TypeidExpr", bpl::no_init);
458  bpl::class_<TypeofExpr, bpl::bases<List>, TypeofExpr *, boost::noncopyable> typeof_expr("TypeofExpr", bpl::no_init);
459  bpl::class_<NewExpr, bpl::bases<List>, NewExpr *, boost::noncopyable> new_expr("NewExpr", bpl::no_init);
460  bpl::class_<DeleteExpr, bpl::bases<List>, DeleteExpr *, boost::noncopyable> delete_expr("DeleteExpr", bpl::no_init);
461  bpl::class_<ArrayExpr, bpl::bases<List>, ArrayExpr *, boost::noncopyable> array_expr("ArrayExpr", bpl::no_init);
462  bpl::class_<FuncallExpr, bpl::bases<List>, FuncallExpr *, boost::noncopyable> funcall_expr("FuncallExpr", bpl::no_init);
463  bpl::class_<PostfixExpr, bpl::bases<List>, PostfixExpr *, boost::noncopyable> postfix_expr("PostfixExpr", bpl::no_init);
464  bpl::class_<UserStatementExpr, bpl::bases<List>, UserStatementExpr *, boost::noncopyable> user_statement_expr("UserStatementExpr", bpl::no_init);
465  bpl::class_<DotMemberExpr, bpl::bases<List>, DotMemberExpr *, boost::noncopyable> dot_member_expr("DotMemberExpr", bpl::no_init);
466  bpl::class_<ArrowMemberExpr, bpl::bases<List>, ArrowMemberExpr *, boost::noncopyable> arrow_member_expr("ArrowMemberExpr", bpl::no_init);
467  bpl::class_<ParenExpr, bpl::bases<List>, ParenExpr *, boost::noncopyable> paren_expr("ParenExpr", bpl::no_init);
468  bpl::class_<StaticUserStatementExpr, bpl::bases<List>, StaticUserStatementExpr *, boost::noncopyable> static_user_statement_expr("StaticUserStatementExpr", bpl::no_init);
469}