instrset.h

Go to the documentation of this file.

// instrset.h
//
// uda - universal disassembler
// Date: 2003-05-04
//
// Copyright (c) 2002-2003 Ales Smrcka 
//
// This program is licensed under GNU Library GPL. See the file COPYING.
//
// An interface of loading instruction set from file and creating tables and
// variables. This file including builtin tables in namespace BuiltinTables.
// Tables, Table, TableItem include core of decoding.

#ifndef instrsetH
#define instrsetH

#include <iomanip>
#include <iostream>
#include <fstream>
#include <map>
#include <string>
#include "shared.h"
#include "udaclasses.h"
#include "sections.h"
using namespace std;

class InstrSetException;
class  ScannerException;
class  ParserException;
class  InstructionException;

class InstructionSet;
// Scanner
class Scanner;
// Parser ist. map
class Parser;
// Tables of instructions map. Map of Table
class Tables;
// Abstract table, parent of BuildinTable and Table
class AbstractTable;
// Builtin table
class  BuiltinTable;
// One table of Tables including TableItem
class  Table;
// Item of Table
class TableItem;
// Map of Variable
class Variables;
// Item of Variables
class Variable;

extern const string instrsetdirectory;
extern const string defaultinstrset;
extern InstructionSet instructionset;

class InstrSetException : public Exception {
protected:
    int line;
public:
    InstrSetException(string s, int l=0) : Exception(s) { line=l; }
    virtual ~InstrSetException() {}
    virtual void Print() { cerr<<"Instruction set error at line "<<line<<" : "<<value<<endl; }
};

class ScannerException : public InstrSetException {
public:
    ScannerException(string s, int l) : InstrSetException(s, l) {}
    virtual ~ScannerException() {}
    void Print() { cerr<<"Scanner error at line "<<line<<" : "<<value<<endl; }
};

class ParserException : public InstrSetException {
public:
    ParserException(string s, int l) : InstrSetException(s, l) {}
    virtual ~ParserException() {}
    void Print() { cerr<<"Parser error at line "<<line<<" : "<<value<<endl; }
};

class InstructionException : public InstrSetException {
public:
    string text;
    InstructionException(string s, string t) : InstrSetException(s) { text=t; }
    virtual ~InstructionException() {}
    void Print() { cerr<<"Instruction decoder error: "<<value<<": "<<text<<endl; }
};

class InstructionSet {
    InstructionSet(const InstructionSet&) {}
public:
    Tables *tables;
    Variables *variables;
    InstructionSet();
    ~InstructionSet();
    int LoadFile(const string filename);
    void Load(const string processor);
    void Clear();
};

enum tk_type {
    tk_end=0,
    tk_number,
    tk_text,
    tk_ident,
    tk_equal,
    tk_plus,
    tk_comma,
    tk_semicol,
    tk_parop,
    tk_parcl
};

class Scanner {
    Scanner();
    int unget; //unget char
    int _line;
protected:
    const char *_filename;
    ifstream input; //input stream from file with instruction set
    int getc();
    void ungetc(int c);
public:
    class Token {
    public:
        tk_type type;
        string str_value;
        unsigned int_value;
        Token(tk_type t=tk_end, unsigned i=0) { type=t; int_value=i; }
        operator tk_type() { return type; }
    };
    int line() { return _line; }
    Scanner(const char *filename);
    Token Scan();
};

class Parser {
    Scanner &scanner;
    Tables &tables;
    Variables &variables;
    Parser();
    void Error();
public:
    Parser(Scanner &sc, Tables &t, Variables &v) : scanner(sc), tables(t), variables(v) {}
    void Parse();
};

typedef map<string, AbstractTable*> MTables;

class Tables {
    MTables _tables;
public:
    Variables *variables;
    Tables(Variables *v) { variables=v; }
    ~Tables();
    Table *Add(string name);
    AbstractTable *&Add(string name, AbstractTable *table);
    AbstractTable *&operator [](string index);
    void Reset();
    void Clear();
};

class AbstractTable {
public:
    virtual ~AbstractTable() {}
    virtual string Decode(Section &data, Address addr, unsigned &size);
    virtual void Reset() {}
};

class BuiltinTable : public AbstractTable {};

class Table : public AbstractTable {
    TableItem *_items[256];
public:
    Tables *tables;
    Variables *variables;
    Table(Tables *t=NULL, Variables *v=NULL); //for all items: item=NULL
    virtual ~Table(); //free all items
    TableItem *Add(unsigned mask, unsigned tag, string value, string length);
    string Decode(Section &data, Address addr, unsigned &size);
//    TableItem &operator [](unsigned index) { return *_items[index]; }
    void Reset();
};

class TableItem {
    void Error(const char *c=NULL);
    int CountLength(unsigned lens[]);
    int CountLength(unsigned lens[], string len);
    // Decodes the text (c) with others tables and variables. Fills the length array.
    // lindex is actual index to length array. c is the text. is terminated character.
    // Returns substituted string.
    string Norm(Section &data, Address addr, unsigned lens[], unsigned &lindex, const char *&c, char t=0);
public:
    Tables &tables;
    Variables &variables;
    string value;
    struct Lengths {
        unsigned first_value;
        bool valid[26];
    } lengths;
    TableItem(Tables &t, Variables &v, string value, string lengthstr);
    string Decode(Section &data, Address addr, unsigned &size);
};

typedef map<string, Variable> MVariables;

class Variables {
    MVariables _variables;
public:
    Variable &Add(string name, string defaultvalue="");
    Variable &operator [](string index);
    void Reset();
    void Clear();
};

class Variable {
public:
    string value;
    string defaultvalue;
    Variable(string defaultvalue="") { Variable::value=defaultvalue; Variable::defaultvalue=defaultvalue; }
    void Reset() { value=defaultvalue; }
    operator string() { return value; }
};

namespace BuiltinTables {

//
// Little Endian - Immediate data
//

class Ib : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class Iw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class Id : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class Ibw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class Ibd : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};

//
// Little Endian - Signed Immediate daat
//

class SIb : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class SIw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class SId : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class SIbw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class SIbd : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};

//
// Little Endian - Relative address
//

class Jb : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class Jw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class Jd : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};

//
// Little Endian - Absolute address
//

class Apw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class Apd : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class Aw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class Ad : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};

//
// Big Endian - Immediate data
//

class BIb : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class BIw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class BId : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class BIbw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class BIbd : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};

//
// Big Endian - Signed Immediate daat
//

class SBIb : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class SBIw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class SBId : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class SBIbw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class SBIbd : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};

//
// Big Endian - Relative address
//

class BJb : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class BJw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class BJd : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};

//
// Big Endian - Absolute address
//

class BApw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class BApd : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class BAw : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};
class BAd : public BuiltinTable {
public:
    virtual string Decode(Section &data, Address addr, unsigned &size);
};

} //namespace BuiltinTables
#endif