windows-xp/Source/XPSP1/NT/sdktools/hdivide/hdivide.cpp

//
// hdivide.cpp -- yet another header file divider
//
// 1998 Nov Hiro Yamamoto
//


#pragma warning(disable: 4786)
#include <cstdio>
#include <string>
#include <cstdarg>
#include <map>
#include <vector>
#include <cassert>

#include <io.h>

#define PROGNAME    "hdivide"
#define VERSION     "1.0"

extern "C" {
    extern int getopt(int argc, char** argv, const char* opts);
    extern int optind;
}

namespace opt {
    bool verbose;
}

namespace input {
    unsigned long length;
    int lineno = 1;
    std::string path;

    std::string strip(const std::string& fname)
    {
        std::string stripped;

        //
        // find the "path" part
        //
        int n = fname.rfind('\\');
        if (n < 0) {
            n = fname.rfind('/');
        }

        if (n < 0 && (n = fname.rfind(':')) < 0) {
            n = 0;
        }
        else {
            ++n;
        }

        // store the path
        path = fname.substr(0, n);
        // retrive the filename portion
        stripped = fname.substr(n, fname.length());

        return stripped;
    }
}

#ifndef ARRAY_SIZE
#define ARRAY_SIZE(a)   (sizeof(a) / sizeof(a[0]))
#endif

namespace id {
    const char all[] = "all";
    const char begin[] = "begin";
    const char end[] = "end";
    const char else_[] = "else";
    const int begin_size = ARRAY_SIZE(begin) - 1;
    const int end_size = ARRAY_SIZE(end) - 1;
    const int else_size = ARRAY_SIZE(else_) - 1;

    const char internal[] = "internal";
    const char public_[] = "public";
    const char null[] = "null";
    std::string privatefile;
    std::string publicfile;

    const char insert[] = "insert";
    const int insert_size = ARRAY_SIZE(insert) - 1;
    const char reference_start[] = "reference_start";
    const char reference_end[] = "reference_end";
}

#define MYFAILURE_OPENFILE          (120)
#define MYFAILURE_INVALID_FORMAT    (121)

using namespace std;

//////////////////////////////////////////////////////////////////////////
// usage
//////////////////////////////////////////////////////////////////////////

void usage()
{
    fputs(PROGNAME ": version " VERSION "\n", stderr);
    fputs("usage: hdivide [-v] input-filename (no path name please)\n", stderr);
}

//////////////////////////////////////////////////////////////////////////
// misc. helpers
//////////////////////////////////////////////////////////////////////////

inline void makeupper(string& str)
{
    for (int i = 0; i < str.length(); ++i) {
        str[i] = (char)toupper(str[i]);
    }
}

inline void makelower(string& str)
{
    for (int i = 0; i < str.length(); ++i) {
        str[i] = (char)tolower(str[i]);
    }
}

namespace msg {
    void __cdecl error(const char* fmt, ...)
    {
        va_list args;

        fputs(PROGNAME ": [error] ", stderr);
        va_start(args, fmt);
        vfprintf(stderr, fmt, args);
        va_end(args);
        putc('\n', stderr);
    }

    void __cdecl verbose(const char* fmt, ...)
    {
        if (!opt::verbose)
            return;

        va_list args;
        fputs(PROGNAME ": ", stderr);
        va_start(args, fmt);
        vfprintf(stderr, fmt, args);
        va_end(args);
        putc('\n', stderr);
    }
}


//////////////////////////////////////////////////////////////////////////
// class Output
//////////////////////////////////////////////////////////////////////////

class Output;

class Insertion {
public:
    // somehow the default constructor is required for std::vector
    // on NT5 build environment, as of Nov 1998
    explicit Insertion() : m_insert(NULL), m_insertion_point(-1) { }
    explicit Insertion(Output* insert, int point)
        : m_insert(insert), m_insertion_point(point)
    {
    }
public:
    Output* m_insert;
    int m_insertion_point;
};

