Synopsis - Cross-Reference

  1//
  2// Copyright (C) 2002 Stephen Davies
  3// Copyright (C) 2002 Stefan Seefeld
  4// All rights reserved.
  5// Licensed to the public under the terms of the GNU LGPL (>= 2),
  6// see the file COPYING for details.
  7//
  8
  9#include "STrace.hh"
 10#include "ASG.hh"
 11#include "Types.hh"
 12
 13using namespace ASG;
 14
 15void SourceFile::add_macro_call(char const *name, int l, int s, int e, int o)
 16{
 17  Line &line = macro_calls_[l];
 18  line.insert(MacroCall(name, s, e, o));
 19}
 20
 21int SourceFile::map_column(int l, int col)
 22{
 23  Lines::iterator i = macro_calls_.find(l);
 24  if (i == macro_calls_.end()) return col;
 25  Line &line = i->second;
 26  int offset = 0;
 27  for (Line::iterator j = line.begin(), end = line.end(); j != end && j->start <= col; ++j)
 28  {
 29    if (col <= j->end) return -1;
 30    offset = j->offset;
 31  }
 32  return col - offset;
 33}
 34
 35//
 36// ASG::Include
 37//
 38
 39Include::Include(SourceFile* target, bool is_macro, bool is_next)
 40    : m_target(target), m_is_macro(is_macro), m_is_next(is_next)
 41{ }
 42
 43//
 44// ASG::Declaration
 45//
 46
 47Declaration::Declaration(SourceFile* file, int line, const std::string& type, const ScopedName& name)
 48        : m_file(file), m_line(line), m_type(type), m_name(name), m_access(Default), m_declared(0)
 49{}
 50
 51Declaration::~Declaration()
 52{ }
 53
 54void
 55Declaration::accept(Visitor* visitor)
 56{
 57    visitor->visit_declaration(this);
 58}
 59
 60const Types::Declared*
 61Declaration::declared() const
 62{
 63    if (!m_declared)
 64        // Constness of 'this' is preserved through const return type
 65        m_declared = new Types::Declared(m_name, const_cast<ASG::Declaration*>(this));
 66    return m_declared;
 67}
 68
 69Types::Declared*
 70Declaration::declared()
 71{
 72    if (!m_declared)
 73        m_declared = new Types::Declared(m_name, this);
 74    return m_declared;
 75}
 76
 77//
 78// ASG::Builtin
 79//
 80
 81Builtin::Builtin(SourceFile* file, int line, const std::string &type, const ScopedName& name)
 82    : Declaration(file, line, type, name)
 83{ }
 84
 85Builtin::~Builtin()
 86{ }
 87
 88void
 89Builtin::accept(Visitor* visitor)
 90{
 91    visitor->visit_builtin(this);
 92}
 93
 94//
 95// ASG::Macro
 96//
 97
 98Macro::Macro(SourceFile* file, int line, const ScopedName& name, Parameters* params, const std::string& text)
 99    : Declaration(file, line, "macro", name),
