escaper.cpp

// #################################################################################################
//  ALib C++ Library
//
//  Copyright 2013-2024 A-Worx GmbH, Germany
//  Published under 'Boost Software License' (a free software license, see LICENSE.txt)
// #################################################################################################
#include "alib/alib_precompile.hpp"
 
#if !DOXYGEN
#   include "alib/strings/util/escaper.hpp"
#   include "alib/strings/util/tokenizer.hpp"
#endif // !DOXYGEN
 
namespace alib::strings::util {
 
// =================================================================================================
// ==== StringEscaper
// =================================================================================================
#if ALIB_MONOMEM
int StringEscaper::EscapeTokens( StringVectorMA& result, const String& value, const String& delimiters  ) const
{
    const integer oldSize= result.Size();
    Tokenizer tknzr( value, delimiters.CharAtStart() );
    tknzr.TrimChars.Reset();
    while(tknzr.HasNext())
        result.Add( tknzr.Next() );
    
    return int(result.Size() - oldSize);
}
#endif // if ALIB_MONOMEM
 
// =================================================================================================
// ==== StringEscaperStandard
// =================================================================================================
AString& StringEscaperStandard::Unescape( const String& src, AString& dest )                   const
{
    Substring parser(src);
    parser.Trim();
    if( parser.Length() > 1 && parser.CharAtStart() == '"' && parser.CharAtEnd() == '"')
    {
        parser.ConsumeChar       <NC>();
        parser.ConsumeCharFromEnd<NC>();
    }
    bool lastWasSlash= false;
 
    while( parser.IsNotEmpty() )
    {
        character c= parser.ConsumeChar<NC>();
 
        if( lastWasSlash )
        {
            lastWasSlash= false;
            character escChr= c == '\\' ? '\\' :
                              c == '"'  ? '"'  :
                              c == 'n'  ? '\n' :
                              c == 'r'  ? '\r' :
                              c == 't'  ? '\t' :
                              c == 'a'  ? '\a' :
                              c == 'b'  ? '\b' :
                              c == 'v'  ? '\v' :
                              c == 'f'  ? '\f' :
                              c == 'e'  ? '\033' :
                              c;
 
            dest._<NC>(escChr);
            continue;
        }
 
        if( c== '\\' )
        {
            lastWasSlash= true;
            continue;
        }
 
        dest._<NC>(c);
    }
 
    return dest;
}
 
AString& StringEscaperStandard::Escape( const String& src, AString& dest, const String& delimiters )    const
{
    Substring parser(src);
    bool needsQuotes=    parser.CharAtStart() == ' '
                      || parser.CharAtStart() == '\t'
                      || parser.CharAtEnd()   == ' '
                      || parser.CharAtEnd()   == '\t';
    if (!needsQuotes)
        for( auto c : delimiters )
            if( parser.IndexOf(c) >= 0 )
            {
                needsQuotes= true;
                break;
            }
                      
    if ( needsQuotes )
        dest._<NC>('"');
 
    while( parser.IsNotEmpty() )
    {
        character c= parser.ConsumeChar();
 
        switch(c)
        {
            case '"'    : dest._<NC>(needsQuotes ? "\\\"" : "\"");
                          break;
            case '\\'   : dest._<NC>("\\\\"); break;
            case '\r'   : dest._<NC>("\\r" ); break;
            case '\n'   : dest._<NC>("\\n" ); break;
            case '\t'   : dest._<NC>("\\t" ); break;
            case '\a'   : dest._<NC>("\\a" ); break;
            case '\b'   : dest._<NC>("\\b" ); break;
            case '\v'   : dest._<NC>("\\v" ); break;
            case '\f'   : dest._<NC>("\\f" ); break;
            case '\033' : dest._<NC>("\\e" ); break;
            default     : dest._<NC>(c);      break;
        }
    }
 
    if ( needsQuotes )
        dest._('"');
 
    return dest;
}
 
 
#if ALIB_MONOMEM
int StringEscaperStandard::EscapeTokens( StringVectorMA& result, const String& src, const String& delimiters )  const
{
    String2K buf;
    const integer oldSize= result.Size();
    Tokenizer tknzr( src, delimiters.CharAtStart() );
    tknzr.TrimChars.Reset();
    while(tknzr.HasNext())
    {
        Escape( tknzr.Next(), buf.Reset(), delimiters );
        result.Add( buf );
    }
    return int(result.Size() - oldSize);
}
 
int StringEscaperStandard::UnescapeTokens( StringVectorMA& result, const String& value, const String& delimiters  ) const
{
    const integer oldSize= result.Size();
    String512 tempBuf; tempBuf.DbgDisableBufferReplacementWarning();
    Substring src( value );
 
    // tokenize
    bool inQuote=      false;
    bool lastWasSlash= false;
    integer idx=          0;
    while( idx < src.Length()  )
    {
        character c= src.CharAt<NC>( idx++ );
 
        if( lastWasSlash )
        {
            lastWasSlash= false;
            continue;
        }
 
        if( c== '\\' )
        {
            lastWasSlash= true;
            continue;
        }
 
        if( c== '"' && (idx==1 || inQuote) )
        {
            inQuote= !inQuote;
            continue;
        }
 
        if( !inQuote && delimiters.IndexOf(c) >= 0 )
        {
            Substring tok= src.Substring<NC>( 0, idx - 1 );
            Unescape( tok, tempBuf );
            result.Add( tempBuf );
            tempBuf.Reset();
            src.ConsumeChars( idx );
            src.TrimStart();
            idx= 0;
        }
    }
 
    if ( src.IsNotEmpty() )
    {
        Unescape( src, tempBuf );
        result.Add( tempBuf );
    }
 
    return int (result.Size() - oldSize);
}
#endif // if ALIB_MONOMEM
 
 
 
} // namespace [alib::util::strings]