htmlreplacer.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  HTMLReplacer::Do() {
    Lox_SetDomain("DXL/HTML/JOB", Scope::Method )
    Lox_Info( "Reading HTML file {!Q} of size {}", htmlFileNode.Name(),
                                                   format::ByteSizeIEC(htmlFileNode->Size()) )
    dxl.Stats.HTMLFileSize.fetch_add(int(htmlFileNode->Size()));
 
    Path path;
    {ALIB_LOCK_SHARED_WITH(dxl.GetHTMLTreeLock())
        htmlFileNode.AssembleRealPath(path, lang::Inclusion::Include);
    }
 
    // read exclamations applicable to this file once
    StdVectorMA<ExclamationFile::Entry*> exclamations(poolWorker->TMA);
    dxl.Exclamations.Get(htmlFileNode.Name(), exclamations);
 
    DXLApp& app= app::Get<DXLApp>();
 
    Lox_Info("Reading HTML file:  {}", path )
    MappedFile&      htmlFile= poolWorker->InputFile;
    std::errc errc=  htmlFile.Open(path.Terminate(), htmlFileNode->Size(), false);
    if(errc != std::errc()) {
        app.cErr->Add(app.cli.ExitCodeDecls.Find(ExitCodes::CantOpenHMLFile).Mapped()->FormatString(),
                      path);
        app.machine.SetExitCode(ExitCodes::CantOpenHMLFile);
        return true;
    }
    MappedFile::Data<char> mfc= htmlFile.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(htmlFileNode->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)
 
    // loop over all lines of the HTML-file
    bool        fileChanged         = false;
    int         cntELReplacements   = 0;
    int         cntELRefReplacements= 0;
    int         lineNo              = 1;
    String512   linkString;
    integer     lineStartRemaining = mfc.Remaining();
    while (!mfc.IsEOF()) {
        char c= mfc.Next<NC>();
 
        // linefeed
        if (c == '\n') {  *wb++= '\n'; lineNo++;  lineStartRemaining= mfc.Remaining(); continue; }
 
        // check for EL-and ELREF-anchors with every '"'
        if (c == '"') {
            bool isElAnchor   = characters::Equal<char>(wb-12, "<a class=\"el"   , 12);
            bool isElRefAnchor= characters::Equal<char>(wb-15, "<a class=\"elRef", 15);
            if ( isElAnchor || isElRefAnchor ) {
                // sometimes Doxygen adds two spaces
                while (mfc.Remaining() && *mfc ==' ')
                    mfc.Next<NC>();
 
                // read 'href="x"'
                if (mfc.Remaining() < 8) { *wb++= '\"'; *wb++= ' '; continue; }
                #if ALIB_DEBUG
                ALIB_ASSERT(   mfc()=='h'
                            && mfc()=='r'
                            && mfc()=='e'
                            && mfc()=='f'
                            && mfc()=='='
                            && mfc()=='\"', "DXL/HTML/JOB")
            #else
                mfc.Skip(6);
                #endif
 
                // read file-name and anchor
                String256 fileName;
                String128 anchor;
                bool isAnchor= false;
                while (mfc.Remaining() && (c= mfc()) != '\"') {
                    if (c=='#') {isAnchor= true; continue;}
                    if (!isAnchor) fileName._(c);
                    else           anchor  ._(c);
                }
                Styles styles;
                dxl.GetELDecoration( styles, isElRefAnchor, htmlFileNode, fileName, anchor,
                                     lineNo, int(lineStartRemaining - mfc.Remaining() - 9)  );
                ALIB_ASSERT_ERROR(styles.Size(), "DXL/HTML/JOB", "No styles given for EL-Anchor" )
                // re-activate AString
                ALIB_ASSERT_ERROR(wb - writeBufferStart < writeBuffer.Capacity(),
                                              "DXL/HTML/JOB", "Write buffer overflow detected" )
                writeBuffer.SetLength(wb - writeBufferStart);
 
                for ( int i= 1; i < styles.Size(); ++i ) // starting with 1 omits el/elRef
                    writeBuffer._<NC>( ' ' )._<NC>( styles.Get(i) );
                writeBuffer._<NC>("\" href=\"" );
                if ( fileName.IsNotEmpty() ) writeBuffer._<NC>( fileName );
                if ( anchor.IsNotEmpty() )   writeBuffer._<NC>( '#' )._<NC>( anchor );
                writeBuffer._<NC>( '\"' );
                wb= writeBuffer.VBuffer() + writeBuffer.Length();
                fileChanged= true;
                if (isElAnchor)   ++cntELReplacements;
                else              ++cntELRefReplacements;
            }
            else
                *wb++= '\"';
            continue;
        }
 
        // not '#'? continue
        if (c != '#') {  *wb++= c;    continue; }
 
 
        //---- 2nd character ----
        if (mfc.Remaining()<3) {
            *wb++= c;
            while (mfc.Remaining()){
                c= mfc.Next<NC>();
                if ( c == '\n')
                    ++lineNo;
                *wb++= c;
            }
            break;
        }
 
        c= mfc.Next<NC>();
 
        // if double hash is given, remove one hash ##"..." and keep the rest.
        // Note: This is mainly needed for the documentation of this tool ;-)
        if (c == '#' ) { *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 or the "&" which (was let is pass above!) did not evaluate to '<' symbol
            bool illegalHTMLEntity= (   linkString.CharAt(suppressedAnchor ? 1 : 0) == '&'
                                     && (     ( suppressedAnchor && !linkString.StartsWith("%&lt;"))
                                          ||  (!suppressedAnchor && !linkString.StartsWith( "&lt;")) ) ) ;
            if (    !foundEnd || illegalHTMLEntity ) {
                *wb++= '#';
                *wb++= '\"';
                for ( auto lsC : linkString )
                    *wb++= lsC;
                if ( !illegalHTMLEntity) {
                    *wb++= '\n';
                    Lox_Warning( "Found unterminated XLink pattern {!Q} in HTML file {}:{}:{}",
                                  linkString, path, lineNo -1, colNo )
                }
                continue;
            }
 
            if (suppressedAnchor)
                linkString[0]= ' ';
            linkString.Trim();
        }
        
        ConvertHTMLEntitiesToAscii(linkString);
        if (verbosity >= Verbosity::Info)
            Lox_Info( "Found XLink pattern {!Q} in HTML file {}:{}:{}",
                      linkString, path, lineNo, colNo )
 
        XLink* link= dxl.GetXLink(linkString, htmlFileNode);
        {ALIB_LOCK_WITH(link->Lock)
            link->HTMLLocations.push_back({htmlFileNode, lineNo, colNo});
        }
 
        // re-activate AString
        ALIB_ASSERT_ERROR(wb - writeBufferStart < writeBuffer.Capacity(), "DXL/HTML/JOB",
                          "Write buffer overflow detected" )
        writeBuffer.SetLength(wb - writeBufferStart);
 
        // not resolved?
        if ( !link->IsResolved() ) {
            // paste the original XLink to the output
            writeBuffer._<NC>( "#")._<NC>( "\"");
            if ( suppressedAnchor )
                writeBuffer._<NC>( "%");
            writeBuffer._<NC>(linkString)._<NC>( "\"");
        } else {
            fileChanged= true;
 
            // write replacement
            auto& css= link->CSSClasses;
            ALIB_ASSERT_ERROR(css.Size(), "DXL/HTML/JOB", "No styles given for XLink {}", linkString )
 
          //-------------------------------------- write anchor ------------------------------------
            if (!suppressedAnchor) {
                writeBuffer._<NC>( "<a class=\"" );
                for ( int i= 0; i < css.Size(); ++i )
                    writeBuffer._<NC>( css.Get(i) )._<NC>( ' ' );
                writeBuffer.DeleteEnd(1);
                writeBuffer._<NC>( "\" href=\""     )
                           ._<NC>( link->Result().HTMLBaseURL  )
                           ._<NC>( link->Result().HTMLFile );
                if (link->Result().HTMLAnchor.IsNotEmpty())
                    writeBuffer._<NC>( '#' )._<NC>( link->Result().HTMLAnchor );
 
                writeBuffer._<NC>( "\">" )
                           ._<NC>( link->DisplayHTMLEncoded    )
                           ._<NC>( "</a>" );
 
          //--------------------------------------- write non --------------------------------------
            } else {
                writeBuffer._<NC>( css.IsCodeEntity() ? "<code" :"<span" );
                writeBuffer._<NC>( " class=\"" );
                for ( int i= 1; i < css.Size(); ++i )  // start with 1, this omits el/elRef
                    writeBuffer._<NC>( css.Get(i) )._<NC>( ' ' );
                writeBuffer.DeleteEnd(1);
                writeBuffer._<NC>( "\">" );
                writeBuffer._<NC>( link->DisplayHTMLEncoded    )
                           ._<NC>( css.IsCodeEntity() ? "</code>" :"</span>" );
        }   }
        wb= writeBuffer.VBuffer() + writeBuffer.Length();
    } // the read-loop
 
    // add stats
    dxl.Stats.HTMLFileLines.fetch_add(lineNo);
    dxl.Stats.ELReplacements   .fetch_add(cntELReplacements);
    dxl.Stats.ELREFReplacements.fetch_add(cntELRefReplacements);
 
  //------------------------------------------- write file -----------------------------------------
    if ( fileChanged && !app.dryrun) {
        Lox_Verbose("Writing file:  {}", path )
 
        Path tempPath;
        tempPath << path << ".tmp";
        ofstream outFile(tempPath.Terminate());
        if ( !outFile.is_open() ) {
            app.cErr->Add( app.cli.ExitCodeDecls.Find(ExitCodes::CantOpenHMLFile).Mapped()->FormatString(),
                           tempPath);
            return true;
        }
        ALIB_ASSERT_ERROR(wb - writeBufferStart < writeBuffer.Capacity(), "DXL/HTML/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::CantOpenHMLFile).Mapped()->FormatString(),
                           tempPath);
            return true;
        }
 
        htmlFile.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::CantOpenHMLFile).Mapped()->FormatString(),
                           path, ec);
            return true;
    }   }
    return true;
}
} //namespace [dxl]