class Reference {
public:
    // somehow the default constructor is required for std::vector
    // on NT5 build environment, as of Nov 1998
    Reference() : m_start(-1), m_end(-1) { }
    explicit Reference(int start, int end)
        : m_start(start), m_end(end) { }
public:
    int m_start;
    int m_end;
};

class Output {
public:
    explicit Output(const string& name)
      : m_name(name),
        m_fname(input::path + name + ".x"),
        m_alive(true),
        m_insertion_finished(false),
        m_reference_start(-1)
    {
        msg::verbose("opening %s", m_fname.c_str());
        if ((m_fp = fopen(m_fname.c_str(), "wt")) == NULL) {
            msg::error("cannot open file %s", m_fname.c_str());
            throw MYFAILURE_OPENFILE;
        }

        if (m_tomem) {
            m_buffer.reserve(input::length);
        }
    }
    virtual ~Output();

public:
    void setalive(bool alive)
    {
        m_alive = alive;
    }
    bool getalive()
    {
        return m_alive;
    }
    const string& getname()
    {
        return m_name;
    }
    void put(int c)
    {
        assert(m_fp);
        if (m_alive) {
            if (m_tomem) {
                m_buffer += (char)c;
            }
            else {
                putc(c, m_fp);
            }
        }
    }
    void puts(const char* s)
    {
        assert(m_fp);
        if (m_alive) {
            if (m_tomem) {
                m_buffer += s;
            }
            else {
                fputs(s, m_fp);
            }
        }
    }
    bool operator<(const Output* a)
    {
        return m_name < a->m_name;
    }

    void set_insertion_point(Output* insert);
    void set_reference_start();
    void set_reference_end();

    bool do_insertion();

protected:
    FILE* m_fp;
    bool m_alive;
    static bool m_tomem;

    string m_name;
    string m_fname;

    string m_buffer;

    vector<Insertion> m_insertions;

    bool m_insertion_finished;

    vector<Reference> m_references;

    int m_reference_start;
    int m_reference_start_line;
};

bool Output::m_tomem = true;

Output::~Output()
{
    if (m_reference_start != -1) {
        msg::error("reference started at line %d is not closed in tag '%s'",
            m_reference_start_line, m_name.c_str());
        throw MYFAILURE_INVALID_FORMAT;
    }
    if (!m_buffer.empty()) {
        msg::verbose("flushing %s", m_fname.c_str());
        fputs(m_buffer.c_str(), m_fp);
    }
    if (m_fp) {
        fclose(m_fp);
    }
}


void Output::set_insertion_point(Output* insert)
{
    assert(insert!= NULL);
    if (m_alive) {
        Insertion i(insert, m_buffer.length());
        m_insertions.push_back(i);
    }
}

void Output::set_reference_start()
{
    if (m_alive) {
        if (m_reference_start != -1) {
            msg::error("line %d: invalid reference_start appeared in tag context '%s'", input::lineno, m_name.c_str());
            throw MYFAILURE_INVALID_FORMAT;
        }
        m_reference_start = m_buffer.length();
        m_reference_start_line = input::lineno;
    }
}

void Output::set_reference_end()
{
    if (m_alive) {
        if (m_reference_start == -1) {
            msg::error("line %d: invalid reference_end appeared in tag context '%s'", input::lineno, m_name.c_str());
            throw MYFAILURE_INVALID_FORMAT;
        }
        Reference ref(m_reference_start, m_buffer.length());
        msg::verbose("%s reference_end: %d - %d", m_name.c_str(), ref.m_start, ref.m_end);
        m_reference_start = -1;
        m_references.push_back(ref);
    }
}

