target.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 "target.hpp"
 
using namespace alib;
using namespace std;
 
namespace dxl {
 
size_t   Target::MAX_TEMPLATE_ARGS= 64;
 
void Target::FunctionArguments::Print(AString& dest) {
    dest << '(';
    for (int i= 0; i< Count; ++i) {
        dest << Arguments[i];
        if ( i < Count - 1)
            dest << ", ";
     }
    dest << ')';
}
 
#include "ALib.Lang.CIFunctions.H"
Target::FunctionArguments* Target::FunctionArguments::PARSE(MonoAllocator& ma, Substring& parser) {
    int       cntArgs= 0;
    String    parsed[128];
 
    if (!parser.ConsumeChar('('))
        return nullptr;
 
    // find all
    for (;;) {
        String256 actParam;
        int depth= 0;
 
        // find end of actual
        char lastChar;
        for(;;) {
            lastChar= parser.ConsumeChar();
            if ( lastChar == '\0')
                return nullptr;
            actParam._<NC>(lastChar);
            if ( depth == 0 && String("=,)").IndexOf(lastChar) >= 0 )
                break;
 
            if ( String("<([{").IndexOf(lastChar) >= 0 ) { depth++; continue; }
            if ( String(">)]}").IndexOf(lastChar) >= 0 ) { depth--; continue; }
        }
 
        // remove '=', ',' or ')'
        actParam.ShortenBy(1);
        // strip parameter name
        {
            // search the last "identifier"
            integer paramNameStart= actParam.Length()-1;
            for ( ;     paramNameStart>=0
                    &&  String(" &*").IndexOf(actParam[paramNameStart]) < 0
                    && (    isalnum(actParam[paramNameStart])
                         || '_' ==  actParam[paramNameStart]    )
                  ; --paramNameStart) ;
            paramNameStart++;
 
            // now we trim further from there and check if the remaining last word is a
            // C++ keyword. If so, the identifier is a type and NOT a parameter name
            Substring remainder= actParam.Substring(0, paramNameStart);
            remainder.TrimEnd();
            if (    remainder.EndsWith("const")
                 || remainder.EndsWith("volatile")
                 || remainder.EndsWith("::") )
                paramNameStart= -1;
 
            if ( paramNameStart>0 && paramNameStart < actParam.Length() ) {
                actParam.ShortenTo(paramNameStart);
                actParam.TrimEnd();
        }   }
        
        actParam.TrimEnd();
        if ( actParam.IsNotEmpty() ) {
            // remove space before reference "&" and pointer "*"
            integer actIdx= 0;
            while ((actIdx= actParam.IndexOf('&', actIdx)) > 0) {
                if (actParam.CharAt(actIdx-1) == ' ')
                    actParam.Delete(actIdx-1, 1);
                ++actIdx;
            }
            actIdx= 0;
            while ((actIdx= actParam.IndexOf('*', actIdx)) > 0) {
                if (actParam.CharAt(actIdx-1) == ' ')
                    actParam.Delete(actIdx-1, 1);
                ++actIdx;
            }
 
            actIdx= 0;
            while ((actIdx= actParam.IndexOf("...", actIdx)) > 0) {
                if (actParam.CharAt(actIdx-1) != ' ')
                    actParam.InsertAt(" ", actIdx);
                actIdx+=3;
            }
 
            if ( lastChar == '=') {
                // skip assignment
                bool inLiteral= false;
                bool escaped= false;
                depth= 0;
                for (;;) {
                    lastChar= parser.ConsumeChar();
                    if ( lastChar == '\0')
                        break;
                    bool isLitChar= lastChar=='\'' || lastChar == '"';
                    bool isEscChar= lastChar=='\\';
                    if ( inLiteral ) { if ( escaped  ) { escaped  = false; continue; }
                                       if ( isEscChar) { escaped  = true;  continue; } }
                    if (isLitChar)   { inLiteral= !inLiteral; continue; }
                    if (inLiteral) continue;
                    if (String8("({[<").IndexOf(lastChar) >= 0)
                        {++depth; continue;}
                    if (String8(">)}]").IndexOf(lastChar) >= 0)
                        {if (--depth < 0) break; continue;}
 
                    if ( depth==0 && (lastChar== ',' || lastChar==')'))
                        break;
            }   }
 
            // remove spaces before/after template braces
            actParam.SearchAndReplace("< ", "<");
            actParam.SearchAndReplace(" >", ">");
 
            parsed[cntArgs++]= String(ma, actParam);
        } // not empty
 
        if ( lastChar==')')
            break;
 
        if (cntArgs==128)
            return nullptr;  // todo: notify caller
        parser.TrimStart();
    }
 
    FunctionArguments* result= ma().Alloc<FunctionArguments>();
    result->Count    = cntArgs;
    if ( cntArgs > 0) {
        result->Arguments= ma().NewArray<String>(cntArgs);
        for (int i= 0; i< cntArgs; ++i)
            result->Arguments[i]= parsed[i];
    }
    return result;
}
 
Target::TemplateArguments* Target::TemplateArguments::PARSE(MonoAllocator& ma, Substring& parser) {
    int       cntArgs= 0;
    String    parsed[128];
 
    if (!parser.ConsumeChar('<') ) {
        ALIB_ERROR("DXL/TARGET", "Template brackets expected.")
        return nullptr;
    }
 
    // find all
    for (;;) {
        // find end of actual
        String256 actParam;
        int depth= 0;
        parser.TrimStart();
        char lastChar;
        for(;;) {
            lastChar= parser.ConsumeChar();
            if ( lastChar == '\0') {
                break; // full syntax error
            }
            if ( String("<([{").IndexOf(lastChar) >= 0 )  ++depth;
            if ( String( ")]}").IndexOf(lastChar) >= 0 )  --depth;
            if ( lastChar == '>' && --depth< 0 )   break;
            if ( lastChar == ',' &&   depth==0 )   break;
 
            actParam._<NC>(lastChar);
        }
 
        // remove ',' or '>'
        actParam.Trim();
        if(actParam.IsNotEmpty()) // full syntax error, otherwise
            parsed[cntArgs++]= String(ma, actParam);
        if ( depth<0 || lastChar==0) {
            break;
        }
 
        if (cntArgs>64) {
            break; // todo: notify caller
        }
        parser.TrimStart();
    }
 
    TemplateArguments* result= ma().Alloc<TemplateArguments>();
    result->Count    = cntArgs;
    if ( cntArgs > 0) {
        result->Arguments= ma().NewArray<String>(cntArgs);
        for (int i= 0; i< cntArgs; ++i)
            result->Arguments[i]= parsed[i];
    }
    return result;
}
 
int Target::FunctionArguments::MATCH(FunctionArguments *linkArgs, FunctionArguments *target) {
    // target has no args?
    if (target==nullptr || target->Count == 0 ) {
        if (linkArgs      ==nullptr) return 2; // XLink has no arg spec given
        if (linkArgs->Count==0)      return 3; // XLink has 0 args given
        return 0;                              // no match
    }
 
    // target has at least one argument
    if (linkArgs      ==nullptr || linkArgs->Count==0)
        return 1;
 
    // search parameters
    int     argNoLink= 0;
    int     argNoTarget= 0;
    bool    exactMatch = true;
    for (;argNoLink<linkArgs->Count && argNoTarget<target->Count;) {
        if ( target->Arguments[argNoTarget].StartsWith(linkArgs->Arguments[argNoLink]) ) {
            if ( target->Arguments[argNoTarget].Length() != linkArgs->Arguments[argNoLink].Length())
                exactMatch= false;
            ++argNoLink;
        }
       ++argNoTarget;
    }
    if ( argNoLink < linkArgs->Count )
        return 0;
    if ( exactMatch && linkArgs->Count == target->Count )
        return 4;
    return 3;
}
 
#include "ALib.Lang.CIMethods.H"
 
int Target::TemplateArguments::Match(Target::TemplateArguments& target) {
    int     argNoSearch= 0;
    int     argNoTarget= 0;
    bool    exactMatch = true;
    for (;argNoSearch < Count && argNoTarget < target.Count;) {
        auto& tArg=  target.Arguments[argNoTarget];
        if (    tArg.StartsWith(Arguments[argNoSearch])
             || (tArg.StartsWith("typename ") && tArg.Substring(9).StartsWith(Arguments[argNoSearch]) )
             || (tArg.StartsWith("class ")    && tArg.Substring(6).StartsWith(Arguments[argNoSearch]) )
            ) {
            if (tArg.Length() != Arguments[argNoSearch].Length())
                exactMatch= false;
            ++argNoSearch;
        }
        ++argNoTarget;
    }
    if ( argNoSearch < Count )
        return 0;
    if ( exactMatch && Count == target.Count )
        return 2;
    return 1;
}
 
void Target::TemplateArguments::Print(AString& dest) {
    dest << '<';
    for (int i= 0; i< Count; ++i) {
        dest << Arguments[i];
        if ( i < Count - 1)
            dest << ", ";
     }
    dest << '>';
}
 
} //namespace [dxl]