src/plugins/litehtml_viewer/litehtml/html.cpp

   1 #include "html.h"
   2 #include "types.h"
   3 #include "utf8_strings.h"
   4
   5 void litehtml::trim(string &s, const string& chars_to_trim)
   6 {
   7         string::size_type pos = s.find_first_not_of(chars_to_trim);
   8         if(pos != string::npos)
   9         {
  10                 s.erase(s.begin(), s.begin() + pos);
  11         }
  12         else
  13         {
  14                 s = "";
  15                 return;
  16         }
  17         pos = s.find_last_not_of(chars_to_trim);
  18         if(pos != string::npos)
  19         {
  20                 s.erase(s.begin() + pos + 1, s.end());
  21         }
  22 }
  23
  24 void litehtml::lcase(string &s)
  25 {
  26         for(char & i : s)
  27         {
  28                 i = t_tolower(i);
  29         }
  30 }
  31
  32 litehtml::string::size_type litehtml::find_close_bracket(const string &s, string::size_type off, char open_b, char close_b)
  33 {
  34         int cnt = 0;
  35         for(string::size_type i = off; i < s.length(); i++)
  36         {
  37                 if(s[i] == open_b)
  38                 {
  39                         cnt++;
  40                 } else if(s[i] == close_b)
  41                 {
  42                         cnt--;
  43                         if(!cnt)
  44                         {
  45                                 return i;
  46                         }
  47                 }
  48         }
  49         return string::npos;
  50 }
  51
  52 litehtml::string litehtml::index_value(int index, const string& strings, char delim)
  53 {
  54         std::vector<string> vals;
  55         string delims;
  56         delims.push_back(delim);
  57         split_string(strings, vals, delims);
  58         if(index >= 0 && index < vals.size())
  59         {
  60                 return vals[index];
  61         }
  62         return std::to_string(index);
  63 }
  64
  65 int litehtml::value_index( const string& val, const string& strings, int defValue, char delim )
  66 {
  67         if(val.empty() || strings.empty() || !delim)
  68         {
  69                 return defValue;
  70         }
  71
  72         int idx = 0;
  73         string::size_type delim_start   = 0;
  74         string::size_type delim_end     = strings.find(delim, delim_start);
  75         string::size_type item_len;
  76         while(true)
  77         {
  78                 if(delim_end == string::npos)
  79                 {
  80                         item_len = strings.length() - delim_start;
  81                 } else
  82                 {
  83                         item_len = delim_end - delim_start;
  84                 }
  85                 if(item_len == val.length())
  86                 {
  87                         if(val == strings.substr(delim_start, item_len))
  88                         {
  89                                 return idx;
  90                         }
  91                 }
  92                 idx++;
  93                 delim_start = delim_end;
  94                 if(delim_start == string::npos) break;
  95                 delim_start++;
  96                 if(delim_start == strings.length()) break;
  97                 delim_end = strings.find(delim, delim_start);
  98         }
  99         return defValue;
 100 }
 101
 102 bool litehtml::value_in_list( const string& val, const string& strings, char delim )
 103 {
 104         int idx = value_index(val, strings, -1, delim);
 105         if(idx >= 0)
 106         {
 107                 return true;
 108         }
 109         return false;
 110 }
 111
 112 void litehtml::split_string(const string& str, string_vector& tokens, const string& delims, const string& delims_preserve, const string& quote)
 113 {
 114         if(str.empty() || (delims.empty() && delims_preserve.empty()))
 115         {
 116                 return;
 117         }
 118
 119         string all_delims = delims + delims_preserve + quote;
 120
 121         string::size_type token_start   = 0;
 122         string::size_type token_end     = str.find_first_of(all_delims, token_start);
 123         string::size_type token_len;
 124         string token;
 125         while(true)
 126         {
 127                 while( token_end != string::npos && quote.find_first_of(str[token_end]) != string::npos )
 128                 {
 129                         if(str[token_end] == '(')
 130                         {
 131                                 token_end = find_close_bracket(str, token_end, '(', ')');
 132                         } else if(str[token_end] == '[')
 133                         {
 134                                 token_end = find_close_bracket(str, token_end, '[', ']');
 135                         } else if(str[token_end] == '{')
 136                         {
 137                                 token_end = find_close_bracket(str, token_end, '{', '}');
 138                         } else
 139                         {
 140                                 token_end = str.find_first_of(str[token_end], token_end + 1);
 141                         }
 142                         if(token_end != string::npos)
 143                         {
 144                                 token_end = str.find_first_of(all_delims, token_end + 1);
 145                         }
 146                 }
 147
 148                 if(token_end == string::npos)
 149                 {
 150                         token_len = string::npos;
 151                 } else
 152                 {
 153                         token_len = token_end - token_start;
 154                 }
 155
 156                 token = str.substr(token_start, token_len);
 157                 if(!token.empty())
 158                 {
 159                         tokens.push_back( token );
 160                 }
 161                 if(token_end != string::npos && !delims_preserve.empty() && delims_preserve.find_first_of(str[token_end]) != string::npos)
 162                 {
 163                         tokens.push_back( str.substr(token_end, 1) );
 164                 }
 165
 166                 token_start = token_end;
 167                 if(token_start == string::npos) break;
 168                 token_start++;
 169                 if(token_start == str.length()) break;
 170                 token_end = str.find_first_of(all_delims, token_start);
 171         }
 172 }
 173
 174 void litehtml::join_string(string& str, const string_vector& tokens, const string& delims)
 175 {
 176         str = "";
 177         for (size_t i = 0; i < tokens.size(); i++)
 178         {
 179                 if (i != 0)
 180                 {
 181                         str += delims;
 182                 }
 183                 str += tokens[i];
 184         }
 185 }
 186
 187 int litehtml::t_strcasecmp(const char *s1, const char *s2)
 188 {
 189         int i, d, c;
 190
 191         for (i = 0;; i++)
 192         {
 193                 c = t_tolower((unsigned char)s1[i]);
 194                 d = c - t_tolower((unsigned char)s2[i]);
 195                 if (d < 0)
 196                         return -1;
 197                 else if (d > 0)
 198                         return 1;
 199                 else if (c == 0)
 200                         return 0;
 201         }
 202 }
 203
 204 int litehtml::t_strncasecmp(const char *s1, const char *s2, size_t n)
 205 {
 206         int i, d, c;
 207
 208         for (i = 0; i < n; i++)
 209         {
 210                 c = t_tolower((unsigned char)s1[i]);
 211                 d = c - t_tolower((unsigned char)s2[i]);
 212                 if (d < 0)
 213                         return -1;
 214                 else if (d > 0)
 215                         return 1;
 216                 else if (c == 0)
 217                         return 0;
 218         }
 219
 220         return 0;
 221 }
 222
 223 litehtml::string litehtml::get_escaped_string(const string& in_str)
 224 {
 225         string ret;
 226         for (auto ch : in_str)
 227         {
 228                 switch (ch)
 229                 {
 230                         case '\'':
 231                                 ret += "\\'";
 232                                 break;
 233
 234                         case '\"':
 235                                 ret += "\\\"";
 236                                 break;
 237
 238                         case '\?':
 239                                 ret += "\\?";
 240                                 break;
 241
 242                         case '\\':
 243                                 ret += "\\\\";
 244                                 break;
 245
 246                         case '\a':
 247                                 ret += "\\a";
 248                                 break;
 249
 250                         case '\b':
 251                                 ret += "\\b";
 252                                 break;
 253
 254                         case '\f':
 255                                 ret += "\\f";
 256                                 break;
 257
 258                         case '\n':
 259                                 ret += "\\n";
 260                                 break;
 261
 262                         case '\r':
 263                                 ret += "\\r";
 264                                 break;
 265
 266                         case '\t':
 267                                 ret += "\\t";
 268                                 break;
 269
 270                         case '\v':
 271                                 ret += "\\v";
 272                                 break;
 273
 274                         default:
 275                                 ret += ch;
 276                 }
 277         }
 278         return ret;
 279 }
 280
 281 bool litehtml::is_number(const string& string, const bool allow_dot) {
 282         for (auto ch : string)
 283         {
 284                 if (!(t_isdigit(ch) || (allow_dot && ch == '.')))
 285                 {
 286                         return false;
 287                 }
 288         }
 289         return true;
 290 }