HtmlGenerator.cpp

Go to the documentation of this file.

#include <dcl/Config.h>
 
#ifdef __WINNT__
#include <windows.h>
#endif
 
#include <dcl/Charset.h>
#include <dcl/Files.h>
#include <dcl/IniFile.h>
 
#include "DocParser.h"
#include "HtmlGenerator.h"
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __THIS_FILE__[] = __T("src2html/HtmlGenerator.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
HtmlGenerator::HtmlGenerator(const wchar_t* pszIDocIniFileName)
{
    __DCL_ASSERT(pszIDocIniFileName && Files::exists(pszIDocIniFileName));
//  __strIniFileName = pszIDocIniFileName;
    IniFile ini(pszIDocIniFileName);
    String strTemp = ini.getString(L"MAIN", L"SYNTAXES");
    __DCL_ASSERT(!strTemp.isEmpty());
    StringArray list;
    strTemp.split(L' ', list);
 
    String strPath = Files::dirname(pszIDocIniFileName);
    String strTitle;
    String strExt;
    String strSyntaxFile;
    for(StringArray::Iterator it = list.begin(); it != list.end(); it++) {
        strTitle = *it;
        strExt = ini.getString(strTitle, L"FILE_EXTENSION");
        strSyntaxFile = strPath + ini.getString(strTitle, L"SYNTAX_FILE");
 
        __DCL_TRACE3(L"Syntax title[%ls] ext[%ls] filename[%ls]",
            strTitle.data(), strExt.data(), strSyntaxFile.data());
 
        DocSyntax* p = new DocSyntax(strTitle, strExt);
        p->load(strSyntaxFile);
        __vSyntaxes.add(p);
    }
 
    __nTabWidth = 4;
    __bShowLineNumber = true;
    __nLineNumber = 1;
}
 
HtmlGenerator::~HtmlGenerator()
{
    if (!__vSyntaxes.isEmpty()) {
        for(size_t i = 0; i < __vSyntaxes.size(); i++)
            delete (DocSyntax*)__vSyntaxes[i];
    }
}
 
#ifdef __GNUC__
#define _snprintf snprintf
#endif
 
void HtmlGenerator::writeLineNumber(Writer& out)
{
    writeEnd(out, __currentType);
 
    out << String::format(L"\n<span style=\"color:gray;\">%3d:  ", __nLineNumber++);
    out << L"</span>";
 
    writeBegin(out, __currentType);
}
 
void HtmlGenerator::writeBegin(Writer& out, BlockType type)
{
    switch(type) {
        case normal :
            break;
        case comment :
            out << L"<span style=\"color:green;\">";
            break;
        case quotation :
            out << L"<span style=\"color:red;\">";
            break;
        case keyword :
            out << L"<span style=\"color:blue;\">";
            break;
        default :
            __DCL_ASSERT(false);
    }
}
 
void HtmlGenerator::writeEnd(Writer& out, BlockType type)
{
    switch(type) {
        case normal :
            break;
        case comment :
        case quotation :
        case keyword :
            out << L"</span>";
            break;
        default :
            __DCL_ASSERT(false);
    }
}
 
#define FLUSH_PRIOR \
    { \
        if (pStart < pCurrent) \
            out.write(pStart, pCurrent - pStart); \
        pStart = pCurrent + 1; \
    }
 
/*
    if (pCurrent > pStart)
        out->write(pStart, pCurrent - pStart);
    pStart = pCurrent + 1;
*/
void HtmlGenerator::writeData(
    Writer& out, const wchar_t* pData, size_t nDataSize
)
{
    const wchar_t* pStart = pData;
    const wchar_t* pCurrent = pStart;
 
    while(pCurrent < (pData + nDataSize)) {
        switch(*pCurrent) {
            case L'\t': {
                if (__nTabWidth > 0) {
                    FLUSH_PRIOR
                    String str(L' ', __nTabWidth);
                    out.write(str.data(), str.length());
                }
                break;
            }
            case L'\r': {
                if (__bShowLineNumber) {
                    FLUSH_PRIOR
                }
                break;
            }
            case L'\n': {
                if (__bShowLineNumber) {
                    FLUSH_PRIOR
                        writeLineNumber(out);
                }
                else
                    out << L"\n";
 
                break;
            }
            case '>': {
                FLUSH_PRIOR
                    out << L"&gt;";
                break;
            }
            case '<': {
                FLUSH_PRIOR
                    out << L"&lt;";
                break;
            }
            case '&': {
                FLUSH_PRIOR
                    out << L"&amp;";
            }
            default: {
                //          out->write(pCurrent, 1);
                ;
            }
        }
        pCurrent++;
    }
    FLUSH_PRIOR
}
 
void HtmlGenerator::generateHelper(
    Writer& out, 
    const wchar_t* pData,
    size_t nDataSize,
    const wchar_t* pszLanguageTitle
)
{
    __currentType = normal;
    DocSyntax* pSyntax = NULL;
    for(size_t i = 0; i < __vSyntaxes.size(); i++) {
        if (((DocSyntax*)__vSyntaxes[i])->isValidLanguage(pszLanguageTitle))
        {
            pSyntax = (DocSyntax*)__vSyntaxes[i];
            break;
        }
    }
    __DCL_ASSERT(pSyntax != NULL);  // Not Found Syntax 
 
    if (__nTabWidth == 0)
        __nTabWidth = pSyntax->tabWidth();
 
    out << L"\n<pre style=\"background-color:white; color:black; font-style=normal; font-weight:normal\">";
    __nLineNumber = 1;
    if (__bShowLineNumber)
        writeLineNumber(out);
 
    DocParser parser(pData, nDataSize, pSyntax);
    DOC_BLOCK block;
    while(parser.getNextBlock(block)) {
        if (__currentType != block.type) {
            writeEnd(out, __currentType);
            writeBegin(out, block.type);
            __currentType = block.type;
        }
 
        writeData(out, block.pData, block.nDataSize);
    }
    writeEnd(out, __currentType);
    out << L"\n</pre>";
}
 
bool HtmlGenerator::generate(
    Writer& out,
    const wchar_t* pszFileName,
    const wchar_t* pszLangSyntax    // = NULL
)
{
    __DCL_ASSERT(pszFileName != NULL);
 
    String strLangSyntax;
    if (pszLangSyntax == NULL) {
        const wchar_t* p = pszFileName + String::length(pszFileName);
        while(--p > pszFileName) {
            if (*p == '.') {
                p++;
                break;
            }
        }
 
        if (p == pszFileName)
            return false;   // invalid file name;
 
        DocSyntax* pSyntax = NULL;
        for(size_t i = 0; i < __vSyntaxes.size(); i++) {
            pSyntax = (DocSyntax*)(__vSyntaxes[i]);
            if (pSyntax->isValidExtension(p)) {
                strLangSyntax = pSyntax->languageTitle();
                pszLangSyntax = strLangSyntax.data();
                break;
            }
        }
    }
 
    __DCL_ASSERT(pszLangSyntax != NULL);
    __DCL_ASSERT(Files::exists(pszFileName));
 
    UTF8Decoder dec;
    String text = Files::readText(pszFileName, dec);
 
    generateHelper(
        out,
        text,
        text.length(),
        pszLangSyntax
    );
    return true;
}
 
bool HtmlGenerator::generate(
    Writer& out,
    const wchar_t* pData,
    size_t nDataSize,
    const wchar_t* pszLangSyntax
)
{
    generateHelper(
        out,
        pData,
        nDataSize,
        pszLangSyntax
    );
    return true;
}
 
void HtmlGenerator::setOption(int nTabWidth, bool bShowLineNumber)
{
    __nTabWidth = nTabWidth;
    __bShowLineNumber = bShowLineNumber;
}
 
void HtmlGenerator::generateHeader(
    Writer& out,
    const wchar_t* pszHtmlTitle
)
{
    if (pszHtmlTitle == NULL)
        pszHtmlTitle = L"Unknown File Name";
 
    StringBuilder strHeader = L""
        "<!DOCTYPE html>"
        "\n<html lang=\"ko-KR\">"
        "\n<head>"
        "\n<meta charset=\"UTF-8\" >"
        "\n<meta name=\"generator\" content=\"src2html 0.9\">"
        "\n<meta name=\"author\" content=\"Daejung Kim &lt;daejung@sysdeveloper.net&gt; http://www.sysdeveloper.net/daejung\">"
        "\n<title>";
    strHeader += pszHtmlTitle;
    strHeader += L"</title>";
    strHeader += L""
        "\n</head>"
        "\n<body>";
 
    out << strHeader;
}
 
void HtmlGenerator::generateFooter(Writer& out)
{
    String strFooter = L""
        "\n</body>"
        "\n</html>";
 
    out << strFooter;
}
 
__DCL_END_NAMESPACE