bool Output::do_insertion()
{
    if (!m_tomem || m_insertion_finished)
        return true;

    // to avoid infinite recursion by errornous commands,
    // firstly declare we've finished this.
    m_insertion_finished = true;

    int upto = m_insertions.size();
    for (int i = 0; i < upto; ++i) {
        Insertion& ins = m_insertions[i];
        assert(&ins);
        if (ins.m_insert->m_references.size() == 0) {
            msg::error("reference area is not specified or incorrect for tag '%s'", ins.m_insert->m_name.c_str());
            return false;
        }

        if (!ins.m_insert->m_insertion_finished) {
            if (!ins.m_insert->do_insertion())
                return false;
        }

        Output* o = ins.m_insert;
        for (int l = 0; l < o->m_references.size(); ++l) {
            Reference& ref = o->m_references[l];
            int len = ref.m_end - ref.m_start;
            msg::verbose("%s [%d] inserting text at %d, %s(%d - %d)",
                         m_name.c_str(), l,
                         ins.m_insertion_point,
                         o->m_name.c_str(), ref.m_start, ref.m_start + len);
            m_buffer.insert(ins.m_insertion_point,
                o->m_buffer, ref.m_start,
                len);
            // fixup my insertions
            int point = ins.m_insertion_point;
            for (int k = 0; k < m_insertions.size(); ++k) {
                if (m_insertions[k].m_insertion_point >= point) {
                    m_insertions[k].m_insertion_point += len;
                    msg::verbose("%s [%d] insertion point fixed from %d to %d",
                        m_name.c_str(), k,
                        m_insertions[k].m_insertion_point - len,
                        m_insertions[k].m_insertion_point);
                }
            }
            // fixup my references
            for (k = 0; k < m_references.size(); ++k) {
                msg::verbose("%s m_reference[%d].m_start=%d, m_end=%d adding len=%d", m_name.c_str(),
                             k,
                             m_references[k].m_start, m_references[k].m_end,
                             len);
                if (m_references[k].m_start > point) {
                    m_references[k].m_start += len;
                }
                if (m_references[k].m_end > point) {
                    m_references[k].m_end += len;
                    msg::verbose("finally start=%d, end=%d", m_references[k].m_start, m_references[k].m_end);
                }
            }
        }
    }

    return true;
}

//////////////////////////////////////////////////////////////////////////
// class Divider
//
// this class manages the map of Output and performs misc. operations
//////////////////////////////////////////////////////////////////////////

class Divider : public map<string, Output*>
{
public:

    virtual ~Divider()
    {
        // process insertions
        for (iterator i = begin(); i != end(); ++i) {
            if (!i->second->do_insertion())
                break;
        }
        // clear up
        for (i = begin(); i != end(); ++i) {
            delete i->second;
        }
    }

    //////////////////////////////////////////////////////////////////////////
    // printout
    //
    // printout the argument to outputs
    //////////////////////////////////////////////////////////////////////////
    void printout(int c)
    {
        for (iterator i = begin(); i != end(); ++i) {
            i->second->put(c);
        }
    }

    void printout(const char* s)
    {
        for (iterator i = begin(); i != end(); ++i) {
            i->second->puts(s);
        }
    }

    void process_line(string& line);

protected:
    void extract_version(const string& name, string& symbol, string& version, bool allow_omission = false);
    void get_arg(const string& name, string& arg);
    void prepare_section(string& name);
    void process_divider(string& line);

    void set_alive(bool alive)
    {
        for (iterator i = begin(); i != end(); ++i) {
            i->second->setalive(alive);
        }
    }

    typedef map<string, bool> OutputState;

    void push_state(OutputState& state)
    {
        state.clear();
        for (iterator i = begin(); i != end(); ++i) {
            state[i->second->getname()] = i->second->getalive();
        }
    }

    void pop_state(OutputState& state)
    {
        for (OutputState::iterator i = state.begin(); i != state.end(); ++i) {
            assert((*this)[i->first] != NULL);
            (*this)[i->first]->setalive(i->second);
        }
    }

protected:
    string m_last_symbol;
    string m_last_version;
};


void Divider::prepare_section(string& name)
{
    // make it lower case
    makelower(name);

    if (name == id::internal) {
        name = id::privatefile;
    }
    else if (name == id::public_) {
        name = id::publicfile;
    }

    if (name != id::null && (*this)[name] == NULL) {
        (*this)[name] = new Output(name);
    }
}

//////////////////////////////////////////////////////////////////////////
// Divider::extract_version
//
// extracts version symbol and supported version
//
// "begin_symbol_version" is splited to symbol and version.
// Both are stored in upper case.
//////////////////////////////////////////////////////////////////////////

void Divider::extract_version(const string& name, string& symbol, string& version, bool allow_omission /*= false*/)
{
    int nsymbol = name.find('_');
    int nver = name.rfind('_');
    if (nsymbol == -1 || nver == nsymbol) {
        if (allow_omission) {
            symbol = m_last_symbol;
            version = m_last_version;
            return;
        }
        else {
            msg::error("line %d: invalid version specifier '%s'", input::lineno, name.c_str());
            throw MYFAILURE_INVALID_FORMAT;
        }
    }
    // symbol
    symbol = name.substr(nsymbol + 1, nver - nsymbol - 1);
    // upper case
    makeupper(symbol);
    version = "0000" + name.substr(nver + 1, name.length());
    version = version.substr(version.length() - 4, 4);
    makeupper(version);

    m_last_symbol = symbol;
    m_last_version = version;
}

//////////////////////////////////////////////////////////////////////////
// Divider::get_arg
//
// extracts one argument separated by "_"
//////////////////////////////////////////////////////////////////////////

void Divider::get_arg(const string& name, string& arg)
{
    int npos = name.find('_');
    if (npos == -1) {
        msg::error("line %d: command incompleted in '%s'", input::lineno, name.c_str());
        throw MYFAILURE_INVALID_FORMAT;
    }

    arg = name.substr(npos + 1, name.length());
}



//////////////////////////////////////////////////////////////////////////
// Divider::process_divider
//
// processes the divider instructions
//////////////////////////////////////////////////////////////////////////

void Divider::process_divider(string& line)
{
    const char* p = line.begin();
    ++p;

    bool makelive = true;
    if (*p == '!') {
        makelive = false;
        ++p;
    }

    // skip the heading spaces
    while (isspace(*p))
        ++p;

    for (int col = 0; p != line.end(); ++col) {
        // pickup the name
        string name;
        while (*p != ';' && p != line.end()) {
            if (!isspace(*p)) {
                name += *p;
            }
            ++p;
        }
        if (p != line.end()) {
            ++p;
        }

        // first column may have special meaning
        if (col == 0) {
            if (name == id::all) {
                set_alive(makelive);
                // does "!all" make sense ?
                // however i'm supporting it anyway
                break;
            }
            if (name == id::null) {
                set_alive(!makelive);
                break;
            }
            if (name.substr(0, id::insert_size) == id::insert) {
                string insert;
                get_arg(name, insert);
                prepare_section(insert);
                if (insert == id::null || insert == id::all) {
                    msg::error("line %d: invalid insertion of '%s'", input::lineno, insert.c_str());
                    throw MYFAILURE_INVALID_FORMAT;
                }
                assert((*this)[insert] != NULL);
                for (iterator i = begin(); i != end(); ++i) {
                    (*this)[i->first]->set_insertion_point((*this)[insert]);
                }
                break;
            }
            if (name == id::reference_start) {
                for (iterator i = begin(); i != end(); ++i) {
                    (*this)[i->first]->set_reference_start();
                }
                break;
            }
            if (name == id::reference_end) {
                for (iterator i = begin(); i != end(); ++i) {
                    (*this)[i->first]->set_reference_end();
                }
                break;
            }

            if (name.substr(0, id::begin_size) == id::begin) {
                string symbol;
                string version;
                extract_version(name, symbol, version);
                printout("#if (");
                printout(symbol.c_str());
                printout(" >= 0x");
                printout(version.c_str());
                printout(")\n");
                break;
            }
            if (name.substr(0, id::else_size) == id::else_) {
                printout("#else\n");
                break;
            }
            if (name.substr(0, id::end_size) == id::end) {
                string symbol;
                string version;
                extract_version(name, symbol, version, true);
                printout("#endif /* ");
                printout(symbol.c_str());
                printout(" >= 0x");
                printout(version.c_str());
                printout(" */\n");
                break;
            }

            // setup the initial state
            set_alive(!makelive);
        }
        prepare_section(name);
        (*this)[name]->setalive(makelive);
    }
}

