doxyfile.cpp

//==================================================================================================
// This implementation-file is part of DoxygenXLinks - A doxygen post-processor that allows to
// define smarter <b>Doxygen</b>-links.
//
// \emoji :copyright: 2025-2026 A-Worx GmbH, Germany.
// Published under \ref mainpage_license "Boost Software License".
//==================================================================================================
#include "doxyfile.hpp"
#include "dxl.hpp"
#include "ALib.ALox.H"
#include "ALib.Strings.StdIOStream.H"
#include "ALib.Containers.StringTreeIterator.H"
#include "ALib.App.H"
#include <fstream>
 
 
using namespace alib;
using namespace std;
 
namespace dxl {
 
void DoxygenINIFile::Load(const system::Path& filePath) {
    Lox_SetDomain("DXL/DOXYFILE", Scope::Filename )
    Lox_Info("Reading doxygen ini file: ", filePath )
 
    std::ifstream ifstream;
    errno= 0;
    ifstream.open( filePath.Terminate() );
    if ( !ifstream.is_open() || errno ) {
        DXLApp& app= app::Get<DXLApp>();
        app.cErr->Add(app.cli.ExitCodeDecls.Find(ExitCodes::CantOpenDoxyfile).Mapped()->FormatString(),
                      filePath);
        app.machine.SetExitCode(ExitCodes::CantOpenDoxyfile);
        throw Exception( ALIB_CALLER_NULLED, app::App::Exceptions::ControlledEarlyExit );
    }
 
    // get the allocator just from any of our containers
    MonoAllocator& ma= InputPaths.GetAllocator();
 
    // reader
    IStreamReader reader;
    reader.SetStream( &ifstream );
    String4K lineBuf; lineBuf.DbgDisableBufferReplacementWarning();
 
    // loop over all lines of the HTML-file
    // We read logical lines: handle trailing '\\' for continuations and strip comments '#'
    String4K acc; acc.DbgDisableBufferReplacementWarning();
    system::Path       tmpOutputDirectory;      // needed to resolve HTML_OUTPUT
    system::Path       tmpHtmlOutput;
    system::Path       tmpTagFilePath;          // will be added to the list of tagfiles at the end
                                                // when the output path is known
    bool               tmpCreateSubDirs= false; // needed to resolve CREATE_SUBDIRS_LEVEL
 
    auto finalizeLogicalLine = [&](Substring logical) {
        // remove in-line comments starting with '#' (when not inside quotes)
        bool inQuotes = false;
        int cutPos = -1;
        for (int i = 0; i < logical.Length(); ++i) {
            nchar c = logical.CharAt(i);
            if (c == '"') inQuotes = !inQuotes;
            if (c == '#' && !inQuotes) { cutPos = i; break; }
        }
        if (cutPos >= 0)
            logical = logical.Substring(0, cutPos);
        logical.Trim();
        if (logical.IsEmpty())
            return;
 
        // Expect KEY = VALUE
        integer eqPos = logical.IndexOf('=');
        if (eqPos < 0) return; // ignore malformed lines
 
        Substring key = logical.Substring(0, eqPos);  key.Trim();
        Substring val = logical.Substring(eqPos + 1); val.Trim();
 
        auto stripQuotes = [](Substring& s){
            s.Trim();
            if (s.Length() >= 2 && s.CharAtStart() == '"' && s.CharAtEnd() == '"') {
                s.ConsumeChar('"');
                // remove last quote by creating a shorter substring
                s = s.Substring(0, s.Length()-1);
            }
        };
 
        auto addListTokensStr = [&](Substring src,
                                    ListMA<String>& listOut) {
            while (src.IsNotNull()) {
                src.TrimStart();
                if (src.IsEmpty()) break;
                if (src.ConsumeChar('"')) {
                    integer end = src.IndexOf('"');
                    Substring tok;
                    if (end >= 0) { tok = src.Substring(0, end); src.ConsumeChars(end); src.ConsumeChar('"'); }
                    else { tok = src; src.ConsumeChars(src.Length()); }
                    tok.Trim();
                    if (tok.IsNotEmpty()) listOut.emplace_back(String(ma,tok));
                } else {
                    Substring tok = src.ConsumeToken(' ');
                    tok.Trim();
                    if (tok.IsNotEmpty()) listOut.emplace_back(String(ma,tok));
                }
            }
        };
 
        auto addListTokensPath = [&](Substring src,
                                     ListMA<system::PathString>& listOut) {
            while (src.IsNotNull()) {
                src.TrimStart();
                if (src.IsEmpty()) break;
                if (src.CharAtStart() == '"') {
                    src.ConsumeChar('"');
                    integer end = src.IndexOf('"');
                    Substring tok;
                    if (end >= 0) { tok = src.Substring(0, end); src.ConsumeChars(end); src.ConsumeChar('"'); }
                    else { tok = src; src.ConsumeChars(src.Length()); }
                    tok.Trim();
                    if (tok.IsNotEmpty()) { system::PathString p; p= tok; listOut.emplace_back(String(ma,p)); }
                } else {
                    Substring tok = src.ConsumeToken(' ');
                    tok.Trim();
                    if (tok.IsNotEmpty()) { system::PathString p; p= tok; listOut.emplace_back(String(ma,p)); }
                }
            }
        };
 
        // Dispatch on key
        if (key.Equals("OUTPUT_DIRECTORY")) {
            stripQuotes(val);
            tmpOutputDirectory = val;
        }
        else if (key.Equals("HTML_OUTPUT")) {
            stripQuotes(val);
            // Temporarily store raw value in HtmlOutput; resolve after loop using outputDirectory
            tmpHtmlOutput = val;
        }
        else if (key.Equals("HTML_FILE_EXTENSION")) { stripQuotes(val); HtmlFileExtension = String(ma,val); }
        else if (key.Equals("CREATE_SUBDIRS"))      { tmpCreateSubDirs  = val.Equals<CHK,lang::Case::Ignore>("YES"); }
        else if (key.Equals("CREATE_SUBDIRS_LEVEL")){ val.ConsumeDec(HtmlSubfolderDepth); }
        else if (key.Equals("INPUT"))               { addListTokensPath(val, InputPaths);        }
        else if (key.Equals("RECURSIVE"))           { RecursiveInputScan= val.Equals<CHK,lang::Case::Ignore>("YES"); }
        else if (key.Equals("EXCLUDE"))             { addListTokensPath(val, ExcludePaths);      }
        else if (key.Equals("EXCLUDE_SYMLINKS"))    { ExcludeSymlinks   = val.Equals<CHK,lang::Case::Ignore>("YES"); }
        else if (key.Equals("EXCLUDE_PATTERNS"))    { addListTokensStr (val, ExcludePatterns);    }
        else if (key.Equals("FILE_PATTERNS"))       {
            String512 buf;
            while ( val.IsNotEmpty() ) {
                val.TrimStart("* \t\r");
                buf << val.ConsumeToken(' ') << ' ';
            }
            FilePatterns= String(ma, buf);
        }
        else if (key.Equals("TAGFILES")) {
            // tokens of form file or file=loc (file/location may be quoted)
            Substring rest(val);
            while (rest.IsNotNull()) {
                rest.TrimStart();
                if (rest.IsEmpty()) break;
 
                Substring token;
                if (rest.CharAtStart() == '"') {
                    rest.ConsumeChar('"');
                    integer end = rest.IndexOf('"');
                    if (end >= 0) {
                        token = rest.Substring(0, end);
                        rest.ConsumeChars(end);
                        rest.ConsumeChar('"');
                    } else {
                        token = rest; rest.ConsumeChars(rest.Length());
                    }
                } else {
                    token = rest.ConsumeToken();
                }
                token.Trim();
                if (token.IsEmpty()) continue;
 
                // split at '=' if present
                integer eq = token.IndexOf('=');
                TagFileInfo tfInfo;
                if (eq >= 0) {
                    Substring f = token.Substring(0, eq); f.Trim();
                    Substring l = token.Substring(eq+1);  l.Trim();
                    tfInfo.TagFilePath = String(ma,f);
                    tfInfo.BaseURL     = String(ma,l);
                } else {
                    tfInfo.TagFilePath = String(ma,token);
                }
                TagFiles.emplace_back(tfInfo);
            }
        }
        else if (key.Equals("GENERATE_TAGFILE")) {
            stripQuotes(val);
            if (val.IsNotEmpty())
                tmpTagFilePath= val;
        }
    };
 
    while( !reader.IsEOF() ) {
        reader.Read(lineBuf);
 
        Substring line(lineBuf);
        // append to accumulator
        acc._(line);
 
        // check for line continuation: trailing '\\' after trimming right spaces
        Substring accView(acc);
        accView.TrimEnd();
        bool cont = accView.IsNotEmpty() && accView.CharAtEnd() == '\\';
        if (cont) {
            // remove trailing backslash and continue accumulating
            acc.SetLength(acc.Length()-1);
            acc._(' ');
            continue;
        }
 
        // process logical line in acc
        Substring logical(acc);
        finalizeLogicalLine(logical);
        acc.Reset();
    }
 
    if (tmpTagFilePath.IsEmpty()) {
        app::Get<DXLApp>().cErr->Add(app::Get<DXLApp>().cli.ExitCodeDecls.Find(ExitCodes::NoTagfileGeneratedByDoxyfile).Mapped()->FormatString(),
                               filePath);
        app::Get<DXLApp>().machine.SetExitCode(ExitCodes::NoTagfileGeneratedByDoxyfile);
        throw Exception( ALIB_CALLER_NULLED, app::App::Exceptions::ControlledEarlyExit );
    }
 
    // Resolve the HTML output directory relative to OUTPUT_DIRECTORY if not absolute
    if (tmpHtmlOutput.IsAbsolute())
        HTMLFilePath= String(ma,tmpHtmlOutput);
    else {
        tmpOutputDirectory << system::DIRECTORY_SEPARATOR << tmpHtmlOutput;
        HTMLFilePath= String(ma,tmpOutputDirectory);
    }
 
    // add a tag-file
    Path tagFileURL= "file://"; tagFileURL << HTMLFilePath;
    TagFiles.push_back({String(ma,tmpTagFilePath), String(ma, tagFileURL)});
 
    // resolve the html output folder depth
    if (!tmpCreateSubDirs)     // coming from CREATE_SUBDIRS
        HtmlSubfolderDepth= 0; // coming from CREATE_SUBDIRS_LEVEL and is always set
}
                      
void DoxygenINIFile::Dump() const {
    auto& p= app::Get<DXLApp>().cOut;
    p->Add("Dumping contents of doxyfile");
    p->PushIndent(2);
        p->Add("ExcludeSymlinks:    ", ExcludeSymlinks);
        p->Add("RecursiveInputScan: ", RecursiveInputScan);
        p->Add("Tagfiles:");
        {
            p->PushIndent(2);
            for (const auto& it : TagFiles)
                p->Add("{} {!ATab} {}\n", it.TagFilePath, "->", it.BaseURL);
            p->PopIndent();
        }
        p->Add();
        p->Add("InputPaths:");
        {
            p->PushIndent(2);
            for (const auto& it : InputPaths) 
                p->Add("{}\n", it);
            p->PopIndent();
        }
        p->Add();
        p->Add("FilePatterns: " );
            p->PushIndent(4);
            p->Add(FilePatterns );
            p->PopIndent();
        p->Add();
        p->Add("ExcludePaths:");
        {
            p->PushIndent(2);
            for (const auto& it : ExcludePaths)
                p->Add("{}\n", it);
            p->PopIndent();
        }
        p->Add();
        p->Add("ExcludePatterns:");
        {
            p->PushIndent(2);
            for (const auto& it : ExcludePatterns)
                p->Add("{}\n", it);
            p->PopIndent();
        }
    p->PopIndent();
 
    app::Get<DXLApp>().onSdOutput();
}
 
} //namespace [dxl]