100    m_parameters(params), m_text(text)
101{ }
102
103Macro::~Macro()
104{ }
105
106void
107Macro::accept(Visitor* visitor)
108{
109    visitor->visit_macro(this);
110}
111
112//
113// ASG::Scope
114//
115
116Scope::Scope(SourceFile* file, int line, const std::string& type, const ScopedName& name)
117        : Declaration(file, line, type, name)
118{ }
119
120Scope::~Scope()
121{}
122
123void
124Scope::accept(Visitor* visitor)
125{
126    visitor->visit_scope(this);
127}
128
129//
130// ASG::Namespace
131//
132
133Namespace::Namespace(SourceFile* file, int line, const std::string& type, const ScopedName& name)
134        : Scope(file, line, type, name)
135{}
136
137Namespace::~Namespace()
138{}
139
140void
141Namespace::accept(Visitor* visitor)
142{
143    visitor->visit_namespace(this);
144}
145
146//
147// ASG::Class
148//
149
150Class::Class(SourceFile* file, int line, const std::string& type, const ScopedName& name,
151             bool is_template_specialization)
152  : Scope(file, line, type, name), is_template_specialization_(is_template_specialization)
153{}
154
155Class::~Class() {}
156void Class::accept(Visitor* visitor) { visitor->visit_class(this);}
157
158//
159// ASG::ClassTemplate
160//
161
162ClassTemplate::ClassTemplate(SourceFile* file, int line, const std::string& type, const ScopedName& name,
163                             bool is_specialization)
164  : Class(file, line, type, name, is_specialization),
165    template_(0)
166{}
167
168ClassTemplate::~ClassTemplate() {}
169void ClassTemplate::accept(Visitor* visitor) { visitor->visit_class_template(this);}
170
171//
172// ASG::Inheritance
173//
174
175Inheritance::Inheritance(Types::Type* type, const Attributes& attrs)
176        : m_parent(type), m_attrs(attrs)
177{ }
178
179void
180Inheritance::accept(Visitor* visitor)
181{
182    visitor->visit_inheritance(this);
183}
184
185
186//
187// ASG::Forward
188//
189
190Forward::Forward(SourceFile* file, int line, const std::string& type, const ScopedName& name,
191                 bool is_template_specialization)
192  : Declaration(file, line, type, name), template_(0),
193    is_template_specialization_(is_template_specialization)
194{}
195
196void
197Forward::accept(Visitor* visitor)
198{
199  visitor->visit_forward(this);
200}
201
202
203//
204// ASG::Typedef
205//
206
207Typedef::Typedef(SourceFile* file, int line, const std::string& type, const ScopedName& name, Types::Type* alias, bool constr)
208        : Declaration(file, line, type, name), m_alias(alias), m_constr(constr)
209{ }
210
211Typedef::~Typedef()
212{}
213
214void
215Typedef::accept(Visitor* visitor)
216{
217    visitor->visit_typedef(this);
218}
219
220
221//
222// ASG::Variable
223//
224
225Variable::Variable(SourceFile* file, int line, const std::string& type, const ScopedName& name, Types::Type* vtype, bool constr)
226        : Declaration(file, line, type, name), m_vtype(vtype), m_constr(constr)
227{ }
228
229Variable::~Variable()
230{}
231
232void
233Variable::accept(Visitor* visitor)
234{
235    visitor->visit_variable(this);
236}
237
238//
239// ASG::Const
240//
241
242Const::Const(SourceFile* file, int line, const std::string& type, const ScopedName& name, Types::Type* t, const std::string& v)
243        : Declaration(file, line, type, name), m_ctype(t), m_value(v)
244{ }
245
246void
247Const::accept(Visitor* visitor)
248{
249    visitor->visit_const(this);
250}
251
252
253//
254// ASG::Enum
255//
256
257Enum::Enum(SourceFile* file, int line, const std::string& type, const ScopedName& name)
258        : Declaration(file, line, type, name)
259{ }
260
261Enum::~Enum()
262{}
263
264void
265Enum::accept(Visitor* visitor)
266{
267    visitor->visit_enum(this);
268}
269
270
271//
272// ASG::Enumerator
273//
274
275Enumerator::Enumerator(SourceFile* file, int line, const std::string& type, const ScopedName& name, const std::string& value)
276        : Declaration(file, line, type, name), m_value(value)
277{ }
278
279void
280Enumerator::accept(Visitor* visitor)
281{
282    visitor->visit_enumerator(this);
283}
284
285
286//
287// ASG::Function
288//
289
290Function::Function(
291    SourceFile* file, int line, const std::string& type, const ScopedName& name,
292    const Mods& premod, Types::Type* ret, const Mods& postmod, const std::string& realname
293)
294  : Declaration(file, line, type, name), m_pre(premod), m_ret(ret), m_post(postmod),
295    m_realname(realname), m_template(0)
296{}
297
298Function::~Function()
299{}
300
301void
302Function::accept(Visitor* visitor)
303{
304    visitor->visit_function(this);
305}
306
307
308//
309// ASG::Operation
310//
311
312Operation::Operation(
313    SourceFile* file, int line, const std::string& type, const ScopedName& name,
314    const Mods& premod, Types::Type* ret, const Mods& postmod, const std::string& realname
315)
316  : Function(file, line, type, name, premod, ret, postmod, realname)
317{ }
318
319void
320Operation::accept(Visitor* visitor)
321{
322    visitor->visit_operation(this);
323}
324
325
326//
327// ASG::Parameter
328//
329
330Parameter::Parameter(const Mods& pre, Types::Type* t, const Mods& post, const std::string& name, const std::string& value)
331        : m_pre(pre), m_post(post), m_type(t), m_name(name), m_value(value)
332{ }
333
334Parameter::~Parameter()
335{}
336
337void
338Parameter::accept(Visitor* visitor)
339{
340    visitor->visit_parameter(this);
341}
342
343void UsingDirective::accept(Visitor* visitor)
344{
345    visitor->visit_using_directive(this);
346}
347
348UsingDeclaration::UsingDeclaration(SourceFile* file, int line, ScopedName const& name, Types::Named *d)
349  : Declaration(file, line, "using", name), m_target(d) {}
350
351
352void UsingDeclaration::accept(Visitor* visitor)
353{
354    visitor->visit_using_declaration(this);
355}
356
357
358Comment::Comment(SourceFile* file, int line, const std::string& text, bool suspect)
359        : m_file(file), m_line(line), m_text(text), m_suspect(suspect)
360{ }
361
362//
363// AST::Visitor
364//
365
366Visitor::~Visitor()
367{}
368void Visitor::visit_declaration(Declaration*)
369{}
370
371void Visitor::visit_builtin(Builtin*)
372{}
373
374void Visitor::visit_macro(Macro* d)
375{
376    visit_declaration(d);
377}
378void Visitor::visit_scope(Scope* d)
379{
380    visit_declaration(d);
381}
382void Visitor::visit_namespace(Namespace* d)
383{
384    visit_scope(d);
385}
386void Visitor::visit_class(Class* d)
387{
388    visit_scope(d);
389}
390void Visitor::visit_class_template(ClassTemplate* d)
391{
392    visit_class(d);
393}
394void Visitor::visit_inheritance(Inheritance* d)
395{}
396void Visitor::visit_forward(Forward* d)
397{
398    visit_declaration(d);
399}
400void Visitor::visit_typedef(Typedef* d)
401{
402    visit_declaration(d);
403}
404void Visitor::visit_variable(Variable* d)
405{
406    visit_declaration(d);
407}
408void Visitor::visit_const(Const* d)
409{
410    visit_declaration(d);
411}
412void Visitor::visit_enum(Enum* d)
413{
414    visit_declaration(d);
415}
416void Visitor::visit_enumerator(Enumerator* d)
417{
418    visit_declaration(d);
419}
420void Visitor::visit_function(Function* d)
421{
422    visit_declaration(d);
423}
424void Visitor::visit_operation(Operation* d)
425{
426    visit_function(d);
427}
428void Visitor::visit_parameter(Parameter* d)
429{ }
430
431void Visitor::visit_using_directive(UsingDirective* u)
432{ }
433
434void Visitor::visit_using_declaration(UsingDeclaration* u)
435{ }
436
437// vim: set ts=8 sts=4 sw=4 et: