/*
 *   FILE:        src2html.cpp
 *   VERSION:     0.1
 *   DESCRIPTION: Converts a source file to syntax highlighted HTML.
 */


//---------------------------------------------------------------------------

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#pragma hdrstop
#include <iterator>
#include <map>
#include <boost/regex.hpp>

//---------------------------------------------------------------------------

using namespace std;

inline string extract_filepath(const string& filename)
{   // À©µµ°¡ ¾Æ´Ñ OS¿¡¼­ ¼öÁ¤ ÇÊ¿ä.
    return filename.substr(0, filename.rfind('\\'));
}

inline string extract_fileext(const string& filename)
{
    return filename.substr(filename.rfind('.') + 1, filename.length());
}

void load_syntax(map<string, string>& syntax, const string& filename);
string make_expression(map<string, string>& syntax);
string make_format(map<string, string>& syntax);

int main(int argc, char* argv[])
{
    if (argc < 1) exit(-1);

    try{
        // ¹®¹ý ÆÄÀÏ À̸§Àº ù¹ø° ÀÎÀÚÀÇ È®ÀåÀÚ·Î °áÁ¤.
        // µÎ¹ø° ÀÎÀÚ¿¡ ´Ù¸¥ È®ÀåÀÚ°¡ ¿Íµµ ¹«½Ã ^^;
        string syntax_filename = extract_filepath(string(argv[0])) + '\\' +
                                 extract_fileext(string(argv[1])) + ".stx";
        map<string, string> syntax;
        load_syntax(syntax, syntax_filename);

        string header1 = syntax["header1"], header2 = syntax["header2"],
               footer = syntax["footer"], pre_format = syntax["pre_format"],
               s_expression = make_expression(syntax),
               s_format = make_format(syntax);

        boost::regex pre_expression(syntax["pre_expression"]),
                     expression(s_expression);

        ifstream fin; ofstream fout;
        ostringstream t(ios::out | ios::binary);
        string in_filename, out_filename, in_filedata;

        for (int i = 1; i < argc; ++i)
        {
            in_filename = argv[i];
            cout << "Processing file " << in_filename << endl;
            syntax.clear();

            fin.open(in_filename.c_str());
            in_filedata.assign((istreambuf_iterator<char>(fin)),
                                istreambuf_iterator<char>());
            fin.close();
            out_filename = in_filename + ".htm";
            fout.open(out_filename.c_str());
            fout << header1 << in_filename << header2;

            // strip '<' and '>' first by outputting to a
            // temporary string stream
            boost::regex_merge(ostream_iterator<char>(t),
                                in_filedata.begin(), in_filedata.end(),
                                pre_expression, pre_format);

            // then output to final output stream
            // adding syntax highlighting:
            string s(t.str());
            boost::regex_merge(ostream_iterator<char>(fout),
                                s.begin(), s.end(), expression, s_format);

            fout << footer;
            fout.close();
            system(out_filename.c_str());  // À©µµ°¡ ¾Æ´Ñ OS¿¡¼­ ¼öÁ¤ ÇÊ¿ä.
        }
    }
    catch(...) { return -1; }
    return 0;
}
//---------------------------------------------------------------------------


void load_syntax(map<string, string>& syntax, const string& filename)
{
    ifstream fin(filename.c_str());
    if (!fin) exit(0);
    string line, key, value;
    int pos;
    while (getline(fin, line)) {
        if (line.length() < 3 || line[0] == ';')                    continue;
        pos = line.find('=');
        if (pos < 2 || pos == string::npos)                         continue;
        key = line.substr(0, pos);
        value = line.substr(pos + 1, line.length());
        if (value.length() < 1)                                     continue;
        syntax.insert(map<string, string>::value_type(key, value));
    }
}

string make_expression(map<string, string>& syntax)
{
    string expression_num = "expression1", expressions = syntax[expression_num];

    for (char i = '2'; i <= '9'; ++i) {
        expression_num[10] = i;
        if (!syntax.count(expression_num)) break;
        expressions += '|' + syntax[expression_num];
    }

    return expressions;
}

string make_format(map<string, string>& syntax)
{
    string format_num = "format#", formats;

    for (char i = '1'; i <= '9'; ++i) {
        format_num[6] = i;
        if (!syntax.count(format_num)) break;
        formats += "(?" + (i + syntax[format_num] + ')');
    }

    return formats;
}