Branch data     Line data    Source code

       1                 :            : // *****************************************************************************
       2                 :            : /*!
       3                 :            :   \file      src/Base/Escaper.hpp
       4                 :            :   \copyright 2012-2015 J. Bakosi,
       5                 :            :              2016-2018 Los Alamos National Security, LLC.,
       6                 :            :              2019-2021 Triad National Security, LLC.
       7                 :            :              All rights reserved. See the LICENSE file for details.
       8                 :            :   \brief     String escaper pulled over from PEGTL v0.32
       9                 :            :   \details   String escaper pulled over from PEGTL v0.32 used to extract an
      10                 :            :              std::string from pegtl::string.
      11                 :            : */
      12                 :            : // *****************************************************************************
      13                 :            : #ifndef Escaper_h
      14                 :            : #define Escaper_h
      15                 :            : 
      16                 :            : #include <string>
      17                 :            : 
      18                 :            : namespace kw {
      19                 :            : 
      20                 :     449610 : inline void escape_impl( std::string & result, const int i )
      21                 :            : {
      22 [ -  - ][ -  - ]:     449610 :    switch ( i )
         [ -  - ][ -  - ]
                 [ +  - ]
      23                 :            :    {
      24                 :          0 :       case '"':
      25                 :          0 :          result += "\\\"";
      26                 :          0 :          break;
      27                 :          0 :       case '\\':
      28                 :          0 :          result += "\\\\";
      29                 :          0 :          break;
      30                 :          0 :       case '\a':
      31                 :          0 :          result += "\\a";
      32                 :          0 :          break;
      33                 :          0 :       case '\b':
      34                 :          0 :          result += "\\b";
      35                 :          0 :          break;
      36                 :          0 :       case '\t':
      37                 :          0 :          result += "\\t";
      38                 :          0 :          break;
      39                 :          0 :       case '\n':
      40                 :          0 :          result += "\\n";
      41                 :          0 :          break;
      42                 :          0 :       case '\r':
      43                 :          0 :          result += "\\r";
      44                 :          0 :          break;
      45                 :          0 :       case '\v':
      46                 :          0 :          result += "\\v";
      47                 :          0 :          break;
      48                 :     449610 :       case 32: case 33:          case 35: case 36: case 37: case 38: case 39:
      49                 :            :       case 40: case 41: case 42: case 43: case 44: case 45: case 46: case 47: case 48: case 49:
      50                 :            :       case 50: case 51: case 52: case 53: case 54: case 55: case 56: case 57: case 58: case 59:
      51                 :            :       case 60: case 61: case 62: case 63: case 64: case 65: case 66: case 67: case 68: case 69:
      52                 :            :       case 70: case 71: case 72: case 73: case 74: case 75: case 76: case 77: case 78: case 79:
      53                 :            :       case 80: case 81: case 82: case 83: case 84: case 85: case 86: case 87: case 88: case 89:
      54                 :            :       case 90: case 91:          case 93: case 94: case 95: case 96: case 97: case 98: case 99:
      55                 :            :       case 100: case 101: case 102: case 103: case 104: case 105: case 106: case 107: case 108: case 109:
      56                 :            :       case 110: case 111: case 112: case 113: case 114: case 115: case 116: case 117: case 118: case 119:
      57                 :            :       case 120: case 121: case 122: case 123: case 124: case 125: case 126:
      58                 :     449610 :          result += char( i );
      59                 :     449610 :          break;
      60                 :          0 :       default: {
      61                 :            :          char tmp[ 12 ];
      62                 :          0 :          ::snprintf( tmp, sizeof( tmp ), "\\u%04x", i );
      63         [ -  - ]:          0 :          result += tmp;
      64                 :          0 :       }  break;
      65                 :            :    }
      66                 :     449610 : }
      67                 :            : 
      68                 :     449610 : inline std::string escape( const int i )
      69                 :            : {
      70                 :     449610 :    std::string nrv;
      71         [ +  - ]:     449610 :    escape_impl( nrv, i );
      72                 :     449610 :    return nrv;
      73                 :            : }
      74                 :            : 
      75                 :            : inline std::string escape( const std::string & s )
      76                 :            : {
      77                 :            :    std::string nrv;
      78                 :            : 
      79                 :            :    for ( std::string::size_type i = 0; i < s.size(); ++i ) {
      80                 :            :       escape_impl( nrv, s[ i ] );
      81                 :            :    }
      82                 :            :    return nrv;
      83                 :            : }
      84                 :            : 
      85                 :            : template< int ... Cs > struct escaper;
      86                 :            : 
      87                 :            : template<>
      88                 :            : struct escaper<>
      89                 :            : {
      90                 :      61382 :    static std::string result()
      91                 :            :    {
      92                 :      61382 :       return std::string();
      93                 :            :    }
      94                 :            : };
      95                 :            : 
      96                 :            : template< int C, int ... Cs >
      97                 :            : struct escaper< C, Cs ... >
      98                 :            : {
      99                 :     449610 :    static std::string result()
     100                 :            :    {
     101 [ +  - ][ +  - ]:     449610 :       return escape( C ) + escaper< Cs ... >::result();
     102                 :            :    }
     103                 :            : };
     104                 :            : 
     105                 :            : } // ::kw
     106                 :            : 
     107                 :            : #endif // Escaper_h