LibreOffice Module sw (master)  1
parcss1.cxx
Go to the documentation of this file.
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of the LibreOffice project.
4  *
5  * This Source Code Form is subject to the terms of the Mozilla Public
6  * License, v. 2.0. If a copy of the MPL was not distributed with this
7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8  *
9  * This file incorporates work covered by the following license notice:
10  *
11  * Licensed to the Apache Software Foundation (ASF) under one or more
12  * contributor license agreements. See the NOTICE file distributed
13  * with this work for additional information regarding copyright
14  * ownership. The ASF licenses this file to you under the Apache
15  * License, Version 2.0 (the "License"); you may not use this file
16  * except in compliance with the License. You may obtain a copy of
17  * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18  */
19 
20 #include <stdlib.h>
21 #include <limits.h>
22 #include <osl/diagnose.h>
23 #include <rtl/character.hxx>
24 #include <rtl/ustrbuf.hxx>
25 #include <tools/color.hxx>
26 #include <vcl/svapp.hxx>
27 #include <svtools/htmltokn.h>
28 #include <comphelper/string.hxx>
29 #include "css1kywd.hxx"
30 #include "parcss1.hxx"
31 
32 // Loop-Check: Used to avoid infinite loops, is checked after every
33 // loop, if there is progress of the input position
34 #define LOOP_CHECK
35 
36 #ifdef LOOP_CHECK
37 
38 #define LOOP_CHECK_DECL \
39  sal_Int32 nOldInPos = SAL_MAX_INT32;
40 #define LOOP_CHECK_RESTART \
41  nOldInPos = SAL_MAX_INT32;
42 #define LOOP_CHECK_CHECK( where ) \
43  OSL_ENSURE( nOldInPos!=m_nInPos || m_cNextCh==sal_Unicode(EOF), where ); \
44  if( nOldInPos==m_nInPos && m_cNextCh!=sal_Unicode(EOF) ) \
45  break; \
46  else \
47  nOldInPos = m_nInPos;
48 
49 #else
50 
51 #define LOOP_CHECK_DECL
52 #define LOOP_CHECK_RESTART
53 #define LOOP_CHECK_CHECK( where )
54 
55 #endif
56 
57 const sal_Int32 MAX_LEN = 1024;
58 
59 void CSS1Parser::InitRead( const OUString& rIn )
60 {
61  m_nlLineNr = 0;
62  m_nlLinePos = 0;
63 
64  m_bWhiteSpace = true; // if nothing was read it's like there was WS
65  m_bEOF = false;
66  m_eState = CSS1_PAR_WORKING;
67  m_nValue = 0.;
68 
69  m_aIn = rIn;
70  m_nInPos = 0;
71  m_cNextCh = GetNextChar();
72  m_nToken = GetNextToken();
73 }
74 
75 sal_Unicode CSS1Parser::GetNextChar()
76 {
77  if( m_nInPos >= m_aIn.getLength() )
78  {
79  m_bEOF = true;
80  return sal_Unicode(EOF);
81  }
82 
83  sal_Unicode c = m_aIn[m_nInPos];
84  m_nInPos++;
85 
86  if( c == '\n' )
87  {
88  ++m_nlLineNr;
89  m_nlLinePos = 1;
90  }
91  else
92  ++m_nlLinePos;
93 
94  return c;
95 }
96 
97 // This function implements the scanner described in
98 
99 // http://www.w3.org/pub/WWW/TR/WD-css1.html
100 // resp. http://www.w3.org/pub/WWW/TR/WD-css1-960220.html
101 
102 // for CSS1. It's a direct implementation of the
103 // described Lex grammar.
104 
105 CSS1Token CSS1Parser::GetNextToken()
106 {
107  CSS1Token nRet = CSS1_NULL;
108  m_aToken.clear();
109 
110  do {
111  // remember if white space was read
112  bool bPrevWhiteSpace = m_bWhiteSpace;
113  m_bWhiteSpace = false;
114 
115  bool bNextCh = true;
116  switch( m_cNextCh )
117  {
118  case '/': // COMMENT | '/'
119  {
120  m_cNextCh = GetNextChar();
121  if( '*' == m_cNextCh )
122  {
123  // COMMENT
124  m_cNextCh = GetNextChar();
125 
126  bool bAsterisk = false;
127  while( !(bAsterisk && '/'==m_cNextCh) && !IsEOF() )
128  {
129  bAsterisk = ('*'==m_cNextCh);
130  m_cNextCh = GetNextChar();
131  }
132  }
133  else
134  {
135  // '/'
136  bNextCh = false;
137  nRet = CSS1_SLASH;
138  }
139  }
140  break;
141 
142  case '@': // '@import' | '@XXX'
143  {
144  m_cNextCh = GetNextChar();
145  if (rtl::isAsciiAlpha(m_cNextCh))
146  {
147  // scan the next identifier
148  OUStringBuffer sTmpBuffer(32);
149  do {
150  sTmpBuffer.append( m_cNextCh );
151  m_cNextCh = GetNextChar();
152  } while( (rtl::isAsciiAlphanumeric(m_cNextCh) ||
153  '-' == m_cNextCh) && !IsEOF() );
154 
155  m_aToken += sTmpBuffer;
156 
157  // check if we know it
158  switch( m_aToken[0] )
159  {
160  case 'i':
161  case 'I':
162  if( m_aToken.equalsIgnoreAsciiCase( "import" ) )
163  nRet = CSS1_IMPORT_SYM;
164  break;
165  case 'p':
166  case 'P':
167  if( m_aToken.equalsIgnoreAsciiCase( "page" ) )
168  nRet = CSS1_PAGE_SYM;
169  break;
170  }
171 
172  // error handling: ignore '@indent' and the rest until
173  // semicolon at end of the next block
174  if( CSS1_NULL==nRet )
175  {
176  m_aToken.clear();
177  int nBlockLvl = 0;
178  sal_Unicode cQuoteCh = 0;
179  bool bDone = false, bEscape = false;
180  while( !bDone && !IsEOF() )
181  {
182  bool bOldEscape = bEscape;
183  bEscape = false;
184  switch( m_cNextCh )
185  {
186  case '{':
187  if( !cQuoteCh && !bOldEscape )
188  nBlockLvl++;
189  break;
190  case ';':
191  if( !cQuoteCh && !bOldEscape )
192  bDone = nBlockLvl==0;
193  break;
194  case '}':
195  if( !cQuoteCh && !bOldEscape )
196  bDone = --nBlockLvl==0;
197  break;
198  case '\"':
199  case '\'':
200  if( !bOldEscape )
201  {
202  if( cQuoteCh )
203  {
204  if( cQuoteCh == m_cNextCh )
205  cQuoteCh = 0;
206  }
207  else
208  {
209  cQuoteCh = m_cNextCh;
210  }
211  }
212  break;
213  case '\\':
214  if( !bOldEscape )
215  bEscape = true;
216  break;
217  }
218  m_cNextCh = GetNextChar();
219  }
220  }
221 
222  bNextCh = false;
223  }
224  }
225  break;
226 
227  case '!': // '!' 'legal' | '!' 'important' | syntax error
228  {
229  // ignore white space
230  m_cNextCh = GetNextChar();
231  while( ( ' ' == m_cNextCh ||
232  (m_cNextCh >= 0x09 && m_cNextCh <= 0x0d) ) && !IsEOF() )
233  {
234  m_bWhiteSpace = true;
235  m_cNextCh = GetNextChar();
236  }
237 
238  if( 'i'==m_cNextCh || 'I'==m_cNextCh)
239  {
240  // scan next identifier
241  OUStringBuffer sTmpBuffer(32);
242  do {
243  sTmpBuffer.append( m_cNextCh );
244  m_cNextCh = GetNextChar();
245  } while( (rtl::isAsciiAlphanumeric(m_cNextCh) ||
246  '-' == m_cNextCh) && !IsEOF() );
247 
248  m_aToken += sTmpBuffer;
249 
250  if( ( 'i'==m_aToken[0] || 'I'==m_aToken[0] ) &&
251  m_aToken.equalsIgnoreAsciiCase( "important" ) )
252  {
253  // '!' 'important'
254  nRet = CSS1_IMPORTANT_SYM;
255  }
256  else
257  {
258  // error handling: ignore '!', not IDENT
259  nRet = CSS1_IDENT;
260  }
261 
262  m_bWhiteSpace = false;
263  bNextCh = false;
264  }
265  else
266  {
267  // error handling: ignore '!'
268  bNextCh = false;
269  }
270  }
271  break;
272 
273  case '\"':
274  case '\'': // STRING
275  {
276  // \... isn't possible yet!!!
277  sal_Unicode cQuoteChar = m_cNextCh;
278  m_cNextCh = GetNextChar();
279 
280  OUStringBuffer sTmpBuffer( MAX_LEN );
281  do {
282  sTmpBuffer.append( m_cNextCh );
283  m_cNextCh = GetNextChar();
284  } while( cQuoteChar != m_cNextCh && !IsEOF() );
285 
286  m_aToken += sTmpBuffer;
287 
288  nRet = CSS1_STRING;
289  }
290  break;
291 
292  case '0':
293  case '1':
294  case '2':
295  case '3':
296  case '4':
297  case '5':
298  case '6':
299  case '7':
300  case '8':
301  case '9': // NUMBER | PERCENTAGE | LENGTH
302  {
303  // save current position
304  std::size_t nInPosSave = m_nInPos;
305  sal_Unicode cNextChSave = m_cNextCh;
306  sal_uInt32 nlLineNrSave = m_nlLineNr;
307  sal_uInt32 nlLinePosSave = m_nlLinePos;
308  bool bEOFSave = m_bEOF;
309 
310  // first try to parse a hex digit
311  OUStringBuffer sTmpBuffer( 16 );
312  do {
313  sTmpBuffer.append( m_cNextCh );
314  m_cNextCh = GetNextChar();
315  } while( sTmpBuffer.getLength() < 7 &&
316  ( ('0'<=m_cNextCh && '9'>=m_cNextCh) ||
317  ('A'<=m_cNextCh && 'F'>=m_cNextCh) ||
318  ('a'<=m_cNextCh && 'f'>=m_cNextCh) ) &&
319  !IsEOF() );
320 
321  if( sTmpBuffer.getLength()==6 )
322  {
323  // we found a color in hex
324  m_aToken += sTmpBuffer;
325  nRet = CSS1_HEXCOLOR;
326  bNextCh = false;
327 
328  break;
329  }
330 
331  // otherwise we try a number
332  m_nInPos = nInPosSave;
333  m_cNextCh = cNextChSave;
334  m_nlLineNr = nlLineNrSave;
335  m_nlLinePos = nlLinePosSave;
336  m_bEOF = bEOFSave;
337 
338  // first parse the number
339  sTmpBuffer.setLength( 0 );
340  do {
341  sTmpBuffer.append( m_cNextCh );
342  m_cNextCh = GetNextChar();
343  } while( (('0'<=m_cNextCh && '9'>=m_cNextCh) || '.'==m_cNextCh) &&
344  !IsEOF() );
345 
346  m_aToken += sTmpBuffer;
347  m_nValue = m_aToken.toDouble();
348 
349  // ignore white space
350  while( ( ' ' == m_cNextCh ||
351  (m_cNextCh >= 0x09 && m_cNextCh <= 0x0d) ) && !IsEOF() )
352  {
353  m_bWhiteSpace = true;
354  m_cNextCh = GetNextChar();
355  }
356 
357  // check now, of there is an unit
358  switch( m_cNextCh )
359  {
360  case '%': // PERCENTAGE
361  m_bWhiteSpace = false;
362  nRet = CSS1_PERCENTAGE;
363  break;
364 
365  case 'c':
366  case 'C': // LENGTH cm | LENGTH IDENT
367  case 'e':
368  case 'E': // LENGTH (em | ex) | LENGTH IDENT
369  case 'i':
370  case 'I': // LENGTH inch | LENGTH IDENT
371  case 'p':
372  case 'P': // LENGTH (pt | px | pc) | LENGTH IDENT
373  case 'm':
374  case 'M': // LENGTH mm | LENGTH IDENT
375  {
376  // save current position
377  sal_Int32 nInPosOld = m_nInPos;
378  sal_Unicode cNextChOld = m_cNextCh;
379  sal_uLong nlLineNrOld = m_nlLineNr;
380  sal_uLong nlLinePosOld = m_nlLinePos;
381  bool bEOFOld = m_bEOF;
382 
383  // parse the next identifier
384  OUString aIdent;
385  OUStringBuffer sTmpBuffer2(64);
386  do {
387  sTmpBuffer2.append( m_cNextCh );
388  m_cNextCh = GetNextChar();
389  } while( (rtl::isAsciiAlphanumeric(m_cNextCh) ||
390  '-' == m_cNextCh) && !IsEOF() );
391 
392  aIdent += sTmpBuffer2;
393 
394  // Is it an unit?
395  const sal_Char *pCmp1 = nullptr, *pCmp2 = nullptr, *pCmp3 = nullptr;
396  double nScale1 = 1., nScale2 = 1.;
397  CSS1Token nToken1 = CSS1_LENGTH,
398  nToken2 = CSS1_LENGTH,
399  nToken3 = CSS1_LENGTH;
400  switch( aIdent[0] )
401  {
402  case 'c':
403  case 'C':
404  pCmp1 = "cm";
405  nScale1 = (72.*20.)/2.54; // twip
406  break;
407  case 'e':
408  case 'E':
409  pCmp1 = "em";
410  nToken1 = CSS1_EMS;
411 
412  pCmp2 = "ex";
413  nToken2 = CSS1_EMX;
414  break;
415  case 'i':
416  case 'I':
417  pCmp1 = "in";
418  nScale1 = 72.*20.; // twip
419  break;
420  case 'm':
421  case 'M':
422  pCmp1 = "mm";
423  nScale1 = (72.*20.)/25.4; // twip
424  break;
425  case 'p':
426  case 'P':
427  pCmp1 = "pt";
428  nScale1 = 20.; // twip
429 
430  pCmp2 = "pc";
431  nScale2 = 12.*20.; // twip
432 
433  pCmp3 = "px";
434  nToken3 = CSS1_PIXLENGTH;
435  break;
436  }
437 
438  double nScale = 0.0;
439  OSL_ENSURE( pCmp1, "Where does the first digit come from?" );
440  if( aIdent.equalsIgnoreAsciiCaseAscii( pCmp1 ) )
441  {
442  nScale = nScale1;
443  nRet = nToken1;
444  }
445  else if( pCmp2 &&
446  aIdent.equalsIgnoreAsciiCaseAscii( pCmp2 ) )
447  {
448  nScale = nScale2;
449  nRet = nToken2;
450  }
451  else if( pCmp3 &&
452  aIdent.equalsIgnoreAsciiCaseAscii( pCmp3 ) )
453  {
454  nScale = 1.; // nScale3
455  nRet = nToken3;
456  }
457  else
458  {
459  nRet = CSS1_NUMBER;
460  }
461 
462  if( CSS1_LENGTH==nRet && nScale!=1.0 )
463  m_nValue *= nScale;
464 
465  if( nRet == CSS1_NUMBER )
466  {
467  m_nInPos = nInPosOld;
468  m_cNextCh = cNextChOld;
469  m_nlLineNr = nlLineNrOld;
470  m_nlLinePos = nlLinePosOld;
471  m_bEOF = bEOFOld;
472  }
473  else
474  {
475  m_bWhiteSpace = false;
476  }
477  bNextCh = false;
478  }
479  break;
480  default: // NUMBER IDENT
481  bNextCh = false;
482  nRet = CSS1_NUMBER;
483  break;
484  }
485  }
486  break;
487 
488  case ':': // ':'
489  // catch link/visited/active !!!
490  nRet = CSS1_COLON;
491  break;
492 
493  case '.': // DOT_W_WS | DOT_WO_WS
494  nRet = bPrevWhiteSpace ? CSS1_DOT_W_WS : CSS1_DOT_WO_WS;
495  break;
496 
497  case '+': // '+'
498  nRet = CSS1_PLUS;
499  break;
500 
501  case '-': // '-'
502  nRet = CSS1_MINUS;
503  break;
504 
505  case '{': // '{'
506  nRet = CSS1_OBRACE;
507  break;
508 
509  case '}': // '}'
510  nRet = CSS1_CBRACE;
511  break;
512 
513  case ';': // ';'
514  nRet = CSS1_SEMICOLON;
515  break;
516 
517  case ',': // ','
518  nRet = CSS1_COMMA;
519  break;
520 
521  case '#': // '#'
522  m_cNextCh = GetNextChar();
523  if( ('0'<=m_cNextCh && '9'>=m_cNextCh) ||
524  ('a'<=m_cNextCh && 'f'>=m_cNextCh) ||
525  ('A'<=m_cNextCh && 'F'>=m_cNextCh) )
526  {
527  // save current position
528  sal_Int32 nInPosSave = m_nInPos;
529  sal_Unicode cNextChSave = m_cNextCh;
530  sal_uLong nlLineNrSave = m_nlLineNr;
531  sal_uLong nlLinePosSave = m_nlLinePos;
532  bool bEOFSave = m_bEOF;
533 
534  // first try to parse a hex digit
535  OUStringBuffer sTmpBuffer(6);
536  do {
537  sTmpBuffer.append( m_cNextCh );
538  m_cNextCh = GetNextChar();
539  } while( sTmpBuffer.getLength() < 7 &&
540  ( ('0'<=m_cNextCh && '9'>=m_cNextCh) ||
541  ('A'<=m_cNextCh && 'F'>=m_cNextCh) ||
542  ('a'<=m_cNextCh && 'f'>=m_cNextCh) ) &&
543  !IsEOF() );
544 
545  if( sTmpBuffer.getLength()==6 || sTmpBuffer.getLength()==3 )
546  {
547  // we found a color in hex
548  m_aToken += sTmpBuffer;
549  nRet = CSS1_HEXCOLOR;
550  bNextCh = false;
551 
552  break;
553  }
554 
555  // otherwise we try a number
556  m_nInPos = nInPosSave;
557  m_cNextCh = cNextChSave;
558  m_nlLineNr = nlLineNrSave;
559  m_nlLinePos = nlLinePosSave;
560  m_bEOF = bEOFSave;
561  }
562 
563  nRet = CSS1_HASH;
564  bNextCh = false;
565  break;
566 
567  case ' ':
568  case '\t':
569  case '\r':
570  case '\n': // White-Space
571  m_bWhiteSpace = true;
572  break;
573 
574  case sal_Unicode(EOF):
575  if( IsEOF() )
576  {
577  m_eState = CSS1_PAR_ACCEPTED;
578  bNextCh = false;
579  break;
580  }
581  [[fallthrough]];
582 
583  default: // IDENT | syntax error
584  if (rtl::isAsciiAlpha(m_cNextCh))
585  {
586  // IDENT
587 
588  bool bHexColor = true;
589 
590  // parse the next identifier
591  OUStringBuffer sTmpBuffer(64);
592  do {
593  sTmpBuffer.append( m_cNextCh );
594  if( bHexColor )
595  {
596  bHexColor = sTmpBuffer.getLength()<7 &&
597  ( ('0'<=m_cNextCh && '9'>=m_cNextCh) ||
598  ('A'<=m_cNextCh && 'F'>=m_cNextCh) ||
599  ('a'<=m_cNextCh && 'f'>=m_cNextCh) );
600  }
601  m_cNextCh = GetNextChar();
602  } while( (rtl::isAsciiAlphanumeric(m_cNextCh) ||
603  '-' == m_cNextCh) && !IsEOF() );
604 
605  m_aToken += sTmpBuffer;
606 
607  if( bHexColor && sTmpBuffer.getLength()==6 )
608  {
609  bNextCh = false;
610  nRet = CSS1_HEXCOLOR;
611 
612  break;
613  }
614  if( '('==m_cNextCh &&
615  ( (('u'==m_aToken[0] || 'U'==m_aToken[0]) &&
616  m_aToken.equalsIgnoreAsciiCase( "url" )) ||
617  (('r'==m_aToken[0] || 'R'==m_aToken[0]) &&
618  m_aToken.equalsIgnoreAsciiCase( "rgb" )) ) )
619  {
620  int nNestCnt = 0;
621  OUStringBuffer sTmpBuffer2(64);
622  do {
623  sTmpBuffer2.append( m_cNextCh );
624  switch( m_cNextCh )
625  {
626  case '(': nNestCnt++; break;
627  case ')': nNestCnt--; break;
628  }
629  m_cNextCh = GetNextChar();
630  } while( (nNestCnt>1 || ')'!=m_cNextCh) && !IsEOF() );
631  sTmpBuffer2.append( m_cNextCh );
632  m_aToken += sTmpBuffer2;
633  bNextCh = true;
634  nRet = 'u'==m_aToken[0] || 'U'==m_aToken[0]
635  ? CSS1_URL
636  : CSS1_RGB;
637  }
638  else
639  {
640  bNextCh = false;
641  nRet = CSS1_IDENT;
642  }
643  }
644  // error handling: ignore digit
645  break;
646  }
647  if( bNextCh )
648  m_cNextCh = GetNextChar();
649 
650  } while( CSS1_NULL==nRet && IsParserWorking() );
651 
652  return nRet;
653 }
654 
655 // These functions implement the parser described in
656 
657 // http://www.w3.org/pub/WWW/TR/WD-css1.html
658 // resp. http://www.w3.org/pub/WWW/TR/WD-css1-960220.html
659 
660 // for CSS1. It's a direct implementation of the
661 // described Lex grammar.
662 
663 // stylesheet
664 // : import* rule*
665 
666 // import
667 // : IMPORT_SYM url
668 
669 // url
670 // : STRING
671 
672 void CSS1Parser::ParseStyleSheet()
673 {
674  LOOP_CHECK_DECL
675 
676  // import*
677  bool bDone = false;
678  while( !bDone && IsParserWorking() )
679  {
680  LOOP_CHECK_CHECK( "Infinite loop in ParseStyleSheet()/import *" )
681 
682  switch( m_nToken )
683  {
684  case CSS1_IMPORT_SYM:
685  // IMPORT_SYM url
686  // URL are skipped without checks
687  m_nToken = GetNextToken();
688  break;
689  case CSS1_IDENT: // Look-Aheads
690  case CSS1_DOT_W_WS:
691  case CSS1_HASH:
692  case CSS1_PAGE_SYM:
693  // rule
694  bDone = true;
695  break;
696  default:
697  // error handling: ignore
698  break;
699  }
700 
701  if( !bDone )
702  m_nToken = GetNextToken();
703  }
704 
705  LOOP_CHECK_RESTART
706 
707  // rule *
708  while( IsParserWorking() )
709  {
710  LOOP_CHECK_CHECK( "Infinite loop in ParseStyleSheet()/rule *" )
711 
712  switch( m_nToken )
713  {
714  case CSS1_IDENT: // Look-Aheads
715  case CSS1_DOT_W_WS:
716  case CSS1_HASH:
717  case CSS1_PAGE_SYM:
718  // rule
719  ParseRule();
720  break;
721  default:
722  // error handling: ignore
723  m_nToken = GetNextToken();
724  break;
725  }
726  }
727 }
728 
729 // rule
730 // : selector [ ',' selector ]*
731 // '{' declaration [ ';' declaration ]* '}'
732 
733 void CSS1Parser::ParseRule()
734 {
735  // selector
736  std::unique_ptr<CSS1Selector> pSelector = ParseSelector();
737  if( !pSelector )
738  return;
739 
740  // process selector
741  SelectorParsed( std::move(pSelector), true );
742 
743  LOOP_CHECK_DECL
744 
745  // [ ',' selector ]*
746  while( CSS1_COMMA==m_nToken && IsParserWorking() )
747  {
748  LOOP_CHECK_CHECK( "Infinite loop in ParseRule()/selector *" )
749 
750  // ignore ','
751  m_nToken = GetNextToken();
752 
753  // selector
754  pSelector = ParseSelector();
755  if( !pSelector )
756  return;
757 
758  // process selector
759  SelectorParsed( std::move(pSelector), false );
760  }
761 
762  // '{'
763  if( CSS1_OBRACE != m_nToken )
764  return;
765  m_nToken = GetNextToken();
766 
767  // declaration
768  OUString aProperty;
769  std::unique_ptr<CSS1Expression> pExpr = ParseDeclaration( aProperty );
770  if( !pExpr )
771  return;
772 
773  // process expression
774  DeclarationParsed( aProperty, std::move(pExpr) );
775 
776  LOOP_CHECK_RESTART
777 
778  // [ ';' declaration ]*
779  while( CSS1_SEMICOLON==m_nToken && IsParserWorking() )
780  {
781  LOOP_CHECK_CHECK( "Infinite loop in ParseRule()/declaration *" )
782 
783  // ';'
784  m_nToken = GetNextToken();
785 
786  // declaration
787  if( CSS1_IDENT == m_nToken )
788  {
789  std::unique_ptr<CSS1Expression> pExp = ParseDeclaration( aProperty );
790  if( pExp )
791  {
792  // process expression
793  DeclarationParsed( aProperty, std::move(pExp));
794  }
795  }
796  }
797 
798  // '}'
799  if( CSS1_CBRACE == m_nToken )
800  m_nToken = GetNextToken();
801 }
802 
803 // selector
804 // : simple_selector+ [ ':' pseudo_element ]?
805 
806 // simple_selector
807 // : element_name [ DOT_WO_WS class ]?
808 // | DOT_W_WS class
809 // | id_selector
810 
811 // element_name
812 // : IDENT
813 
814 // class
815 // : IDENT
816 
817 // id_selector
818 // : '#' IDENT
819 
820 // pseude_element
821 // : IDENT
822 
823 std::unique_ptr<CSS1Selector> CSS1Parser::ParseSelector()
824 {
825  std::unique_ptr<CSS1Selector> pRoot;
826  CSS1Selector *pLast = nullptr;
827 
828  bool bDone = false;
829  CSS1Selector *pNew = nullptr;
830 
831  LOOP_CHECK_DECL
832 
833  // simple_selector+
834  while( !bDone && IsParserWorking() )
835  {
836  LOOP_CHECK_CHECK( "Infinite loop in ParseSelector()" )
837 
838  bool bNextToken = true;
839 
840  switch( m_nToken )
841  {
842  case CSS1_IDENT:
843  {
844  // element_name [ DOT_WO_WS class ]?
845 
846  // element_name
847  OUString aElement = m_aToken;
848  CSS1SelectorType eType = CSS1_SELTYPE_ELEMENT;
849  m_nToken = GetNextToken();
850 
851  if( CSS1_DOT_WO_WS == m_nToken )
852  {
853  // DOT_WO_WS
854  m_nToken = GetNextToken();
855 
856  // class
857  if( CSS1_IDENT == m_nToken )
858  {
859  aElement += "." + m_aToken;
860  eType = CSS1_SELTYPE_ELEM_CLASS;
861  }
862  else
863  {
864  // missing class
865  return pRoot;
866  }
867  }
868  else
869  {
870  // that was a look-ahead
871  bNextToken = false;
872  }
873  pNew = new CSS1Selector( eType, aElement );
874  }
875  break;
876  case CSS1_DOT_W_WS:
877  // DOT_W_WS class
878 
879  // DOT_W_WS
880  m_nToken = GetNextToken();
881 
882  if( CSS1_IDENT==m_nToken )
883  {
884  // class
885  pNew = new CSS1Selector( CSS1_SELTYPE_CLASS, m_aToken );
886  }
887  else
888  {
889  // missing class
890  return pRoot;
891  }
892  break;
893  case CSS1_HASH:
894  // '#' id_selector
895 
896  // '#'
897  m_nToken = GetNextToken();
898 
899  if( CSS1_IDENT==m_nToken )
900  {
901  // id_selector
902  pNew = new CSS1Selector( CSS1_SELTYPE_ID, m_aToken );
903  }
904  else
905  {
906  // missing id_selector
907  return pRoot;
908  }
909  break;
910 
911  case CSS1_PAGE_SYM:
912  {
913  // @page
914  pNew = new CSS1Selector( CSS1_SELTYPE_PAGE, m_aToken );
915  }
916  break;
917 
918  default:
919  // stop because we don't know what's next
920  bDone = true;
921  break;
922  }
923 
924  // if created a new selector then save it
925  if( pNew )
926  {
927  OSL_ENSURE( (pRoot!=nullptr) == (pLast!=nullptr),
928  "Root-Selector, but no Last" );
929  if( pLast )
930  pLast->SetNext( pNew );
931  else
932  pRoot.reset(pNew);
933 
934  pLast = pNew;
935  pNew = nullptr;
936  }
937 
938  if( bNextToken && !bDone )
939  m_nToken = GetNextToken();
940  }
941 
942  if( !pRoot )
943  {
944  // missing simple_selector
945  return pRoot;
946  }
947 
948  // [ ':' pseudo_element ]?
949  if( CSS1_COLON==m_nToken && IsParserWorking() )
950  {
951  // ':' pseudo element
952  m_nToken = GetNextToken();
953  if( CSS1_IDENT==m_nToken )
954  {
955  pLast->SetNext( new CSS1Selector(CSS1_SELTYPE_PSEUDO,m_aToken) );
956  m_nToken = GetNextToken();
957  }
958  else
959  {
960  // missing pseudo_element
961  return pRoot;
962  }
963  }
964 
965  return pRoot;
966 }
967 
968 // declaration
969 // : property ':' expr prio?
970 // | /* empty */
971 
972 // expression
973 // : term [ operator term ]*
974 
975 // term
976 // : unary_operator?
977 // [ NUMBER | STRING | PERCENTAGE | LENGTH | EMS | EXS | IDENT |
978 // HEXCOLOR | URL | RGB ]
979 
980 // operator
981 // : '/' | ',' | /* empty */
982 
983 // unary_operator
984 // : '-' | '+'
985 
986 // property
987 // : ident
988 
989 // the sign is only used for numeric values (except PERCENTAGE)
990 // and it's applied on nValue!
991 std::unique_ptr<CSS1Expression> CSS1Parser::ParseDeclaration( OUString& rProperty )
992 {
993  std::unique_ptr<CSS1Expression> pRoot;
994  CSS1Expression *pLast = nullptr;
995 
996  // property
997  if( CSS1_IDENT != m_nToken )
998  {
999  // missing property
1000  return pRoot;
1001  }
1002  rProperty = m_aToken;
1003 
1004  m_nToken = GetNextToken();
1005 
1006  // ':'
1007  if( CSS1_COLON != m_nToken )
1008  {
1009  // missing ':'
1010  return pRoot;
1011  }
1012  m_nToken = GetNextToken();
1013 
1014  // term [operator term]*
1015  // here we're pretty lax regarding the syntax, but this shouldn't
1016  // be a problem
1017  bool bDone = false;
1018  sal_Unicode cSign = 0, cOp = 0;
1019  CSS1Expression *pNew = nullptr;
1020 
1021  LOOP_CHECK_DECL
1022 
1023  while( !bDone && IsParserWorking() )
1024  {
1025  LOOP_CHECK_CHECK( "Infinite loop in ParseDeclaration()" )
1026 
1027  switch( m_nToken )
1028  {
1029  case CSS1_MINUS:
1030  cSign = '-';
1031  break;
1032 
1033  case CSS1_PLUS:
1034  cSign = '+';
1035  break;
1036 
1037  case CSS1_NUMBER:
1038  case CSS1_LENGTH:
1039  case CSS1_PIXLENGTH:
1040  case CSS1_EMS:
1041  case CSS1_EMX:
1042  if( '-'==cSign )
1043  m_nValue = -m_nValue;
1044  [[fallthrough]];
1045  case CSS1_STRING:
1046  case CSS1_PERCENTAGE:
1047  case CSS1_IDENT:
1048  case CSS1_URL:
1049  case CSS1_RGB:
1050  case CSS1_HEXCOLOR:
1051  pNew = new CSS1Expression( m_nToken, m_aToken, m_nValue, cOp );
1052  m_nValue = 0; // otherwise this also is applied to next ident
1053  cSign = 0;
1054  cOp = 0;
1055  break;
1056 
1057  case CSS1_SLASH:
1058  cOp = '/';
1059  cSign = 0;
1060  break;
1061 
1062  case CSS1_COMMA:
1063  cOp = ',';
1064  cSign = 0;
1065  break;
1066 
1067  default:
1068  bDone = true;
1069  break;
1070  }
1071 
1072  // if created a new expression save it
1073  if( pNew )
1074  {
1075  OSL_ENSURE( (pRoot!=nullptr) == (pLast!=nullptr),
1076  "Root-Selector, but no Last" );
1077  if( pLast )
1078  pLast->SetNext( pNew );
1079  else
1080  pRoot.reset(pNew);
1081 
1082  pLast = pNew;
1083  pNew = nullptr;
1084  }
1085 
1086  if( !bDone )
1087  m_nToken = GetNextToken();
1088  }
1089 
1090  if( !pRoot )
1091  {
1092  // missing term
1093  return pRoot;
1094  }
1095 
1096  // prio?
1097  if( CSS1_IMPORTANT_SYM==m_nToken )
1098  {
1099  // IMPORTANT_SYM
1100  m_nToken = GetNextToken();
1101  }
1102 
1103  return pRoot;
1104 }
1105 
1106 CSS1Parser::CSS1Parser()
1107  : m_bWhiteSpace(false)
1108  , m_bEOF(false)
1109  , m_cNextCh(0)
1110  , m_nInPos(0)
1111  , m_nlLineNr(0)
1112  , m_nlLinePos(0)
1113  , m_nValue(0)
1114  , m_eState(CSS1_PAR_ACCEPTED)
1115  , m_nToken(CSS1_NULL)
1116 {
1117 }
1118 
1119 CSS1Parser::~CSS1Parser()
1120 {
1121 }
1122 
1123 void CSS1Parser::ParseStyleSheet( const OUString& rIn )
1124 {
1125  OUString aTmp( rIn );
1126 
1127  sal_Unicode c;
1128  while( !aTmp.isEmpty() &&
1129  ( ' '==(c=aTmp[0]) || '\t'==c || '\r'==c || '\n'==c ) )
1130  aTmp = aTmp.copy( 1 );
1131 
1132  while( !aTmp.isEmpty() && ( ' '==(c=aTmp[aTmp.getLength()-1])
1133  || '\t'==c || '\r'==c || '\n'==c ) )
1134  aTmp = aTmp.copy( 0, aTmp.getLength()-1 );
1135 
1136  // remove SGML comments
1137  if( aTmp.getLength() >= 4 &&
1138  aTmp.startsWith( "<!--" ) )
1139  aTmp = aTmp.copy( 4 );
1140 
1141  if( aTmp.getLength() >=3 &&
1142  aTmp.endsWith("-->") )
1143  aTmp = aTmp.copy( 0, aTmp.getLength() - 3 );
1144 
1145  if( aTmp.isEmpty() )
1146  return;
1147 
1148  InitRead( aTmp );
1149 
1150  ParseStyleSheet();
1151 }
1152 
1153 void CSS1Parser::ParseStyleOption( const OUString& rIn )
1154 {
1155  if( rIn.isEmpty() )
1156  return;
1157 
1158  InitRead( rIn );
1159 
1160  // fdo#41796: skip over spurious semicolons
1161  while (CSS1_SEMICOLON == m_nToken)
1162  {
1163  m_nToken = GetNextToken();
1164  }
1165 
1166  OUString aProperty;
1167  std::unique_ptr<CSS1Expression> pExpr = ParseDeclaration( aProperty );
1168  if( !pExpr )
1169  return;
1170 
1171  // process expression
1172  DeclarationParsed( aProperty, std::move(pExpr) );
1173 
1174  LOOP_CHECK_DECL
1175 
1176  // [ ';' declaration ]*
1177  while( CSS1_SEMICOLON==m_nToken && IsParserWorking() )
1178  {
1179  LOOP_CHECK_CHECK( "Infinite loop in ParseStyleOption()" )
1180 
1181  m_nToken = GetNextToken();
1182  if( CSS1_IDENT==m_nToken )
1183  {
1184  std::unique_ptr<CSS1Expression> pExp = ParseDeclaration( aProperty );
1185  if( pExp )
1186  {
1187  // process expression
1188  DeclarationParsed( aProperty, std::move(pExp) );
1189  }
1190  }
1191  }
1192 }
1193 
1194 void CSS1Parser::SelectorParsed( std::unique_ptr<CSS1Selector> /* pSelector */, bool /*bFirst*/ )
1195 {
1196 }
1197 
1198 void CSS1Parser::DeclarationParsed( const OUString& /*rProperty*/,
1199  std::unique_ptr<CSS1Expression> /* pExpr */ )
1200 {
1201 }
1202 
1203 CSS1Selector::~CSS1Selector()
1204 {
1205  delete pNext;
1206 }
1207 
1208 CSS1Expression::~CSS1Expression()
1209 {
1210  delete pNext;
1211 }
1212 
1213 void CSS1Expression::GetURL( OUString& rURL ) const
1214 {
1215  OSL_ENSURE( CSS1_URL==eType, "CSS1-Expression is not URL" );
1216 
1217  OSL_ENSURE( aValue.startsWithIgnoreAsciiCase( "url" ) &&
1218  aValue.getLength() > 5 &&
1219  '(' == aValue[3] &&
1220  ')' == aValue[aValue.getLength()-1],
1221  "no valid URL(...)" );
1222 
1223  if( aValue.getLength() > 5 )
1224  {
1225  rURL = aValue.copy( 4, aValue.getLength() - 5 );
1226 
1227  // tdf#94088 original stripped only spaces, but there may also be
1228  // double quotes in CSS style URLs, so be prepared to spaces followed
1229  // by a single quote followed by spaces
1230  const sal_Unicode aSpace(' ');
1231  const sal_Unicode aSingleQuote('\'');
1232 
1233  rURL = comphelper::string::strip(rURL, aSpace);
1234  rURL = comphelper::string::strip(rURL, aSingleQuote);
1235  rURL = comphelper::string::strip(rURL, aSpace);
1236  }
1237 }
1238 
1239 bool CSS1Expression::GetColor( Color &rColor ) const
1240 {
1241  OSL_ENSURE( CSS1_IDENT==eType || CSS1_RGB==eType ||
1242  CSS1_HEXCOLOR==eType || CSS1_STRING==eType,
1243  "CSS1-Expression cannot be colour" );
1244 
1245  bool bRet = false;
1246  sal_uInt32 nColor = SAL_MAX_UINT32;
1247 
1248  switch( eType )
1249  {
1250  case CSS1_RGB:
1251  {
1252  sal_uInt8 aColors[3] = { 0, 0, 0 };
1253 
1254  if (!aValue.startsWithIgnoreAsciiCase( "rgb" ) || aValue.getLength() < 6 ||
1255  aValue[3] != '(' || aValue[aValue.getLength()-1] != ')')
1256  {
1257  break;
1258  }
1259 
1260  sal_Int32 nPos = 4; // start after "rgb("
1261  for ( int nCol = 0; nCol < 3 && nPos > 0; ++nCol )
1262  {
1263  const OUString aNumber = aValue.getToken(0, ',', nPos);
1264 
1265  sal_Int32 nNumber = aNumber.toInt32();
1266  if( nNumber<0 )
1267  {
1268  nNumber = 0;
1269  }
1270  else if( aNumber.indexOf('%') >= 0 )
1271  {
1272  if( nNumber > 100 )
1273  nNumber = 100;
1274  nNumber *= 255;
1275  nNumber /= 100;
1276  }
1277  else if( nNumber > 255 )
1278  nNumber = 255;
1279 
1280  aColors[nCol] = static_cast<sal_uInt8>(nNumber);
1281  }
1282 
1283  rColor.SetRed( aColors[0] );
1284  rColor.SetGreen( aColors[1] );
1285  rColor.SetBlue( aColors[2] );
1286 
1287  bRet = true; // something different than a colour isn't possible
1288  }
1289  break;
1290 
1291  case CSS1_IDENT:
1292  case CSS1_STRING:
1293  {
1294  OUString aTmp( aValue.toAsciiUpperCase() );
1295  nColor = GetHTMLColor( aTmp );
1296  bRet = nColor != SAL_MAX_UINT32;
1297  }
1298  if( bRet || CSS1_STRING != eType || aValue.isEmpty() ||
1299  aValue[0] != '#' )
1300  break;
1301  [[fallthrough]];
1302  case CSS1_HEXCOLOR:
1303  {
1304  // MS-IE hack: colour can also be a string
1305  sal_Int32 nOffset = CSS1_STRING==eType ? 1 : 0;
1306  bool bDouble = aValue.getLength()-nOffset == 3;
1307  sal_Int32 i = nOffset, nEnd = (bDouble ? 3 : 6) + nOffset;
1308 
1309  nColor = 0;
1310  for( ; i<nEnd; i++ )
1311  {
1312  sal_Unicode c = (i<aValue.getLength() ? aValue[i]
1313  : '0' );
1314  if( c >= '0' && c <= '9' )
1315  c -= 48;
1316  else if( c >= 'A' && c <= 'F' )
1317  c -= 55;
1318  else if( c >= 'a' && c <= 'f' )
1319  c -= 87;
1320  else
1321  c = 16;
1322 
1323  nColor *= 16;
1324  if( c<16 )
1325  nColor += c;
1326  if( bDouble )
1327  {
1328  nColor *= 16;
1329  if( c<16 )
1330  nColor += c;
1331  }
1332  }
1333  bRet = true;
1334  }
1335  break;
1336  default:
1337  ;
1338  }
1339 
1340  if( bRet && nColor!=SAL_MAX_UINT32 )
1341  {
1342  rColor.SetRed( static_cast<sal_uInt8>((nColor & 0x00ff0000UL) >> 16) );
1343  rColor.SetGreen( static_cast<sal_uInt8>((nColor & 0x0000ff00UL) >> 8) );
1344  rColor.SetBlue( static_cast<sal_uInt8>(nColor & 0x000000ffUL) );
1345  }
1346 
1347  return bRet;
1348 }
1349 
1350 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
CSS1Parser::m_cNextCh
sal_Unicode m_cNextCh
Definition: parcss1.hxx:179
CSS1Parser::GetNextToken
CSS1Token GetNextToken()
Definition: parcss1.cxx:105
Color::SetBlue
void SetBlue(sal_uInt8 nBlue)
CSS1Parser::m_aToken
OUString m_aToken
Definition: parcss1.hxx:192
sal_uLong
sal_uIntPtr sal_uLong
CSS1Parser::m_eState
CSS1ParserState m_eState
Definition: parcss1.hxx:188
CSS1Token
CSS1Token
Definition: parcss1.hxx:24
MAX_LEN
const sal_Int32 MAX_LEN
Definition: parcss1.cxx:57
CSS1Parser::m_bWhiteSpace
bool m_bWhiteSpace
Definition: parcss1.hxx:176
CSS1Parser::IsParserWorking
bool IsParserWorking() const
Is the parser still working?
Definition: parcss1.hxx:204
GetHTMLColor
sal_uInt32 GetHTMLColor(const OUString &rName)
LOOP_CHECK_RESTART
#define LOOP_CHECK_RESTART
Definition: parcss1.cxx:40
CSS1Parser::GetNextChar
sal_Unicode GetNextChar()
Definition: parcss1.cxx:75
CSS1Expression
a subexpression of a CSS1 declaration
Definition: parcss1.hxx:113
SAL_MAX_UINT32
#define SAL_MAX_UINT32
sal_Unicode
sal_uInt16 sal_Unicode
sal_Char
char sal_Char
CSS1SelectorType
CSS1SelectorType
Definition: parcss1.hxx:65
comphelper::string::strip
OString strip(const OString &rIn, sal_Char c)
CSS1Parser::ParseStyleSheet
void ParseStyleSheet()
Definition: parcss1.cxx:672
CSS1Parser::m_nInPos
sal_Int32 m_nInPos
Definition: parcss1.hxx:181
CSS1Expression::eType
CSS1Token eType
Definition: parcss1.hxx:116
CSS1Parser::m_nValue
double m_nValue
Definition: parcss1.hxx:186
CSS1Parser::ParseSelector
std::unique_ptr< CSS1Selector > ParseSelector()
Definition: parcss1.cxx:823
i
int i
Color::SetRed
void SetRed(sal_uInt8 nRed)
CSS1Expression::SetNext
void SetNext(CSS1Expression *pNxt)
Definition: parcss1.hxx:141
LOOP_CHECK_CHECK
#define LOOP_CHECK_CHECK(where)
Definition: parcss1.cxx:42
CSS1Selector::pNext
CSS1Selector * pNext
Definition: parcss1.hxx:90
eType
DocumentType const eType
CSS1Parser::ParseStyleOption
void ParseStyleOption(const OUString &rIn)
parse the content of a HTML style option
Definition: parcss1.cxx:1153
CSS1Parser::m_nToken
CSS1Token m_nToken
Definition: parcss1.hxx:189
CSS1Parser::IsEOF
bool IsEOF() const
Definition: parcss1.hxx:206
CSS1Parser::ParseDeclaration
std::unique_ptr< CSS1Expression > ParseDeclaration(OUString &rProperty)
Definition: parcss1.cxx:991
CSS1Expression::aValue
OUString aValue
Definition: parcss1.hxx:117
sal_uInt8
unsigned char sal_uInt8
CSS1Parser::SelectorParsed
virtual void SelectorParsed(std::unique_ptr< CSS1Selector > pSelector, bool bFirst)
Called after a selector was parsed.
Definition: parcss1.cxx:1194
LOOP_CHECK_DECL
#define LOOP_CHECK_DECL
Definition: parcss1.cxx:38
CSS1Expression::GetColor
bool GetColor(Color &rRGB) const
Definition: parcss1.cxx:1239
CSS1Parser::m_nlLineNr
sal_uInt32 m_nlLineNr
Definition: parcss1.hxx:183
Color::SetGreen
void SetGreen(sal_uInt8 nGreen)
CSS1Parser::ParseRule
void ParseRule()
Definition: parcss1.cxx:733
CSS1Parser::InitRead
void InitRead(const OUString &rIn)
prepare parsing
Definition: parcss1.cxx:59
CSS1Parser::m_aIn
OUString m_aIn
Definition: parcss1.hxx:191
CSS1Expression::GetURL
void GetURL(OUString &rURL) const
Definition: parcss1.cxx:1213
CSS1Parser::DeclarationParsed
virtual void DeclarationParsed(const OUString &rProperty, std::unique_ptr< CSS1Expression > pExpr)
Called after a declaration or property was parsed.
Definition: parcss1.cxx:1198
CSS1Parser::~CSS1Parser
virtual ~CSS1Parser()
Definition: parcss1.cxx:1119
CSS1Selector
A simple selector.
Definition: parcss1.hxx:86
CSS1Expression::pNext
CSS1Expression * pNext
Definition: parcss1.hxx:119
CSS1Parser::m_bEOF
bool m_bEOF
Definition: parcss1.hxx:177
nPos
sal_Int32 nPos
CSS1Selector::SetNext
void SetNext(CSS1Selector *pNxt)
Definition: parcss1.hxx:102
CSS1Parser::m_nlLinePos
sal_uInt32 m_nlLinePos
Definition: parcss1.hxx:184
Generated on Sat May 18 2019 02:57:08 for LibreOffice Module sw (master) by   doxygen 1.8.10