nel/src/gui/css_parser.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010-2021  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdpch.h"
  21
  22 #include <string>
  23 #include "nel/misc/types_nl.h"
  24 #include "nel/gui/css_parser.h"
  25 #include "nel/gui/css_style.h"
  26 #include "nel/gui/css_selector.h"
  27
  28 using namespace NLMISC;
  29
  30 #ifdef DEBUG_NEW
  31 #define new DEBUG_NEW
  32 #endif
  33
  34 namespace NLGUI
  35 {
  36         // ***************************************************************************
  37         // Parse style declarations style, eg. "color:red; font-size: 10px;"
  38         //
  39         // key is converted to lowercase
  40         // value is left as is
  41         TStyleVec CCssParser::parseDecls(const std::string &styleString)
  42         {
  43                 TStyleVec styles;
  44                 size_t pos = 0;
  45                 size_t end = styleString.size();
  46                 while(pos < end)
  47                 {
  48                         size_t sep = styleString.find(':', pos);
  49                         if (sep == std::string::npos)
  50                                 break;
  51
  52                         size_t keyIndex = pos;
  53                         size_t keyLength = sep - pos;
  54
  55                         sep++;
  56                         pos = sep;
  57                         while(sep < end)
  58                         {
  59                                 sep = styleString.find_first_of(";'\"(", sep);
  60                                 if (sep == std::string::npos || styleString[sep] == ';')
  61                                         break;
  62
  63                                 if (styleString[sep] == '\'' || styleString[sep] == '"')
  64                                 {
  65                                         char ch = styleString[sep];
  66                                         // skip open quote
  67                                         sep++;
  68                                         while(sep < end && styleString[sep] != ch)
  69                                         {
  70                                                 if (styleString[sep] == '\\')
  71                                                         sep++;
  72                                                 sep++;
  73                                         }
  74                                         // skip close quote
  75                                         sep++;
  76                                 }
  77                                 else if (styleString[sep] == '(')
  78                                 {
  79                                         while(sep < end && styleString[sep] != ')')
  80                                         {
  81                                                 sep++;
  82                                         }
  83                                         // skip close parenthesis
  84                                         sep++;
  85                                 }
  86                         }
  87
  88                         styles.push_back(TStylePair(trim(styleString.substr(keyIndex, keyLength)), trim(styleString.substr(pos, sep - pos))));
  89
  90                         if (sep >= end)
  91                                 break;
  92
  93                         pos = sep + 1;
  94                 }
  95                 return styles;
  96         }
  97
  98         // ***************************************************************************
  99         // Parse stylesheet, eg content from main.css file
 100         //
 101         // Return all found rules
 102         void CCssParser::parseStylesheet(const std::string &cssString, std::vector<CCssStyle::SStyleRule> &result)
 103         {
 104                 _Rules.clear();
 105                 _Style.clear();
 106
 107                 _Style = cssString;
 108                 preprocess();
 109
 110                 _Position = 0;
 111                 while(!is_eof())
 112                 {
 113                         skipWhitespace();
 114
 115                         if (_Style[_Position] == '@')
 116                                 readAtRule();
 117                         else
 118                                 readRule();
 119                 }
 120
 121                 result.insert(result.end(), _Rules.begin(), _Rules.end());
 122                 _Rules.clear();
 123         }
 124
 125         // ***************************************************************************
 126         // Parse selector with style string
 127         // selector: "a#id .class"
 128         // style:    "color: red; font-size: 10px;"
 129         //
 130         // @internal
 131         void CCssParser::parseRule(const std::string &selectorString, const std::string &styleString)
 132         {
 133                 TStyleVec props;
 134                 props = parseDecls(styleString);
 135
 136                 // duplicate props to each selector in selector list,
 137                 // example 'div > p, h1' creates 'div>p' and 'h1'
 138                 for(std::string::size_type pos = 0; pos < selectorString.size(); pos++)
 139                 {
 140                         while(pos < selectorString.size() && is_whitespace(selectorString[pos]))
 141                                 pos++;
 142
 143                         CCssStyle::SStyleRule rule;
 144                         rule.Selector = parse_selector(selectorString, rule.PseudoElement, pos);
 145                         rule.Properties = props;
 146                         if (!rule.Selector.empty())
 147                                 _Rules.push_back(rule);
 148
 149                 }
 150         }
 151
 152         // ***************************************************************************
 153         // Skip over at-rule
 154         // @import ... ;
 155         // @charset ... ;
 156         // @media query { .. }
 157         //
 158         // @internal
 159         void CCssParser::readAtRule()
 160         {
 161                 // skip '@'
 162                 _Position++;
 163
 164                 // skip 'import', 'media', etc
 165                 skipIdentifier();
 166
 167                 // skip at-rule statement
 168                 while(!is_eof() && _Style[_Position] != ';')
 169                 {
 170                         if (maybe_escape())
 171                         {
 172                                 escape();
 173                         }
 174                         else if (is_quote(_Style[_Position]))
 175                         {
 176                                 skipString();
 177                         }
 178                         else if (is_block_open(_Style[_Position]))
 179                         {
 180                                 bool mustBreak = (_Style[_Position] == '{');
 181                                 skipBlock();
 182
 183                                 if(mustBreak)
 184                                 {
 185                                         break;
 186                                 }
 187                         }
 188                         else
 189                         {
 190                                 _Position++;
 191                         }
 192                 }
 193
 194                 // skip ';' or '}'
 195                 _Position++;
 196         }
 197
 198         // ***************************************************************************
 199         // skip over "elm#id.selector[attr]:peseudo, .sel2 { rule }" block
 200         // @internal
 201         void CCssParser::readRule()
 202         {
 203                 size_t start;
 204
 205                 // selector
 206                 start = _Position;
 207                 while(!is_eof())
 208                 {
 209                         if (maybe_escape())
 210                                 _Position++;
 211                         else if (is_quote(_Style[_Position]))
 212                                 skipString();
 213                         else if (_Style[_Position] == '[')
 214                                 skipBlock();
 215                         else if (_Style[_Position] == '{')
 216                                 break;
 217                         else
 218                                 _Position++;
 219                 }
 220
 221                 if (!is_eof())
 222                 {
 223                         std::string selector;
 224                         selector.append(_Style, start, _Position - start);
 225
 226                         skipWhitespace();
 227
 228                         // declaration block
 229                         start = _Position;
 230                         skipBlock();
 231                         if (_Position <= _Style.size())
 232                         {
 233                                 std::string rules;
 234                                 rules.append(_Style, start + 1, _Position - start - 2);
 235
 236                                 parseRule(selector, rules);
 237                         }
 238                 }
 239         }
 240
 241         // ***************************************************************************
 242         // skip over \abcdef escaped sequence or escaped newline char
 243         // @internal
 244         void CCssParser::escape()
 245         {
 246                 // skip '\'
 247                 _Position++;
 248                 if (is_hex(_Style[_Position]))
 249                 {
 250                         // TODO: '\abc def' should be considered one string
 251                         for(uint i=0; i<6 && is_hex(_Style[_Position]); i++)
 252                                 _Position++;
 253
 254                         if (_Style[_Position] == ' ')
 255                                 _Position++;
 256                 }
 257                 else if (_Style[_Position] != 0x0A)
 258                         _Position++;
 259         }
 260
 261         // ***************************************************************************
 262         // @internal
 263         bool CCssParser::skipIdentifier()
 264         {
 265                 size_t start = _Position;
 266                 bool valid = true;
 267                 while(!is_eof() && valid)
 268                 {
 269                         if (maybe_escape())
 270                         {
 271                                 escape();
 272                                 continue;
 273                         }
 274                         else if (is_alpha(_Style[_Position]))
 275                         {
 276                                 // valid
 277                         }
 278                         else if (is_digit(_Style[_Position]))
 279                         {
 280                                 if (_Position == start)
 281                                 {
 282                                         // cannot start with digit
 283                                         valid = false;
 284                                 }
 285                                 else if ((_Position - start) == 0 && _Style[_Position-1] == '-')
 286                                 {
 287                                         // cannot start with -#
 288                                         valid = false;
 289                                 }
 290                         }
 291                         else if (_Style[_Position] == '_')
 292                         {
 293                                 // valid
 294                         }
 295                         else if (_Style[_Position] >= 0x80)
 296                         {
 297                                 // valid
 298                         }
 299                         else if (_Style[_Position] == '-')
 300                         {
 301                                 if ((_Position - start) == 1 && _Style[_Position-1] == '-')
 302                                 {
 303                                         // cannot start with --
 304                                         valid = false;
 305                                 }
 306                         }
 307                         else
 308                         {
 309                                 // we're done
 310                                 break;
 311                         }
 312
 313                         _Position++;
 314                 }
 315
 316                 return valid && !is_eof();
 317         }
 318
 319         // ***************************************************************************
 320         // skip over (..), [..], or {..} blocks
 321         // @internal
 322         void CCssParser::skipBlock()
 323         {
 324                 char startChar = _Style[_Position];
 325
 326                 // block start
 327                 _Position++;
 328                 while(!is_eof() && !is_block_close(_Style[_Position], startChar))
 329                 {
 330                         if (maybe_escape())
 331                                 // skip backslash and next char
 332                                 _Position += 2;
 333                         else if (is_quote(_Style[_Position]))
 334                                 skipString();
 335                         else if (is_block_open(_Style[_Position]))
 336                                 skipBlock();
 337                         else
 338                                 _Position++;
 339                 }
 340
 341                 // block end
 342                 _Position++;
 343         }
 344
 345         // ***************************************************************************
 346         // skip over quoted string
 347         // @internal
 348         void CCssParser::skipString()
 349         {
 350                 char endChar = _Style[_Position];
 351
 352                 // quote start
 353                 _Position++;
 354                 while(!is_eof() && _Style[_Position] != endChar)
 355                 {
 356                         if (maybe_escape())
 357                                 _Position++;
 358
 359                         _Position++;
 360                 }
 361
 362                 // quote end
 363                 _Position++;
 364         }
 365
 366         // ***************************************************************************
 367         // @internal
 368         void CCssParser::skipWhitespace()
 369         {
 370                 while(!is_eof() && is_whitespace(_Style[_Position]))
 371                         _Position++;
 372         }
 373
 374         // ***************************************************************************
 375         // parse selector list
 376         // @internal
 377         std::vector<CCssSelector> CCssParser::parse_selector(const std::string &sel, std::string &pseudoElement, std::string::size_type &pos) const
 378         {
 379                 std::vector<CCssSelector> result;
 380                 CCssSelector current;
 381
 382                 pseudoElement.clear();
 383
 384                 bool failed = false;
 385                 std::string::size_type start = pos;
 386                 while(pos < sel.size() && sel[pos] != ',')
 387                 {
 388                         std::string uc;
 389                         uc = sel[pos];
 390                         if (is_nmchar(sel[pos]) && current.empty())
 391                         {
 392                                 pos++;
 393
 394                                 while(pos < sel.size() && is_nmchar(sel[pos]))
 395                                         pos++;
 396
 397                                 current.Element = toLowerAscii(sel.substr(start, pos - start));
 398                                 start = pos;
 399                                 continue;
 400                         }
 401
 402                         if (sel[pos] == '*' && current.empty())
 403                         {
 404                                 pos++;
 405                                 current.Element = "*";
 406                                 start = pos;
 407                                 continue;
 408                         }
 409
 410                         if(sel[pos] == '#')
 411                         {
 412                                 pos++;
 413                                 start=pos;
 414
 415                                 while(pos < sel.size() && is_nmchar(sel[pos]))
 416                                         pos++;
 417
 418                                 current.Id = toLowerAscii(sel.substr(start, pos - start));
 419                                 start = pos;
 420                         }
 421                         else if (sel[pos] == '.')
 422                         {
 423                                 pos++;
 424                                 start=pos;
 425
 426                                 // .classA.classB
 427                                 while(pos < sel.size() && (is_nmchar(sel[pos]) || sel[pos] == '.'))
 428                                         pos++;
 429
 430                                 current.setClass(toLowerAscii(sel.substr(start, pos - start)));
 431                                 start = pos;
 432                         }
 433                         else if (sel[pos] == '[')
 434                         {
 435                                 pos++;
 436                                 start = pos;
 437
 438                                 if (is_whitespace(sel[pos]))
 439                                 {
 440                                         while(pos < sel.size() && is_whitespace(sel[pos]))
 441                                                 pos++;
 442
 443                                         start = pos;
 444                                 }
 445
 446                                 std::string key;
 447                                 std::string value;
 448                                 char op = ' ';
 449
 450                                 // key
 451                                 while(pos < sel.size() && is_nmchar(sel[pos]))
 452                                         pos++;
 453
 454                                 key = sel.substr(start, pos - start);
 455                                 if (pos == sel.size()) break;
 456
 457                                 if (is_whitespace(sel[pos]))
 458                                 {
 459                                         while(pos < sel.size() && is_whitespace(sel[pos]))
 460                                                 pos++;
 461
 462                                         if (pos == sel.size()) break;
 463                                 }
 464
 465                                 if (sel[pos] == ']')
 466                                 {
 467                                         current.addAttribute(key);
 468                                 }
 469                                 else
 470                                 {
 471                                         // operand
 472                                         op = sel[pos];
 473                                         if (op == '~' || op == '|' || op == '^' || op == '$' || op == '*')
 474                                         {
 475                                                 pos++;
 476                                                 if (pos == sel.size()) break;
 477                                         }
 478
 479                                         // invalid rule?, eg [attr^value]
 480                                         if (sel[pos] != '=')
 481                                         {
 482                                                 while(pos < sel.size() && sel[pos] != ']')
 483                                                         pos++;
 484
 485                                                 if (pos == sel.size()) break;
 486
 487                                                 start = pos;
 488                                         }
 489                                         else
 490                                         {
 491                                                 // skip '='
 492                                                 pos++;
 493
 494                                                 if (is_whitespace(sel[pos]))
 495                                                 {
 496                                                         while(pos < sel.size() && is_whitespace(sel[pos]))
 497                                                                 pos++;
 498
 499                                                         if (pos == sel.size()) break;
 500                                                 }
 501
 502                                                 // value
 503                                                 start = pos;
 504                                                 bool quote = false;
 505                                                 char quoteOpen;
 506                                                 while(pos < sel.size())
 507                                                 {
 508                                                         if (sel[pos] == '\'' || sel[pos] == '"')
 509                                                         {
 510                                                                 // skip over quoted value
 511                                                                 start = pos;
 512                                                                 pos++;
 513                                                                 while(pos < sel.size() && sel[pos] != sel[start])
 514                                                                 {
 515                                                                         if (sel[pos] == '\\')
 516                                                                         {
 517                                                                                 pos++;
 518                                                                         }
 519                                                                         pos++;
 520                                                                 }
 521
 522                                                                 if (pos == sel.size()) break;
 523                                                         }
 524                                                         else if (sel[pos] == '\\')
 525                                                         {
 526                                                                 pos++;
 527                                                         }
 528                                                         else if (!quote && sel[pos] == ']')
 529                                                         {
 530                                                                 value = sel.substr(start, pos - start);
 531                                                                 break;
 532                                                         }
 533
 534                                                         pos++;
 535                                                 } // while 'value'
 536
 537                                                 if (pos == sel.size()) break;
 538
 539                                                 bool cs = true;
 540                                                 // [value="attr" i]
 541                                                 if (value.size() > 2 && value[value.size()-2] == ' ')
 542                                                 {
 543                                                         char lastChar = value[value.size()-1];
 544                                                         if (lastChar == 'i' || lastChar == 'I' || lastChar == 's' || lastChar == 'S')
 545                                                         {
 546                                                                 value = value.substr(0, value.size()-2);
 547                                                                 cs = !((lastChar == 'i' || lastChar == 'I'));
 548                                                         }
 549                                                 }
 550                                                 current.addAttribute(key, trimQuotes(value), (char)op, cs);
 551                                         } // op error
 552                                 } // no value
 553
 554                                 // skip ']'
 555                                 pos++;
 556
 557                                 start = pos;
 558                         }
 559                         else if (sel[pos] == ':')
 560                         {
 561                                 pos++;
 562                                 start=pos;
 563                                 // pseudo element, eg '::before'
 564                                 if (pos < sel.size() && sel[pos] == ':')
 565                                 {
 566                                         pos++;
 567                                 }
 568                                 // :first-child
 569                                 // :nth-child(2n+0)
 570                                 // :not(h1, div#main)
 571                                 // :not(:nth-child(2n+0))
 572                                 // has no support for quotes, eg  :not(h1[attr=")"]) fails
 573                                 while(pos < sel.size() && (is_nmchar(sel[pos]) || sel[pos] == '('))
 574                                 {
 575                                         if (sel[pos] == '(')
 576                                         {
 577                                                 uint open = 1;
 578                                                 pos++;
 579                                                 while(pos < sel.size() && open > 0)
 580                                                 {
 581                                                         if (sel[pos] == ')')
 582                                                                 open--;
 583                                                         else if (sel[pos] == '(')
 584                                                                 open++;
 585
 586                                                         pos++;
 587                                                 }
 588                                                 break;
 589                                         }
 590                                         else
 591                                         {
 592                                                 pos++;
 593                                         }
 594                                 }
 595
 596                                 std::string key = toLowerAscii(sel.substr(start, pos - start));
 597                                 if (key.empty())
 598                                 {
 599                                         failed = true;
 600                                         break;
 601                                 }
 602
 603                                 if (key[0] == ':' || key == "after" || key == "before" || key == "cue" || key == "first-letter" || key == "first-line")
 604                                 {
 605                                         if (!pseudoElement.empty())
 606                                         {
 607                                                 failed = true;
 608                                                 break;
 609                                         }
 610                                         if (key[0] != ':')
 611                                         {
 612                                                 pseudoElement = ":" + key;
 613                                         }
 614                                         else
 615                                         {
 616                                                 pseudoElement = key;
 617                                         }
 618                                 }
 619                                 else
 620                                 {
 621                                         current.addPseudoClass(key);
 622                                 }
 623
 624                                 start = pos;
 625                         }
 626                         else if (!current.empty())
 627                         {
 628                                 // pseudo element like ':before' can only be set on the last selector
 629                                 // user action pseudo classes can be used after pseudo element (ie, :focus, :hover)
 630                                 // there is no support for those and its safe to just fail the selector
 631                                 if (!result.empty() && !pseudoElement.empty())
 632                                 {
 633                                         failed = true;
 634                                         break;
 635                                 }
 636
 637                                 // start new selector as combinator is part of next selector
 638                                 result.push_back(current);
 639                                 current = CCssSelector();
 640
 641                                 // detect and remove whitespace around combinator, eg ' > '
 642                                 bool isSpace = is_whitespace(sel[pos]);;
 643                                 while(pos < sel.size() && is_whitespace(sel[pos]))
 644                                         pos++;
 645
 646                                 if (sel[pos] == '>' || sel[pos] == '+' || sel[pos] == '~')
 647                                 {
 648                                         current.Combinator = sel[pos];
 649                                         pos++;
 650
 651                                         while(pos < sel.size() && is_whitespace(sel[pos]))
 652                                                 pos++;
 653                                 }
 654                                 else if (isSpace)
 655                                 {
 656                                         if (sel[pos] != ',' && sel[pos] != '\0')
 657                                                 current.Combinator = ' ';
 658                                 }
 659                                 else
 660                                 {
 661                                         // unknown
 662                                         current.Combinator = sel[pos];
 663                                         pos++;
 664                                 }
 665
 666                                 start = pos;
 667                         }
 668                         else
 669                         {
 670                                 pos++;
 671                         }
 672                 }
 673
 674                 if (failed)
 675                 {
 676                         result.clear();
 677                 }
 678                 else if (!current.empty())
 679                 {
 680                         result.push_back(current);
 681                 }
 682
 683                 return result;
 684         }
 685
 686         // ***************************************************************************
 687         // @internal
 688         void CCssParser::preprocess()
 689         {
 690                 _Position = 0;
 691
 692                 size_t start;
 693                 size_t charsLeft;
 694                 bool quote = false;
 695                 char quoteChar;
 696                 while(!is_eof())
 697                 {
 698                         charsLeft = _Style.size() - _Position - 1;
 699
 700                         // FF, CR
 701                         if (_Style[_Position] == 0x0C || _Style[_Position] == 0x0D)
 702                         {
 703                                 uint len = 1;
 704                                 // CR, LF
 705                                 if (charsLeft >= 1 && _Style[_Position] == 0x0D && _Style[_Position+1] == 0x0A)
 706                                         len++;
 707
 708                                 std::string tmp;
 709                                 tmp += 0x0A;
 710                                 _Style.replace(_Position, 1, tmp);
 711                         }
 712                         else if (_Style[_Position] == 0x00)
 713                         {
 714                                 // Unicode replacement character
 715                                 // _Style[_Position] = 0xFFFD;
 716                                 _Style.replace(_Position, 1, "\xEF\xBF\xBD");
 717                         }
 718                         else
 719                         {
 720                                 // strip comments for easier parsing
 721                                 if (_Style[_Position] == '\\')
 722                                 {
 723                                         _Position++;
 724                                 }
 725                                 else if (is_quote(_Style[_Position]))
 726                                 {
 727                                         if (!quote)
 728                                                 quoteChar = _Style[_Position];
 729
 730                                         if (quote && _Style[_Position] == quoteChar)
 731                                                 quote = !quote;
 732                                 }
 733                                 else if (!quote && is_comment_open())
 734                                 {
 735                                         size_t pos = _Style.find("*/", _Position + 2);
 736                                         if (pos == std::string::npos)
 737                                                 pos = _Style.size();
 738
 739                                         _Style.erase(_Position, pos - _Position + 2);
 740                                         std::string uc;
 741                                         uc = _Style[_Position];
 742
 743                                         // _Position is already at correct place
 744                                         continue;
 745                                 }
 746                         }
 747
 748                         _Position++;
 749                 }
 750         }
 751 } // namespace
 752