//////////////////////////////////////////////////////////////////////////
// Divider::process_line
//
// handles one line
//////////////////////////////////////////////////////////////////////////

void Divider::process_line(string& line)
{
    if (line[0] == ';') {
        process_divider(line);
    }
    else {
        // check if inline section appears
        bool instr = false;
        const char* p = line.begin();
        const char* section = NULL;
        while (p != line.end()) {
            if (*p == '\\' && (p + 1) != line.end()) {
                // skip escape character
                // note: no consideration for Shift JIS
                ++p;
            }
            else if (*p == '"' || *p == '\'') {
                // beginning of end of literal
                instr = !instr;
            }
            else if (*p == '@' && !instr) {
                // we have inline section
                section = p;
                break;
            }
            ++p;
        }

        if (section) {
            //
            // if inline tag is specified, temporarily change
            // the output
            //
            OutputState state;
            push_state(state);
            assert(*p == '@');
            ++p;
            if (*p == '+') {
                ++p;
            }
            else {
                set_alive(false);
            }
            while (p != line.end()) {
                string name;
                while (*p != ';' && p != line.end()) {
                    if (!isspace(*p)) {
                        name += *p;
                    }
                    ++p;
                }
                if (p != line.end())
                    ++p;
                if (name == id::all) {
                    set_alive(true);
                    break;
                }
                if (name == id::null) {
                    set_alive(false);
                    break;
                }
                prepare_section(name);
                (*this)[name]->setalive(true);
            }
            // trim trailing spaces
            int i = section - line.begin() - 1;
            while (i >= 0 && isspace(line[i])) {
                --i;
            }
            line = line.substr(0, i + 1);
            printout(line.c_str());
            printout('\n');
            pop_state(state);
        }
        else {
            printout(line.c_str());
            printout('\n');
        }
    }
    ++input::lineno;
}

//////////////////////////////////////////////////////////////////////////
// hdivide
//////////////////////////////////////////////////////////////////////////

void hdivide(FILE* fp)
{
    Divider divider;

    divider[id::publicfile] = new Output(id::publicfile);
    divider[id::privatefile] = new Output(id::privatefile);

    string line;
    int c;

    while ((c = getc(fp)) != EOF) {
        if (c == '\n') {
            divider.process_line(line);
            line = "";
        }
        else {
            line += (char)c;
        }
    }
    if (!line.empty())
        divider.process_line(line);
}


//////////////////////////////////////////////////////////////////////////
// main
//////////////////////////////////////////////////////////////////////////

int __cdecl main(int argc, char** argv)
{
    int c;

    while ((c = getopt(argc, argv, "v")) != EOF) {
        switch (c) {
        case 'v':
            opt::verbose = true;
            break;
        default:
            usage();
            return EXIT_FAILURE;
        }
    }

    if (optind == argc) {
        usage();
        return EXIT_FAILURE;
    }

    msg::verbose("input file: %s", argv[optind]);

    FILE* fp = fopen(argv[optind], "rt");
    if (fp == NULL) {
        msg::error("cannot open input file %s", argv[optind]);
        return EXIT_FAILURE;
    }

    input::length = _filelength(_fileno(fp));

    id::publicfile = argv[optind];
    id::publicfile = input::strip(id::publicfile.substr(0, id::publicfile.length() - 2));
    id::privatefile = id::publicfile + "p";

    int exitcode = EXIT_SUCCESS;

    try {
        hdivide(fp);
    } catch (int err) {
        exitcode = EXIT_FAILURE;
        switch (err) {
        case MYFAILURE_OPENFILE:
            break;
        case MYFAILURE_INVALID_FORMAT:
            msg::error("fatal: invalid format");
            break;
        }
    } catch (...) {
        exitcode = EXIT_FAILURE;
    }

    fclose(fp);

    return exitcode;
}