class AtomicType {
public:
- AtomicType()
- : parent(0)
+ AtomicType() :
+ name(),
+ parent(0)
{ }
virtual ~AtomicType()
{ }
std::string name;
Namespace* parent;
+
+private:
+ AtomicType(const AtomicType&);
+ AtomicType& operator=(const AtomicType&);
};
class BasicType : public AtomicType {
private:
BasicType(const std::string& name)
- {
+ {
this->name = name;
- }
+ }
};
class Type {
public:
- Type()
+ Type()
: atomic_type(0), _unsigned(false), _const(false), _static(false),
pointer(0), ref(0)
{ }
void write_c_type(std::ostream& out)
{
if(_static)
- out << "static ";
+ out << "static ";
if(_const)
out << "const ";
atomic_type->write_c(out);
int ref;
};
+class SQIntegerType : public AtomicType {
+public:
+ SQIntegerType()
+ {
+ this->name = "SQInteger";
+ assert(_instance == 0);
+ _instance = this;
+ }
+ virtual ~SQIntegerType()
+ {
+ assert(_instance == this);
+ _instance = NULL;
+ }
+
+ static SQIntegerType* instance()
+ {
+ return _instance;
+ }
+private:
+ static SQIntegerType* _instance;
+};
+
class HSQUIRRELVMType : public AtomicType {
public:
HSQUIRRELVMType()
virtual ~HSQUIRRELVMType()
{
assert(_instance == this);
- _instance = 0;
+ _instance = NULL;
}
static HSQUIRRELVMType* instance()
}
private:
- static StringType* _instance;
+ static StringType* _instance;
};
-class Parameter {
+class Parameter
+{
public:
+ Parameter() :
+ name(),
+ type()
+ { }
+
std::string name;
Type type;
};
class ClassMember {
public:
+ ClassMember() :
+ visibility()
+ { }
virtual ~ClassMember()
{ }
- enum Visbility {
+ enum Visibility {
PUBLIC,
PROTECTED,
PRIVATE
};
- Visbility visibility;
+ Visibility visibility;
};
class Function : public ClassMember {
public:
+ Function() :
+ type(),
+ suspend(),
+ custom(),
+ parameter_spec(),
+ docu_comment(),
+ name(),
+ return_type(),
+ parameters()
+ {
+ type = FUNCTION;
+ suspend = false;
+ custom = false;
+ }
+
enum FuncType {
FUNCTION,
CONSTRUCTOR,
DESTRUCTOR
};
FuncType type;
+ /// function should suspend squirrel VM after execution
+ bool suspend;
+ /// a custom wrapper (just pass along HSQUIRRELVM)
+ bool custom;
+ std::string parameter_spec;
std::string docu_comment;
std::string name;
Type return_type;
std::vector<Parameter> parameters;
};
+class Field : public ClassMember {
+public:
+ Field() :
+ type(),
+ docu_comment(),
+ name(),
+ has_const_value(),
+ const_float_value(),
+ const_int_value(),
+ const_string_value()
+ {
+ has_const_value = false;
+ }
+
+ Type* type;
+ std::string docu_comment;
+ std::string name;
+ bool has_const_value;
+
+ float const_float_value;
+ int const_int_value;
+ std::string const_string_value;
+
+private:
+ Field(const Field&);
+ Field& operator=(const Field&);
+};
+
class Class : public AtomicType {
public:
+ Class() :
+ members(),
+ super_classes(),
+ sub_classes(),
+ docu_comment()
+ { }
~Class() {
- for(std::vector<ClassMember*>::iterator i = members.begin();
- i != members.end(); ++i)
+ for(std::vector<ClassMember*>::iterator i = members.begin(); i != members.end(); ++i)
delete *i;
}
-
+
std::vector<ClassMember*> members;
+ std::vector<Class*> super_classes;
+ std::vector<Class*> sub_classes;
std::string docu_comment;
};
class Namespace {
public:
- Namespace() {
+ Namespace() :
+ functions(),
+ fields(),
+ types(),
+ namespaces(),
+ parent(),
+ name()
+ {
parent = 0;
}
virtual ~Namespace() {
return ret;
}
-
+
std::vector<Function*> functions;
+ std::vector<Field*> fields;
std::vector<AtomicType*> types;
std::vector<Namespace*> namespaces;
Namespace* parent;
std::string name;
+
+private:
+ Namespace(const Namespace&);
+ Namespace& operator=(const Namespace&);
};
class CompilationUnit : public Namespace {
};
#endif
-