1 /* -*-java-extended-*-

     2  *

     3  * (c) COPYRIGHT MIT and INRIA, 1997.

     4  * Please first read the full copyright statement in file COPYRIGHT.html

     5  *

     6  * $Id: CssParser.jj,v 1.69 2009-10-11 09:19:37 ylafon Exp $

     7  *

     8  */

     9 

    10 options {

    11     IGNORE_CASE  = true;

    12     STATIC = false;

    13     UNICODE_INPUT = true;

    14     /*

    15           DEBUG_TOKEN_MANAGER = true; 

    16 	  DEBUG_PARSER = true;      

    17     */

    18 }

    19 

    20 PARSER_BEGIN(CssParser)

    21 

    22 package org.w3c.css.parser.analyzer;

    23 

    24 import java.io.InputStream;

    25 import java.io.InputStreamReader;

    26 import java.io.UnsupportedEncodingException;

    27 import java.util.Vector;

    28 import java.util.Enumeration;

    29 import java.net.URL;

    30 

    31 import org.w3c.css.values.CssValue;

    32 import org.w3c.css.values.CssExpression;

    33 import org.w3c.css.values.CssString;

    34 import org.w3c.css.values.CssURL;

    35 import org.w3c.css.values.CssLength;

    36 import org.w3c.css.values.CssNumber;

    37 import org.w3c.css.values.CssColor;

    38 import org.w3c.css.values.CssIdent;

    39 import org.w3c.css.values.CssPercentage;

    40 import org.w3c.css.values.CssFrequency;

    41 import org.w3c.css.values.CssTime;

    42 import org.w3c.css.values.CssDate;

    43 import org.w3c.css.values.CssAngle;

    44 import org.w3c.css.values.CssFunction;

    45 import org.w3c.css.values.CssUnicodeRange;

    46 import org.w3c.css.values.CssResolution;

    47 import org.w3c.css.properties.css1.CssProperty;

    48 import org.w3c.css.parser.Frame;

    49 import org.w3c.css.util.ApplContext;

    50 import org.w3c.css.parser.CssError;

    51 import org.w3c.css.parser.CssSelectors;

    52 import org.w3c.css.parser.CssParseException;

    53 import org.w3c.css.parser.AtRule;

    54 import org.w3c.css.parser.AtRuleMedia;

    55 import org.w3c.css.parser.AtRuleFontFace;

    56 import org.w3c.css.parser.AtRulePage;

    57 import org.w3c.css.parser.AtRulePreference;

    58 import org.w3c.css.parser.AtRulePhoneticAlphabet;

    59 import org.w3c.css.properties.svg.AtRuleColorProfile;

    60 import org.w3c.css.util.InvalidParamException;

    61 import org.w3c.css.util.Util;

    62 import org.w3c.css.util.Messages;

    63 import org.w3c.css.css.StyleSheetCom;

    64 

    65 import org.w3c.css.selectors.AdjacentSiblingSelector;

    66 import org.w3c.css.selectors.AttributeSelector;

    67 import org.w3c.css.selectors.ChildSelector;

    68 import org.w3c.css.selectors.ClassSelector;

    69 import org.w3c.css.selectors.DescendantSelector;

    70 import org.w3c.css.selectors.GeneralSiblingSelector;

    71 import org.w3c.css.selectors.IdSelector;

    72 import org.w3c.css.selectors.TypeSelector;

    73 import org.w3c.css.selectors.UniversalSelector;

    74 import org.w3c.css.selectors.attributes.AttributeAny;

    75 import org.w3c.css.selectors.attributes.AttributeBegin;

    76 import org.w3c.css.selectors.attributes.AttributeExact;

    77 import org.w3c.css.selectors.attributes.AttributeOneOf;

    78 import org.w3c.css.selectors.attributes.AttributeStart;

    79 import org.w3c.css.selectors.attributes.AttributeSubstr;

    80 import org.w3c.css.selectors.attributes.AttributeSuffix;

    81 

    82 /**

    83  * A CSS3 parser  

    84  *

    85  * @author Philippe Le Hegaret and Sijtsche Smeman

    86  * @version $Revision: 1.69 $

    87  */

    88 public abstract class CssParser {

    89 

    90     private static char hexdigits[] = { '0', '1', '2', '3',

    91 					'4', '5', '6', '7', 

    92 					'8', '9', 'a', 'b', 

    93 					'c', 'd', 'e', 'f' };

    94     // the current atRule

    95     protected AtRule atRule;

    96     protected String mediaDeclaration = "off";

    97 

    98     /**

    99      * The URL of the document

   100      */  

   101     protected URL url;

   102     

   103     protected ApplContext ac;

   104 

   105     protected boolean incompatible_error;

   106     

   107     /**

   108      * The current context recognized by the parser (for errors).

   109      */  

   110     protected Vector currentContext;

   111     

   112     /**

   113      * The current property recognized by the parser (for errors).

   114      */  

   115     protected String currentProperty;

   116     

   117     /**

   118      * <code>true</code> if the parser should recognized Aural properties, 

   119      * <code>false</code> otherwise.

   120      */  

   121     protected boolean mode;

   122 

   123     /**

   124      * <code>true</code> if the parser had recognize a rule,

   125      * <code>false</code> otherwise.

   126      */  

   127     protected boolean markRule;

   128 

   129     private boolean reinited = false;

   130     private boolean charsetdeclared = false;

   131 

   132     static StringBuilder SPACE = new StringBuilder(" ");

   133 

   134     // to be able to remove a ruleset if the selector is not valid

   135     protected boolean validSelector = true;

   136 

   137     /**

   138      * The ac for handling errors and warnings.

   139      * 

   140      * @param ac the new ac for the parser.

   141      */  

   142     public final void setApplContext(ApplContext ac) {

   143 	this.ac = ac;

   144     }

   145 

   146     /**

   147      * Set the attribute atRule

   148      *

   149      * @param atRule the new value for the attribute

   150      */

   151     public void setAtRule(AtRule atRule) {

   152         this.atRule = atRule;

   153     }

   154 

   155     /**

   156      * Set the attribute mediaDeclaration

   157      *

   158      * @param mediaDeclaration indicator if in a media expression list or not

   159      */

   160     public void setMediaDeclaration(String mediadeclaration) {

   161         this.mediaDeclaration = mediadeclaration;

   162     }

   163 

   164     /**

   165      * Returns the attribute mediaDeclaration

   166      *

   167      * @return the value of the attribute

   168      */

   169     public String getMediaDeclaration() {

   170     	return mediaDeclaration;

   171     }

   172 

   173     /**

   174      * Returns the attribute atRule

   175      *

   176      * @return the value of the attribute

   177      */

   178     public AtRule getAtRule() {

   179         return atRule;

   180     }

   181 

   182     /**

   183      * Reinitialized the parser.

   184      *

   185      * @param stream the stream data to parse.

   186      * @param ac  the new ac to use for parsing.

   187      */

   188     public void ReInitWithAc(InputStream stream, ApplContext ac, 

   189 			     String charset)

   190     {

   191 	InputStream is = /*new  CommentSkipperInputStream(stream);*/stream;

   192 	if (charset == null) {

   193 	    charset = "iso-8859-1";

   194 	}

   195 	InputStreamReader isr = null;

   196 	try {

   197 	    isr = new InputStreamReader(is, charset);

   198 	} catch (UnsupportedEncodingException uex) {

   199 	    isr = new InputStreamReader(is);

   200 	}

   201 	// reinit, it can not happen...

   202 	// ...in theory ;)

   203     	ReInit(isr);

   204 	markRule = false;

   205 	reinited = true;

   206 	setApplContext(ac);

   207     }

   208   

   209     /* utilities for a parser */

   210  

   211     /**

   212      * Call by the import statement.

   213      *

   214      * @param url  The style sheet where this import statement appears.

   215      * @param file the file name in the import

   216      */  

   217     public abstract void handleImport(URL url, String file, 

   218 				      boolean is_url, AtRuleMedia media);

   219 

   220     /**

   221      * Call by the namespace declaration statement.

   222      *

   223      * @param url  The style sheet where this namespace statement appears.

   224      * @param file the file/url name in the namespace declaration

   225      */  

   226     public abstract void handleNamespaceDeclaration(URL url, String prefix,

   227 						    String file, 

   228 						    boolean is_url);

   229 

   230     /**

   231      * Call by the at-rule statement.

   232      *

   233      * @param ident  The ident for this at-rule (for example: 'font-face')

   234      * @param string The string associate to this at-rule

   235      * @see          org.w3c.css.parser.Analyzer.Couple

   236      */  

   237     public abstract void handleAtRule(String ident, String string);

   238 

   239     /* added by Sijtsche Smeman */

   240     public abstract void addCharSet(String charset);

   241     public abstract void newAtRule(AtRule atRule);

   242     public abstract void endOfAtRule();

   243     public abstract void setImportant(boolean important);

   244     public abstract void setSelectorList(Vector selectors);

   245     public abstract void addProperty(Vector properties);

   246     public abstract void endOfRule();	

   247     public abstract void removeThisRule();

   248     public abstract void removeThisAtRule();

   249     

   250     /**

   251      * Assign an expression to a property.  This function create a new property

   252      * with <code>property</code> and assign to it the expression with the

   253      * importance. Don't forget to set informations too.

   254      * <p>

   255      * A subclass must provide an implementation of this method. 

   256      *

   257      * @param  property  the name of the property

   258      * @param  values    the expression representation of values

   259      * @param  important <code>true</code> if values are important

   260      *

   261      * @return           <code>null</code>or a property

   262      * 

   263      * @see              org.w3c.css.css.CssProperty

   264      */

   265     public abstract CssProperty handleDeclaration(String property, 

   266 						  CssExpression values, 

   267 						  boolean important) 

   268 	throws InvalidParamException;

   269 

   270     /**

   271      * Adds a vector of properties to a selector.

   272      * <p>

   273      * A subclass must provide an implementation of this method. 

   274      *

   275      * @param selector     the selector

   276      * @param declarations Properties to associate with contexts

   277      */  

   278     public abstract void handleRule(CssSelectors selector, 

   279 				    Vector declarations);

   280 

   281     /*Added by Sijtsche Smeman */

   282 

   283     /**

   284      * Returns the source file of the style sheet

   285      */

   286     public final String getSourceFile() {

   287 	return getURL().toString();

   288     }

   289 

   290     /**

   291      * Returns the current line in the style sheet

   292      */

   293     public final int getLine() {

   294 	//return token.beginLine;

   295 	return 0;

   296     }

   297 

   298     /**

   299      * Set the URL of the style sheet.

   300      *

   301      * @param URL The URL for the style sheet

   302      */

   303     public final void setURL(URL url) {

   304 	this.url = url;

   305     }

   306 

   307     public final URL getURL() {

   308 	return url;

   309     }

   310 

   311     /**

   312      * Return the next selector from the inputstream

   313      */    

   314     public CssSelectors parseSelector() throws ParseException {

   315 	return externalSelector();

   316     }

   317     

   318     /*

   319      * Add a value to an expression

   320      */

   321     private void setValue(CssValue v, CssExpression expr, 

   322 			  char operator, Token n, int token) 

   323 	throws ParseException {

   324 	if (n != null) {

   325 	    if (ac.getCssVersion().equals("css1") && 

   326 		(n.image).equals("inherit")) {

   327 		incompatible_error = true;

   328 	    }	

   329 	    String val = (operator == ' ') ? n.image : operator+n.image;

   330 

   331 	    if (n.kind == CssParserConstants.IDENT) {

   332 		v.set(convertIdent(val), ac);

   333 	    } else if (n.kind == CssParserConstants.STRING) {

   334 		v.set(val, ac); 

   335 	    } else {

   336 		v.set(val, ac); 

   337 	    }

   338 	}

   339 	expr.addValue(v);

   340     }

   341 

   342     /*

   343      * Error control

   344      */

   345     private void addError(Exception e, String skippedText) {

   346 	if (Util.onDebug) {

   347 	    System.err.println(e.getMessage());

   348 	    e.printStackTrace();

   349 	}

   350 	CssParseException ex = new CssParseException(e);

   351 	ex.setSkippedString(skippedText);

   352 	ex.setProperty(currentProperty);

   353 	ex.setContexts(currentContext);

   354 	CssError error = new CssError(getSourceFile(), getLine(), ex);

   355 	ac.getFrame().addError(error);

   356     }

   357     

   358     /*

   359      * Error control 2

   360      */

   361     private void addError(Exception e, CssExpression exp) {

   362 	if (Util.onDebug) {

   363 	    System.err.println(e.getMessage());

   364 	    e.printStackTrace();

   365 	}

   366 	

   367 	//	if ((exp != null) && (exp.getCount() != 0)) {

   368 	CssParseException ex = new CssParseException(e);

   369 	ex.setExp(exp);

   370 	ex.setProperty(currentProperty);

   371 	ex.setContexts(currentContext);

   372 	CssError error = new CssError(getSourceFile(), getLine(), ex);

   373 	ac.getFrame().addError(error);

   374 	//	}

   375     }

   376 }

   377 

   378 PARSER_END(CssParser)

   379 

   380 /*

   381  * The tokenizer 

   382  */

   383 

   384 <DEFAULT>

   385 SPECIAL_TOKEN :

   386 {

   387     < COMMENT : "/*" ( ~["*"] )* ( "*" )+ ( ~["/", "*"] ( ~["*"] )* ( "*" )+ )* "/" >

   388 } 

   389 

   390 <DEFAULT>

   391     TOKEN [IGNORE_CASE] : /* basic tokens */

   392 { 

   393     < #H          : ["0"-"9", "a"-"f"] > 

   394   | < #NONASCII   : ["\200"-"\377"] >

   395   | < #UNICODE    : "\\" <H> ( <H> )? ( <H> )? ( <H> )? ( <H> )? ( <H> )? 

   396 	            ( "\r\n" | [ " ", "\t" , "\n" , "\r", "\f" ] )? >

   397   | < #ESCAPE     : <UNICODE> | ( "\\" ~[ "\r", "\n", "\f", "0"-"9", "a"-"f" ] ) >

   398   | < #NMSTART    : [ "a"-"z", "_" ] | <NONASCII> | <ESCAPE> >

   399   | < #NMCHAR     : ["a"-"z", "0"-"9", "-", "_"] | <NONASCII> | <ESCAPE> >

   400   | < #STRING1    : "\"" ( ~[ "\n", "\r", "\f", "\\", "\"" ] | "\\" <NL> | <ESCAPE> )* "\"" >

   401   | < #STRING2	  : "\'" ( ~[ "\n", "\r", "\f", "\\", "\'" ] | "\\" <NL> | <ESCAPE> )* "\'" >

   402   | < #INVALID1   : "\"" ( ~[ "\n", "\r", "\f", "\\", "\"" ] | "\\" <NL> | <ESCAPE> )* >

   403   | < #INVALID2	  : "\'" ( ~[ "\n", "\r", "\f", "\\", "\'" ] | "\\" <NL> | <ESCAPE> )* >  

   404   | < #_IDENT     : ( <MINUS> )? <NMSTART> ( <NMCHAR> )* >

   405   | < #NAME       : ( <NMCHAR> )+ >

   406   | < #NUM        : ( ["0"-"9"] )+ | ( ["0"-"9"] )* "." ( ["0"-"9"] )+ >

   407   | < #_STRING    : <STRING1> | <STRING2> >

   408   | < #_INVALID   : <INVALID1> | <INVALID2> >

   409   | < #_URL       : ( [ "!", "#", "$", "%", "&", "*"-"[", "]"-"~" ] | <NONASCII> | <ESCAPE> )* >

   410   | < #_S         : ( [ " ", "\t" , "\n" , "\r", "\f" ] ) ( <COMMENT> | [ " ", "\t" , "\n" , "\r", "\f" ] )*  >

   411   | < #_W         : ( <_S> )? >

   412   | < #NL         : ( "\n" | "\r\n" | "\r" | "\f" ) >

   413 }

   414 /*

   415  * The _S definition is not  ( [ " ", "\t" , "\n" , "\r", "\f" ] ) + as we need to add support

   416  * for the unput(' ') (see http://www.w3.org/TR/CSS21/grammar.html#scanner )

   417  */

   418 

   419 <DEFAULT>

   420 TOKEN :

   421 {

   422   < S : ( <_S> ) >

   423 }

   424 

   425 <DEFAULT>

   426     TOKEN :

   427 {

   428     < CDO : "<!--" >

   429   | < CDC : "-->" >

   430   | < INCLUDES  : <TILDE> "=" >

   431   | < DASHMATCH : "|=" >

   432 }

   433 

   434 <DEFAULT>

   435 TOKEN :

   436 {

   437   < LBRACE : <_W> "{" >

   438   | < PLUS      : <_W>  "+" >

   439   | < GREATER   : <_W> ">" >

   440   | < COMMA     : <_W> "," >

   441   | < TILDE     : <_W> "~" >

   442 }

   443 

   444 <DEFAULT>

   445 TOKEN [IGNORE_CASE] :

   446 {

   447     < AND : "and" > 

   448 }  

   449 

   450 <DEFAULT>

   451 TOKEN :

   452 {

   453     <STRING    : <_STRING> >

   454   | <INVALID   : <_INVALID> >

   455   | <IDENT     : <_IDENT> >

   456   | <HASHIDENT : "#" <_IDENT> >

   457   | <HASH      : "#" <NAME> >

   458 }

   459 

   460 <DEFAULT>

   461 TOKEN :

   462 {

   463   < RBRACE : "}">

   464   | < PREFIXMATCH : "^=" >

   465   | < SUFFIXMATCH : "$=" >

   466   | < SUBSTRINGMATCH : "*=" >

   467   | < EQ        : "=" >

   468   | < MINUS     : "-" >

   469   | < SEMICOLON : ";" >

   470   | < DIV       : "/" >

   471   | < LBRACKET  : "[" >

   472   | < RBRACKET  : "]" >

   473   | < ANY       : "*" >

   474   | < DOT       : "." >

   475   | < LPARAN    : ")" >

   476   | < RPARAN    : "(">

   477 }

   478 

   479 <DEFAULT>

   480     TOKEN :

   481 {

   482     < COLON     : ":" >

   483 }

   484 

   485 <DEFAULT>

   486 TOKEN [IGNORE_CASE] :

   487 {

   488     < MEDIARESTRICTOR : "only" | "not" >

   489 }

   490 

   491 <DEFAULT>

   492 TOKEN [IGNORE_CASE] :

   493 {

   494   < URL         : "url(" ( <S> )* ( <STRING> | <_URL>  ) ( <S> )* ")" >

   495 }

   496 

   497 <DEFAULT>

   498 TOKEN [IGNORE_CASE] :

   499 {

   500   < LENGTH     : <NUM> "pt" 

   501                    | <NUM> "mm" 

   502 	           | <NUM> "cm" 

   503 	           | <NUM> "pc" 

   504 	           | <NUM> "in"

   505 	           | <NUM> "gd" 

   506 	           | <NUM> "px" >

   507   | < EMS        : <NUM> "em" >

   508   | < EXS        : <NUM> "ex" >

   509   | < ANGLE      : <NUM> ( "deg" | "grad" | "rad" ) >

   510   | < TIME       : <NUM> ( "ms" | "s" ) >

   511   | < FREQ       : <NUM> "Hz" | <NUM> "kHz" >

   512   | < RESOLUTION : <NUM> "dpi" | <NUM> "dpcm" >

   513   | < DATE       : <NUM> "/" <NUM> "/" <NUM> >

   514   | < DIMEN      : <NUM> <NMSTART> ( <NMCHAR> )* >

   515   | < PERCENTAGE : <NUM> "%" >

   516   | < NUMBER     : <NUM> >

   517 }

   518 

   519 <DEFAULT>

   520 TOKEN [IGNORE_CASE] :

   521 {  

   522     < IMPORTANT_SYM : "!" ( <_W> )* "important" >

   523 }

   524 

   525 <DEFAULT>

   526 TOKEN :

   527 {

   528     <PSEUDOELEMENT_SYM : "::" >

   529 }

   530 

   531 /* RESERVED ATRULE WORDS */

   532 <DEFAULT>

   533 TOKEN : 

   534 {

   535    < CHARSET_SYM           : "@charset" >

   536 }

   537 

   538 <DEFAULT>

   539 TOKEN [IGNORE_CASE] :

   540 { 

   541     < IMPORT_SYM            : "@import">

   542   | < NAMESPACE_SYM         : "@namespace">

   543   | < MEDIA_SYM             : "@media" >

   544   | < PAGE_SYM              : "@page"  >

   545   | < FONT_FACE_SYM         : "@font-face" >

   546   | < PREF_SYM              : "@preference" >

   547   | < COLOR_PROFILE         : "@color-profile" >

   548   | < ATTOP	            : "@top" >

   549   | < ATRIGHT               : "@right" >

   550   | < ATBOTTOM              : "@bottom" >

   551   | < ATLEFT                : "@left" >

   552   | < ATCOUNTER             : "@counter" >

   553   | < PHONETIC_ALPHABET_SYM : "@phonetic-alphabet" >

   554   | < ATKEYWORD             : "@" <IDENT> >

   555 }

   556 

   557 <DEFAULT>

   558 TOKEN [IGNORE_CASE] :

   559 {

   560     < #RANGE0 : <H> <H> <H> <H> <H> <H> > 

   561   | < #RANGE1 : <H> <H> <H> <H> <H> ( "?" )? >

   562   | < #RANGE2 : <H> <H> <H> <H> ( "?" )? ( "?" )? >

   563   | < #RANGE3 : <H> <H> <H> ( "?" )? ( "?" )? ( "?" )? >

   564   | < #RANGE4 : <H> <H> ( "?" )? ( "?" )? ( "?" )? ( "?" )? >

   565   | < #RANGE5 : <H> ( "?" )? ( "?" )? ( "?" )? ( "?" )? ( "?" )? >

   566   | < #RANGE6 : "?" ( "?" )? ( "?" )? ( "?" )? ( "?" )? ( "?" )? >

   567   | < #RANGE  : <RANGE0> | <RANGE1> | <RANGE2> 

   568                 | <RANGE3> | <RANGE4> | <RANGE5> | <RANGE6> >

   569   | < #UNI    : <H> ( <H> )? ( <H> )? ( <H> )? ( <H> )? ( <H> )? >

   570   | < UNICODERANGE : "U+" <RANGE> | "U+" <UNI> "-" <UNI> >

   571 }

   572 

   573 <DEFAULT>

   574     TOKEN:

   575 {

   576     < CLASS : "." <IDENT> >

   577 }

   578 

   579 /* FIXED, added a spacial case for lang pseudoclass */

   580 <DEFAULT>

   581 TOKEN [IGNORE_CASE] :

   582 {

   583     < FUNCTIONLANG : "lang(" >

   584 }

   585 

   586 <DEFAULT>

   587 TOKEN [IGNORE_CASE] :

   588 {

   589     < FUNCTIONNOT : ":not(" >

   590 }

   591 

   592 

   593 <DEFAULT>

   594     TOKEN :

   595 {

   596     < FUNCTION : <IDENT> "(" >

   597 }

   598 

   599 /* Quick and dirty way to catch HTML tags starting CSS documents 

   600   (common mistake) */

   601 <DEFAULT>

   602     TOKEN:

   603 {

   604     <HTMLSTARTTAG : "<" ( <S> )* <IDENT> ( <S> )* 

   605 	                ( <IDENT> "=" ( <IDENT> | <STRING> ) ( <S> )* )* 

   606 	            ">" >

   607   | <HTMLENDTAG : "</" ( <S> )* <IDENT> ( <S> )* ">" >

   608 }

   609 

   610 //<DEFAULT, IN_COMMENT>

   611 //TOKEN :

   612 //{ /* avoid token manager error */

   613 //   < UNKNOWN : ~[] >

   614 //}

   615 

   616 /*

   617  * The grammar of CSS2

   618  */

   619 

   620 /**

   621  * The main entry for the parser.

   622  *

   623  * @exception ParseException exception during the parse

   624  */

   625 void parserUnit() :

   626 {

   627     Token n = null;

   628 }

   629 {

   630     try {

   631 	// used as an error recovery for HTML tags in CSS pages

   632         ( ( n=<HTMLSTARTTAG> | n=<HTMLENDTAG> ) {

   633 	    addError (

   634 new ParseException(ac.getMsg().getString("generator.dontmixhtml")), n.image); 

   635 	}

   636 	    )*

   637 	  ( charset() )* // * instead of ? to capture the reinit part

   638 	    ( <S> | <CDO> | <CDC> )*

   639 	    ( importDeclaration() ( ignoreStatement() ) )*

   640 	    ( namespaceDeclaration() ( ignoreStatement() ) )*

   641 	    afterImportDeclaration()

   642 	    <EOF>

   643 	 } catch (TokenMgrError err) {

   644    addError (new ParseException(ac.getMsg().getString("generator.unrecognize")),

   645 	     err.getMessage());

   646     }

   647 }

   648 

   649 void charset() :

   650 {

   651     Token n = null;

   652     Token charsetToken = null;

   653     Token space1Token = null;

   654     Token space2Token = null;

   655     Token semicolonToken = null;

   656     int nb_S = 0;

   657 }

   658 {  

   659     try {

   660 	charsetToken=<CHARSET_SYM> ( space1Token=<S> { nb_S++;} )* 

   661 	    n=<STRING> ( space2Token=<S> )* semicolonToken=<SEMICOLON>

   662 	    {

   663 		if (charsetdeclared && !reinited) {

   664 		    throw new ParseException(

   665 				     ac.getMsg().getString("parser.charset"));

   666 		}

   667 		// the @charset must be at the beginning of the document

   668 		if(charsetToken.beginLine != 1 || 

   669 		   charsetToken.beginColumn != 1) {

   670 		    throw new ParseException(

   671 				  ac.getMsg().getString("parser.charset"));

   672 		}

   673 		if ("css1".equals(ac.getCssVersion())) {

   674 		    throw new ParseException(ac.getMsg().getString(

   675 							 "parser.charsetcss1"));

   676 		}

   677 	        // stricter rule for CSS21 and soon for CSS3

   678 		if ("css21".equals(ac.getCssVersion())) {

   679 		    // single space before

   680 		    // case sensitive

   681 		    // no space before ;

   682 		    // no comments

   683 		    // string must start with "

   684 		    if ( (nb_S != 1) ||

   685 			 (!"@charset".equals(charsetToken.image)) ||

   686 			 (!" ".equals(space1Token.image)) || 

   687 			 (space2Token != null && 

   688 			  !"".equals(space2Token.image)) ||

   689 			 (space1Token.specialToken != null) ||

   690 			 (n.specialToken != null) ||

   691 			 (semicolonToken.specialToken != null) ||

   692 			 (n.image.charAt(0) != '\"')

   693 			) {

   694 			throw new ParseException(ac.getMsg().getString(

   695 						     "parser.charsetspecial"));

   696 		    }

   697 		}

   698 		if (!charsetdeclared) {

   699 		    addCharSet(n.image.substring(1, n.image.length()-1));

   700 		    charsetdeclared = true;

   701 		} else {

   702 		    reinited = false;

   703 		}

   704 	    }

   705     } catch (Exception e) {

   706 	String skip = charsetToken +

   707 	    ((space1Token == null) ? "" : space1Token.image) +

   708 	    n +

   709 	    ((space2Token == null) ? "" : space2Token.image) +

   710 	    ";";

   711         addError(e, skip); 

   712     }

   713 }

   714 

   715 void afterImportDeclaration() :

   716 {String ret; }

   717 {

   718     ( ( ruleSet() | media() | page() | fontFace() | preference() | 

   719 	colorprofile() | phoneticAlphabet() | ret=skipStatement() 

   720 	{ if ((ret == null) || (ret.length() == 0)) {

   721 		return; 

   722 	    }

   723 	  // quite ugly but necessary to avoid probably a lot of changes in the

   724 	  // grammar, still having a beautiful error message

   725 	    else if (ret.startsWith("@charset")) {

   726 		ParseException e = 

   727 		new ParseException(ac.getMsg().getString("parser.charset"));

   728 		addError(e, ret);

   729 	    } else if (ret.startsWith("@import")) {

   730 		ParseException e = 

   731 		new ParseException(ac.getMsg().getString("parser.import_not_allowed"));

   732 		addError(e, ret);

   733 	    } else {

   734 		ParseException e = 

   735 	     new ParseException(ac.getMsg().getString("generator.unrecognize"));

   736 		addError(e, ret);

   737 	    }

   738 	}

   739 	) ignoreStatement() )*

   740 }

   741 

   742 void ignoreStatement() :

   743 {}

   744 {

   745     ( ( <CDO> | <CDC> | atRuleDeclaration() ) ( <S> )* )*

   746 }

   747 

   748 void namespaceDeclaration() :

   749 {

   750     Token n=null;

   751     Token v=null;

   752     boolean is_url; /* for formatting */

   753     String nsname;

   754     String prefix = null;

   755     CssValue val;

   756 }

   757 {

   758     // FIXME add namespaces in context to match when a definition happens

   759     ( <NAMESPACE_SYM> 

   760       ( <S> )* 

   761       ( n=<IDENT> {

   762 	  prefix = convertIdent(n.image);

   763       } 

   764 	  ( <S> )* )?

   765       ( v=<STRING> { 

   766 	      is_url = false;

   767 	      nsname = v.image.substring(1, v.image.length()-1);

   768 	  } 

   769 	  | v=<URL> {

   770 	      is_url = true;

   771 	      val = new CssURL(); 

   772 	      ((CssURL) val).set(v.image, ac, url);

   773 	      nsname = (String) val.get();

   774 	      if ((nsname.charAt(0) == '"')

   775 		  || (nsname.charAt(0) == '\'')) {

   776 		  nsname = nsname.substring(1, nsname.length()-1);

   777 	      }

   778 	  }

   779       ) 

   780       ( <S> )*

   781       <SEMICOLON> 

   782       ( <S> )*

   783       ) {

   784 	if (!ac.getCssVersion().equals("css3")) {

   785 	    addError(new InvalidParamException("at-rule", "@namespace", ac),

   786 		     (n==null)?"default":n.toString());

   787 	} else {

   788 	    if (v != null) {

   789 		handleNamespaceDeclaration(getURL(), prefix, nsname, is_url);

   790 	    }

   791 	}

   792     }

   793 }

   794 /**

   795  * The import statement

   796  *

   797  * @exception ParseException exception during the parse

   798  */

   799 void importDeclaration() :

   800 {Token n;

   801     AtRuleMedia media = new AtRuleMedia();

   802     CssValue val; 

   803     String importFile;

   804     boolean is_url = false;

   805 }

   806 {

   807     try {

   808 	<IMPORT_SYM> ( <S> )*

   809 	    ( n=<STRING> {

   810 		importFile = n.image.substring(1, n.image.length() -1);

   811 		is_url = false;

   812 	    } 

   813 	      | n=<URL> {

   814 		val = new CssURL(); 

   815 		((CssURL) val).set(n.image, ac, url);

   816 		importFile = (String) val.get();

   817 		if ((importFile.charAt(0) == '"')

   818 		    || (importFile.charAt(0) == '\'')) {

   819 		    importFile = importFile.substring(1, importFile.length()-1);

   820 		}

   821 		is_url = true;

   822 	    } 

   823 	    )

   824 	    ( <S> )*

   825 	    ( medium(media) 

   826 	      ( <COMMA> ( <S> )* medium(media) 

   827 		)* )? <SEMICOLON> 

   828 	    ( <S> )*

   829 	    { 

   830 		handleImport(getURL(), importFile, is_url, media);

   831 	    } 

   832     } catch (ParseException e) {

   833 	addError(e, skipStatement()); 

   834     }

   835 }

   836 

   837 /**

   838  * @exception ParseException exception during the parse

   839  */

   840 void media() :

   841 {

   842     AtRule old = getAtRule();

   843     AtRuleMedia newRule = new AtRuleMedia();

   844     setAtRule(newRule);

   845     Token n;

   846     CssProperty p = null;

   847 }

   848 {

   849     try {

   850 	<MEDIA_SYM> ( <S> )*

   851             // <CSS3>

   852 	    (n=<MEDIARESTRICTOR> { newRule.addMediaRestrictor(convertIdent(n.image), ac); } ( <S> )+)? 

   853 	    medium(newRule) 

   854             // </CSS3>

   855 	    ( <COMMA> ( <S> )* medium(newRule) )* 

   856             // <CSS3>

   857 	    (<AND> ( <S> )* <RPARAN> ( <S> )* p=mediadeclaration() { newRule.addMediaFeature(p); } <LPARAN> ( <S> )* )*

   858             // </CSS3>

   859    

   860 	    {

   861 		String media = getAtRule().toString();

   862 		if (ac.getMedium() != null && 

   863 		    !(media.equals(ac.getMedium())) &&

   864 		    !(ac.getMedium().equals("all"))) {

   865 		 

   866 		    ac.getFrame().addWarning("noothermedium", 

   867 					     getAtRule().toString());

   868 		}

   869 		if (ac.getCssVersion().equals("css1")) {

   870 		    skipStatement();

   871 		    addError(new InvalidParamException("noatruleyet", "", ac),

   872 			     getAtRule().toString());

   873 		}

   874 		if (!ac.getCssVersion().equals("css1")) {

   875 		    newAtRule(getAtRule());	

   876 		}

   877 	    }

   878 	<LBRACE> ( <S> )* ( ruleSet() )* <RBRACE> ( <S> )*

   879 	     {

   880 		 if (!ac.getCssVersion().equals("css1")) {

   881 		     endOfAtRule();

   882 		 }

   883 	     }

   884     } catch (ParseException e) {

   885 	if (!ac.getCssVersion().equals("css1")) {

   886 	    addError(e, skipStatement()); 

   887 	}

   888     } finally {

   889 	setAtRule(old);

   890     }

   891 }

   892 

   893 /**

   894  * @exception ParseException exception during the parse

   895  */

   896 void medium(AtRuleMedia media) : /* tv, projection, screen, ... */

   897 {Token n;}

   898 {

   899     n=<IDENT> ( <S> )*

   900     {

   901 	try {

   902 	    media.addMedia(convertIdent(n.image), ac); 

   903 	} catch (InvalidParamException e) {

   904 	    CssError error = new CssError(getSourceFile(), getLine(), e);

   905 	    ac.getFrame().addError(error);	

   906 	}

   907     }

   908 }

   909 

   910 /**

   911  * @exception ParseException exception during the parse

   912  */

   913 void page() :

   914 {

   915     Vector       v                              ;

   916     Token        n        = null                ;

   917     Vector       collectv = new Vector()        ;

   918     CssSelectors s        = new CssSelectors(ac);

   919     AtRule       old      = getAtRule()         ;

   920     AtRulePage   newRule  = new AtRulePage()    ;

   921     setAtRule(newRule);

   922     s.setAtRule(getAtRule());

   923 }

   924 {

   925     try {

   926 	<PAGE_SYM> ( <S> )*

   927             // FIXME <CSS3> ?

   928             ( n=<IDENT> { newRule.setIdent(convertIdent(n.image)); } 

   929 	      ( <S> )* )?

   930             // </CSS3>

   931 	    ( pseudo_page(newRule) )? <LBRACE> ( <S> )* ( v=pageContent() 

   932 		{ 

   933 		    collectv = v;

   934 		}

   935 							  ) <RBRACE> ( <S> )*

   936 	    {

   937 		if (!ac.getCssVersion().equals("css1")) {

   938 		    newAtRule(getAtRule());

   939 		}

   940 

   941 		if (!ac.getCssVersion().equals("css1")) {

   942 		    addProperty(collectv);

   943 		    endOfRule();

   944 		    endOfAtRule();

   945 		}

   946 		if (v == null) {

   947 		    ac.getFrame().addWarning("no-declaration");

   948 		} else {

   949 		    handleRule(s, collectv);

   950 		}

   951 	    }

   952     } catch (InvalidParamException ie) {

   953 	if (!ac.getCssVersion().equals("css1")) {

   954 	    skipStatement();

   955 	    removeThisAtRule();

   956 	    ac.getFrame().addError(new CssError(ie));

   957 	}

   958     } catch (ParseException e) {

   959 	if (!ac.getCssVersion().equals("css1")) {

   960 	    removeThisAtRule();

   961 	    addError(e, skipStatement()); 

   962 	}

   963     } finally {

   964 	setAtRule(old);

   965     }

   966 }

   967 

   968 Vector pageContent() :

   969 { CssProperty prop;

   970     Vector v = new Vector();

   971 }

   972 {

   973     // <CSS3> ?? FIXME

   974     v=prefAtRule() { return v;}

   975     // </CSS3>

   976     |

   977     v=declarations() { return v;} /* FIXME moved here as it can match empty string */

   978 }

   979 

   980 Vector prefAtRule() :

   981 { Token n; 

   982     Vector v;

   983 }

   984 {

   985     try {

   986         (n=<ATTOP> | n=<ATBOTTOM> | n=<ATLEFT> | n=<ATRIGHT> ) ( <S> )*

   987 	    <LBRACE> ( <S> )* v=declarations() <RBRACE> ( <S> )* 

   988 	    {

   989 		return v;

   990 	    }

   991     } catch (ParseException e) {

   992 	addError(e, skipStatement());

   993     }

   994 }

   995 

   996 void pseudo_page(AtRulePage page) :

   997 { Token n; }

   998 {

   999     ":" n=<IDENT> ( <S> )*

  1000     { 

  1001 	try {

  1002 	    page.setName(":" + convertIdent(n.image), ac); 

  1003 	} catch (InvalidParamException e) {

  1004 	    throw new InvalidParamException("pseudo", n.image, ac );

  1005 	    /*CssError error = new CssError(getSourceFile(), getLine(), e);

  1006 	      ac.getFrame().addError(error);	*/

  1007 	}

  1008     }

  1009 }

  1010 

  1011 void fontFace() :

  1012 {

  1013     Vector v;

  1014     AtRule old = getAtRule();

  1015     setAtRule(new AtRuleFontFace());

  1016     CssSelectors s = new CssSelectors(ac);

  1017     s.setAtRule(getAtRule());

  1018 }

  1019 {

  1020     try {

  1021 	<FONT_FACE_SYM> ( <S> )* 

  1022 	    {

  1023 		if (ac.getCssVersion().equals("css1")) {

  1024 		    skipStatement();

  1025 		    addError(new InvalidParamException("noatruleyet", "", ac),

  1026 			     getAtRule().toString());

  1027 		}

  1028 		if (!ac.getCssVersion().equals("css1")) {

  1029 		    newAtRule(getAtRule());	

  1030 		}

  1031 

  1032 	    }

  1033 	<LBRACE> ( <S> )* v=declarations() <RBRACE> ( <S> )*

  1034 	     {

  1035 		 if (!ac.getCssVersion().equals("css1")) {

  1036 		     addProperty(v);

  1037 		     endOfRule();

  1038 		     endOfAtRule();

  1039 		 }

  1040 		 if (v == null) {

  1041 		     ac.getFrame().addWarning("no-declaration");

  1042 		 } else {

  1043 		     handleRule(s, v);

  1044 		 }

  1045 	     }

  1046     } catch (ParseException e) {

  1047 	if (!ac.getCssVersion().equals("css1")) {

  1048 	    addError(e, skipStatement()); 

  1049         }

  1050     } finally {

  1051 	setAtRule(old);

  1052     }

  1053 }

  1054 

  1055 void colorprofile() :

  1056 {

  1057     Vector v;

  1058     AtRule old = getAtRule();

  1059     setAtRule(new AtRuleColorProfile());

  1060     CssSelectors s = new CssSelectors(ac);

  1061     s.setAtRule(getAtRule());

  1062 }

  1063 {

  1064     try {

  1065 	<COLOR_PROFILE> ( <S> )*

  1066 	    {

  1067 		if (!ac.getCssVersion().equals("svg")) {

  1068 		    skipStatement();

  1069 		    addError(new InvalidParamException("onlysvg", "", ac),

  1070 			     getAtRule().toString());

  1071 		}

  1072 		if (ac.getCssVersion().equals("svg")) {

  1073 		    newAtRule(getAtRule());	

  1074 		}

  1075 

  1076 	    }

  1077 	<LBRACE> ( <S> )* v=declarations() <RBRACE> ( <S> )*

  1078 	     {

  1079 		 if (ac.getCssVersion().equals("svg")) {

  1080 		     addProperty(v);

  1081 		     endOfRule();

  1082 		     endOfAtRule();

  1083 		 }

  1084 

  1085 		 if (v == null) {

  1086 		     //ac.getFrame().addWarning("medialist");

  1087 		 } else {

  1088 		     handleRule(s, v);  

  1089 		 }

  1090 	     }

  1091     }

  1092     catch (ParseException e) {

  1093 	if (ac.getCssVersion().equals("svg")) {

  1094             addError(e, skipStatement());

  1095 	}

  1096     } finally {

  1097 	setAtRule(old);

  1098     }

  1099 }

  1100 

  1101 

  1102 void preference() :

  1103 {

  1104     Vector v;

  1105     AtRule old = getAtRule();

  1106     setAtRule(new AtRulePreference());

  1107     CssSelectors s = new CssSelectors(ac);

  1108     s.setAtRule(getAtRule());

  1109 }

  1110 {

  1111     try {

  1112 	<PREF_SYM> ( <S> )*

  1113 	    {

  1114 		if (ac.getCssVersion().equals("css1")) {

  1115 		    skipStatement();

  1116 		    addError(new InvalidParamException("noatruleyet", "", ac),

  1117 			     getAtRule().toString());

  1118 		}

  1119 		if (!ac.getCssVersion().equals("css1")) {

  1120 		    newAtRule(getAtRule());	

  1121 		}

  1122 

  1123 	    }

  1124 	<LBRACE> ( <S> )* v=declarations() <RBRACE> ( <S> )*

  1125 	     {

  1126 		 if (!ac.getCssVersion().equals("css1")) {

  1127 		     addProperty(v);

  1128 		     endOfRule();

  1129 		     endOfAtRule();

  1130 		 }

  1131 

  1132 		 if (v == null) {

  1133 		     ac.getFrame().addWarning("medialist");

  1134 		 } else {