public:

virtual Declaration* loadModule( const Import& imp ) = 0;

virtual QByteArray moduleSuffix( const MetaActualList& imp ) = 0;

virtual QByteArray modulePath( const QByteArrayList& imp ) = 0;

{

public:

Validator(AstModel* mdl, Importer* imp = 0, bool xref = false);

~Validator();

bool validate(Declaration* module, const Import& import = Import());

Xref takeXref();

struct Error {

QString msg;

RowCol pos;

QString path;

Error( const QString& m, const RowCol& pos, const QString& p):msg(m),pos(pos),path(p){}

};

mutable QList<Error> errors;

protected:

void error( const RowCol&, const QString& msg ) const;

void visitScope( Declaration* scope );

void visitDecl( Declaration* );

void visitImport(Declaration* import);

void visitBody(Statement* body);

void visitExpr(Expression*, Type* hint = 0, bool doNext = true);

void visitType(Type*);

void visitEnum(Type*);

void resolve(Type* nameRef);

void unaryOp(Expression*);

void binaryOp(Expression*);

void arithOp(Expression*);

void relOp(Expression*);

void assigOp(Statement*);

Statement* ifOp(Statement*);

Statement* caseStat(Statement*);

Statement* forStat(Statement*);

void loopStat(Statement*);

void returnOp(Statement*);

Qualident resolve(Expression* nameRef);

typedef QPair<Declaration*,Declaration*> ResolvedQ;

ResolvedQ find(const Qualident& q, const RowCol& pos, Declaration* import = 0);

void selectOp(Expression*);

void callOp(Expression*);

void callOp(Statement*);

void indexOp(Expression*);

void inOp(Expression*);

void isOp(Expression*);

void constructor(Expression*, Type* hint);

Type* deref(Type*) const;

bool checkBuiltinArgs(quint8 builtin, const ExpList& args, Type** ret, const RowCol& pos);

bool evalBuiltin(quint8 builtin, const ExpList& args, QVariant& ret, const RowCol& pos);

void markDecl(Declaration*);

Symbol* markRef(Declaration*, const RowCol&);

Declaration* addHelper(Type*);

bool assigCompat(Type* lhs, Type* rhs) const;

bool assigCompat(Type* lhs, Declaration* rhs) const;

bool assigCompat(Type* lhs, const Expression* rhs) const;

bool paramCompat(Declaration* lhs, const Expression* rhs) const;

bool matchFormals(const QList<Declaration*>& a, const QList<Declaration*>& b) const;

bool matchResultType(Type* lhs, Type* rhs) const;

bool sameType(Type* lhs, Type* rhs) const;

bool equalTypes(Type* lhs, Type* rhs) const;

private:

AstModel* mdl;

Importer* imp;

Declaration* module;

ExpList unresolveds;

QList<Declaration*> scopeStack;

QList<Declaration*> boundProcs;

QList<Statement*> loopStack;

Symbol* first;

Symbol* last;

QHash<Declaration*,SymList> xref;

QHash<Declaration*,DeclList> subs;