sourcereplacer.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 "jobs.hpp"
#include "dxl.hpp"
#include "xlink.hpp"
#include "dxlapp.hpp"
#include "ALib.ALox.H"
#include "ALib.App.H"    // TODO(251204 09:14): we need this only for the definition of LOX_LOX.
                         //                     How can we avoid to include the whole app?
 
#include <iostream>
#include <fstream>
 
using namespace alib;
using namespace std;
 
namespace dxl {
 
bool  SourceReplacer::Do() {
    Lox_SetDomain("DXL/SREPL/JOB", Scope::Method )
    Lox_Info( "Reading source file {!Q} of size {}", srcFileNode.Name(),
                                                   format::ByteSizeIEC(srcFileNode->Size()) )
    dxl.Stats.ReplSourceFileSize.fetch_add(int(srcFileNode->Size()));
 
    Path path;
    {ALIB_LOCK_SHARED_WITH(dxl.GetSourceTreeLock())
        srcFileNode.AssembleRealPath(path, lang::Inclusion::Include);
    }
 
    // read exclamations applicable to this file once
    StdVectorMA<ExclamationFile::Entry*> exclamations(poolWorker->TMA);
    dxl.Exclamations.Get(srcFileNode.Name(), exclamations);
 
    DXLApp& app= app::Get<DXLApp>();
 
    Lox_Info("Reading source file:  {}", path )
    MappedFile&      sourceFile= poolWorker->InputFile;
    std::errc errc=  sourceFile.Open(path.Terminate(), srcFileNode->Size(), false);
    if(errc != std::errc()) {
        app.cErr->Add(app.cli.ExitCodeDecls.Find(ExitCodes::CantOpenReplSrcFile).Mapped()->FormatString(),
                      path);
        app.machine.SetExitCode(ExitCodes::CantOpenReplSrcFile);
        return true;
    }
    MappedFile::Data<char> mfc= sourceFile.GetData<char>();
 
    // output buffer (fileSize * 3). And: we add some padding bytes, to be able to test
    // backward contents without checking actual write-size.
    AString& writeBuffer= poolWorker->WriteBuffer;
    writeBuffer.EnsureRemainingCapacity(integer(srcFileNode->Size() * 3));
    constexpr integer writeBufferPadSize= 20;
    writeBuffer._(Fill(0, writeBufferPadSize));
    char* writeBufferStart= writeBuffer.VBuffer();
    char* wb              = writeBufferStart + writeBufferPadSize;
 
     // if the application has an exit code, we stop right now
     // todo: this periodical check makes sense but was never tested, yet.
     //       it has to go into the loop below and also to other jobs
     if ( app.machine.GetExitCode().Integral() )
         return true;
 
    // we want maximum speed and even spare the fast log calls in the loop.
    Verbosity verbosity;
    Lox_GetVerbosity(verbosity)
 
  //------------------------------------------- main loop ------------------------------------------
    bool        fileChanged         = false;
    int         lineNo              = 1;
    String512   linkString;
    integer     lineStartRemaining = mfc.Remaining();
    while (!mfc.IsEOF()) {
        char c= mfc.Next<NC>();
        if (c == '\n') {  *wb++= '\n'; lineNo++;  lineStartRemaining= mfc.Remaining(); continue; }
        if (c != '#' ) {  *wb++= c;    continue; }
 
        if (mfc.Remaining()<3) {
            *wb++= c;
            while (mfc.Remaining()){
                c= mfc.Next<NC>();
                if ( c == '\n')
                    ++lineNo;
                *wb++= c;
            }
            break;
        }
 
        //---- 2nd character ----
        c= mfc.Next<NC>();
 
        // if double hash is given, skip it.
        // Note: This is mainly needed for the documentation of this tool ;-)
        if (c == '#' ) { *wb++= '#'; *wb++= '#';  continue;}
 
        // not '"' ?
        if ( c != '\"' ) {
            *wb++= '#';
            *wb++= c;
            if ( c == '\n')
                ++lineNo;
            continue;
        }
 
        //---- 3rd character: not an allowed link start? ----
        c= mfc.Next<NC>();
        if ( !isalpha(c) && String(".%^_<").IndexOf(c) < 0 ) {
            *wb++= '#';
            *wb++= '\"';
            *wb++= c;
            if ( c == '\n')
                ++lineNo;
            continue;
        }
 
        int colNo= int(lineStartRemaining - mfc.Remaining() - 2);
 
        // search for exclamations
        {   auto exclIt= exclamations.begin();
            for (; exclIt!=exclamations.end(); ++exclIt )
                if ( (*exclIt)->Matches(lineNo, colNo ) )
                    break;
            if (exclIt != exclamations.end()) {
                *wb++= '#';
                *wb++= '\"';
                *wb++= c;
                continue;
        }   }
 
        // This seems to be an XLink!
        bool suppressedAnchor;
        linkString.Reset(c); {
            bool foundEnd= false;
            while (mfc.Remaining()) {
                c= mfc.Next<NC>();
                if ( c == '\\') { linkString._<NC>(c); linkString._<NC>(mfc.Next()); continue; }
                if ( c == '\"') { foundEnd= true; break;}
                if ( c == '\n') { lineNo++; break; }
                linkString._<NC>(c);
                if (linkString.Length() == 511 ) {
                    Lox_Warning( "Found unterminated XLink pattern {!Q} in HTML file {}:{}:{}",
                                  linkString, path, lineNo, colNo )
                    break;
            }   }
 
            suppressedAnchor= linkString.CharAtStart() == '%';
 
            // end not found?
            if (!foundEnd) {
                *wb++= '#';
                *wb++= '\"';
                for ( auto lsC : linkString )
                    *wb++= lsC;
                *wb++= '\n';
                Lox_Warning( "Found unterminated XLink pattern {!Q} in replacement source file {}:{}:{}",
                             linkString, path, lineNo -1, colNo )
                continue;
            }
 
            if (suppressedAnchor)
                linkString[0]= ' ';
            linkString.Trim();
        }
 
        if (verbosity >= Verbosity::Info)
            Lox_Info( "Found XLink pattern {!Q} in replacement source file {}:{}:{}",
                      linkString, path, lineNo, colNo )
 
        XLink* xLink= dxl.GetXLink(linkString, FTFile());
        // attach this source file to the XLink and vice versa
        {ALIB_LOCK_WITH(xLink->Lock)
            xLink->SourceLocations.push_back({srcFileNode, lineNo, colNo});     }
        { ALIB_LOCK_WITH(dxl.GetSourceTreeLock())
            if (!srcFileNode.HasCustomData())
                srcFileNode.AttachCustomData<XLinkList>(dxl.GetSourceTree().GetAllocator());
            srcFileNode.GetCustomData<XLinkList>().emplace_back( xLink, lineNo, colNo );
        }
 
        // re-activate AString
        ALIB_ASSERT_ERROR(wb - writeBufferStart < writeBuffer.Capacity(), "DXL/SREPL/JOB",
                          "Write buffer overflow detected" )
        writeBuffer.SetLength(wb - writeBufferStart);
 
        // not resolved?
        if ( !xLink->IsResolved() ) {
            // paste the original XLink to the output
            writeBuffer._<NC>( "#")._<NC>( "\"");
            if ( suppressedAnchor )
                writeBuffer._<NC>( "%");
            writeBuffer._<NC>(linkString)._<NC>( "\"");
        } else {
            fileChanged= true;
            auto& node  = xLink->Result().Node;
 
            // write replacement
            String256 entityPath;
            if( !node.IsA(Target::DocAnchor|Target::File|Target::Dir|Target::Macro)) {
                ALIB_LOCK_SHARED_WITH(node.Index().SLock)
                ( node.IsA(Target::EnumElement) ? node.Parent() : node ).Path(entityPath);
                if( node.IsA(Target::Function))
                    entityPath.ShortenTo(entityPath.IndexOfOrLength('('));
            } else
                entityPath= node.Name();
 
            ConvertHTMLEntitiesToAscii(entityPath);
            writeBuffer._<NC>( "\\ref " )
                       ._<NC>(entityPath)
                       ._<NC>(" \"")
                       ._<NC>(xLink->Display)
                       ._<NC>('"');
        }
        wb= writeBuffer.VBuffer() + writeBuffer.Length();
 
    } // the read-loop
 
    // add stats
    dxl.Stats.ReplSourceFileLines.fetch_add(lineNo);
 
  //------------------------------------------- write file -----------------------------------------
    if ( fileChanged && !app.dryrun) {
        Lox_Verbose("Writing replacement source file:  {}", path )
 
        Path tempPath;
        tempPath << path << ".tmp";
        ofstream outFile(tempPath.Terminate());
        if ( !outFile.is_open() ) {
            app.cErr->Add( app.cli.ExitCodeDecls.Find(ExitCodes::CantWriteReplSrcFile).Mapped()->FormatString(),
                           tempPath);
            return true;
        }
        ALIB_ASSERT_ERROR(wb - writeBufferStart < writeBuffer.Capacity(), "DXL/SREPL/JOB",
                          "Write buffer overflow detected" )
        outFile.write(writeBuffer.Buffer() + writeBufferPadSize, wb - writeBufferStart - writeBufferPadSize);
        outFile.close();
 
        if ( outFile.fail() ) {
            app.cErr->Add( app.cli.ExitCodeDecls.Find(ExitCodes::CantWriteReplSrcFile).Mapped()->FormatString(),
                           tempPath);
            return true;
        }
 
        sourceFile.Close();
        std::error_code ec;
        std::filesystem::rename(tempPath.Terminate(), path.Terminate(), ec);
        if ( ec.value() != 0 ) {
            app.cErr->Add( app.cli.ExitCodeDecls.Find(ExitCodes::CantWriteReplSrcFile).Mapped()->FormatString(),
                           path, ec.message());
            return true;
    }   }
    return true;
}
} //namespace [dxl]