CSS2 v3.02.1.atg

using System.Collections.Generic;

COMPILER CSS3

	public CSSDocument CSSDoc;

		bool PartOfHex(string value) {
			if (value.Length == 7) { return false; }
			if (value.Length + la.val.Length > 7) { return false; }
			System.Collections.Generic.List<string> hexes = new System.Collections.Generic.List<string>(new string[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "a", "b", "c", "d", "e", "f" });
			foreach (char c in la.val) {
				if (!hexes.Contains(c.ToString())) {
					return false;
				}
			}
			return true;
		}
		bool IsUnit() {
			if (la.kind != 1) { return false; }
			System.Collections.Generic.List<string> units = new System.Collections.Generic.List<string>(new string[] { "em", "ex", "px", "gd", "rem", "vw", "vh", "vm", "ch", "mm", "cm", "in", "pt", "pc", "deg", "grad", "rad", "turn", "ms", "s", "hz", "khz" });
			return units.Contains(la.val.ToLower());
		}
		bool IsNumber() {
			if (la.val.Length > 0) {
				return char.IsDigit(la.val[0]);
			}
			return false;
		}

/*------------------------------------------------------------------------*
 *----- SCANNER DESCRIPTION ----------------------------------------------*
 *------------------------------------------------------------------------*/

CHARACTERS

	tab                = '\u0009'. /*  9 = tabulator */
	eol                = '\u000a'. /* 10 = line feed */
	cr                 = '\u000d'. /* 13 = carriage return */
	newLine            = cr + eol. /* Line separator character (U+2028) + Paragraph separator character (U+2029) */

	letter             = 'A' .. 'Z' + 'a' .. 'z' + '_'.
	digit              = "0123456789".
	hexDigit           = digit + "ABCDEFabcdef".
	notDigit           = ANY - digit.

	char               = ANY - "'" - '\\' - newLine.
	verbatimStringChar = ANY - '"'.
	regularStringChar  = ANY - '"' - '\\' - newLine.
	notNewLine         = ANY - newLine .
	ws                 = " " + tab + '\u000b' + '\u000c'. /* Any character with Unicode class Zs */
	identchar		   = letter + digit + '-'.

TOKENS

	ident = letter { identchar }.  //(letter | '-') { identchar }.
	newline = newLine.
	digit = digit.
	whitespace = ws.

PRAGMAS

COMMENTS FROM "/*" TO "*/"

IGNORE eol + cr

PRODUCTIONS

/*------------------------------------------------------------------------*
 *--------------------------- Declarations -------------------------------*
 *------------------------------------------------------------------------*/

CSS3 =							(. CSSDoc = new CSSDocument();
									string cset = null;
									RuleSet rset = null;
									Directive dir = null;
								.)
	{ whitespace }
    {("<!--" | "-->")}
    {
		( ruleset<out rset>		(. CSSDoc.RuleSets.Add(rset); .)
		| directive<out dir>	(. CSSDoc.Directives.Add(dir); .)
		)
		{("<!--" | "-->")}
		{ whitespace }
	}
.
QuotedString<out string qs> =	(. qs = ""; char quote = '\n'; .)
	( "'"						(. quote = '\''; .)
		{ANY					(. qs += t.val; .)
								(. if (la.val.Equals("'") && !t.val.Equals("\\")) { break; } .)
		}
		"'"
	| '"'						(. quote = '"'; .)
		{ANY					(. qs += t.val; .)
								(. if (la.val.Equals("\"") && !t.val.Equals("\\")) { break; } .)
		}
		'"'
	)							(. /*if (quote != '\n') { qs = quote + qs + quote; }*/ .)
.
URI<out string url> =			(. url = ""; .)
	"url"
	{ whitespace }
	[ "(" ]
	{ whitespace }
	(
		QuotedString<out url>
		| {ANY					(. url += t.val; .)
								(. if (la.val.Equals(")")) { break; } .)
		}
	)
	{ whitespace }
	[ ")" ]
.
medium<out Medium m> =		(. m = Medium.all; .)
	(
		"all"			(. m = Medium.all; .)
		| "aural"		(. m = Medium.aural; .)
		| "braille"		(. m = Medium.braille; .)
		| "embossed"	(. m = Medium.embossed; .)
		| "handheld"	(. m = Medium.handheld; .)
		| "print"		(. m = Medium.print; .)
		| "projection"	(. m = Medium.projection; .)
		| "screen"		(. m = Medium.screen; .)
		| "tty"			(. m = Medium.tty; .)
		| "tv"			(. m = Medium.tv; .)
	)
.
identity<out string ident> =	(. ident = ""; .)
	/*[ '-'				(. ident += t.val; .)
	]*/
	(
		ident
		| "n"
		| "url"
		| "all"
		| "aural"
		| "braille"
		| "embossed"
		| "handheld"
		| "print"
		| "projection"
		| "screen"
		| "tty"
		| "tv"
	)					(. ident += t.val; .)
.
directive<out Directive dir> =	(. dir = new Directive();
									Declaration dec = null;
									RuleSet rset = null;
									Expression exp = null;
									Directive dr = null;
									string ident = null;
									Medium m;
								.)
	'@'							(. dir.Name = "@"; .)
	[ "-"						(. dir.Name += "-"; .)
	]
	identity<out ident>			(. dir.Name += ident;
									switch (dir.Name.ToLower()) {
										case "@media": dir.Type = DirectiveType.Media; break;
										case "@import": dir.Type = DirectiveType.Import; break;
										case "@charset": dir.Type = DirectiveType.Charset; break;
										case "@page": dir.Type = DirectiveType.Page; break;
										case "@font-face": dir.Type = DirectiveType.FontFace; break;
										case "@namespace": dir.Type = DirectiveType.Namespace; break;
										default: dir.Type = DirectiveType.Other; break;
									}
								.)
	{ whitespace }
	[
		medium<out m>			(. dir.Mediums.Add(m); .)
		{ whitespace }
		{ ',' { whitespace }
			medium<out m>		(. dir.Mediums.Add(m); .)
			{ whitespace }
		}
	|
		expr<out exp>			(. dir.Expression = exp; .)
		{ whitespace }
	]
	(
		'{' { whitespace } [ {
			(	IF(dir.Type == DirectiveType.Page || dir.Type == DirectiveType.FontFace)
				declaration<out dec>		(. dir.Declarations.Add(dec); .)
				{ whitespace }
				{ ';' { whitespace }		(. if (la.val.Equals("}")) { Get(); return; } .)
					declaration<out dec>	(. dir.Declarations.Add(dec); .)
					{ whitespace }
				}
				[ ';' { whitespace } ]
			|
				ruleset<out rset>			(. dir.RuleSets.Add(rset); .)
				{ whitespace }
			|	directive<out dr>			(. dir.Directives.Add(dr); .)
				{ whitespace }
			)
		} ] '}' { whitespace }
	|
		';' { whitespace }
	)
.
/*
+c Directive : IDeclarationContainer, IRuleSetContainer {
	+DirectiveType Type;
	+string Name;
	+Expression Expression;
	+Medium[] Mediums;
	+Directive[] Directives;
	+RuleSet[] RuleSets;
	+Declaration[] Declarations;
}
+e DirectiveType {
	Media, Import, Charset, Page, FontFace, Namespace, Other
}
+e Unit {
	em, ex, px, gd, rem, vw, vh, vm, mm, cm, in, pt, pc, deg, grad, rad, ms, s, Hz, kHz
}
*/
ruleset<out RuleSet rset> =		(. rset = new RuleSet();
									Selector sel = null;
									Declaration dec = null;
								.)
	selector<out sel>			(. rset.Selectors.Add(sel); .)
	{ whitespace }
	{ ',' { whitespace }
		selector<out sel>		(. rset.Selectors.Add(sel); .)
		{ whitespace }
	}
    '{' { whitespace }
	[ declaration<out dec>		(. rset.Declarations.Add(dec); .)
	{ whitespace }
	{ ';' { whitespace }		(. /* ';' may not be the begining of another declaration */
									if (la.val.Equals("}")) { Get(); return; }
								.)
	declaration<out dec>		(. rset.Declarations.Add(dec); .)
	{ whitespace }
	} [ ';' { whitespace } ] ] '}' { whitespace }
.
selector<out Selector sel> =	(. sel = new Selector();
									SimpleSelector ss = null;
									Combinator? cb = null;
								.)
	simpleselector<out ss>		(. sel.SimpleSelectors.Add(ss); .)
	{ whitespace }
	{ [ ('+'					(. cb = Combinator.PrecededImmediatelyBy; .)
		| '>'					(. cb = Combinator.ChildOf; .)
		| '~'					(. cb = Combinator.PrecededBy; .)
		) ]
		{ whitespace }
		simpleselector<out ss>	(. if (cb.HasValue) { ss.Combinator = cb.Value; }
									sel.SimpleSelectors.Add(ss);
								.)
								(. cb = null; .)
		{ whitespace }
	}
.
simpleselector<out SimpleSelector ss> =		(. ss = new SimpleSelector();
											ss.ElementName = "";
											string psd = null;
											BoneSoft.CSS.Attribute atb = null;
											SimpleSelector parent = ss;
											string ident = null;
											.)
	([ "-"							(. ss.ElementName += "-"; .)
	 ]
	  identity<out ident>			(. ss.ElementName += ident; .)
	| '*'							(. ss.ElementName = "*"; .)
	| ('#'
		[ "-"						(. ss.ID = "-"; .)
		]
		identity<out ident>			(. if (ss.ID == null) { ss.ID = ident; } else { ss.ID += ident; } .)
		| '.'						(. ss.Class = ""; .)
		  [ "-"						(. ss.Class += "-"; .)
		  ]
		  identity<out ident>		(. ss.Class += ident; .)
		| attrib<out atb>			(. ss.Attribute = atb; .)
		| pseudo<out psd>			(. ss.Pseudo = psd; .)
		)
	)
	{								(. SimpleSelector child = new SimpleSelector(); .)
		('#'
		[ "-"						(. child.ID = "-"; .)
		]
		identity<out ident>			(. if (child.ID == null) { child.ID = ident; } else { child.ID += "-"; } .)
		| '.'						(. child.Class = ""; .)
		  [ "-"						(. child.Class += "-"; .)
		  ]
		  identity<out ident>		(. child.Class += ident; .)
		| attrib<out atb>			(. child.Attribute = atb; .)
		| pseudo<out psd>			(. child.Pseudo = psd; .)
		)							(. parent.Child = child;
										parent = child;
									.)
	}
.
attrib<out BoneSoft.CSS.Attribute atb> =
									(. atb = new BoneSoft.CSS.Attribute();
										atb.Value = "";
										string quote = null;
										string ident = null;
									.)
	'['
	{ whitespace }
	identity<out ident>				(. atb.Operand = ident; .)
	{ whitespace }
	[
		( '='						(. atb.Operator = AttributeOperator.Equals; .)
		| "~="						(. atb.Operator = AttributeOperator.InList; .)
		| "|="						(. atb.Operator = AttributeOperator.Hyphenated; .)
		| "$="						(. atb.Operator = AttributeOperator.EndsWith; .)
		| "^="						(. atb.Operator = AttributeOperator.BeginsWith; .)
		| "*="						(. atb.Operator = AttributeOperator.Contains; .)
		)
		{ whitespace }
    	( [ "-"						(. atb.Value += "-"; .)
		  ]
		identity<out ident>			(. atb.Value += ident; .)
		| QuotedString<out quote>	(. atb.Value = quote; .)
		)
		{ whitespace }
	] ']'
.
pseudo<out string pseudo> =	(. pseudo = "";
								Expression exp = null;
								string ident = null;
							.)
	':' [ ':' ]
	{ whitespace }
	[ "-"					(. pseudo += "-"; .)
	]
	identity<out ident>		(. pseudo += ident; .)
	[
		//{ whitespace }
		'('					(. pseudo += t.val; .)
		{ whitespace }
		expr<out exp>			(. pseudo += exp.ToString(); .)
		{ whitespace }
		')'						(. pseudo += t.val; .)
		//{ whitespace }
	]
.
declaration<out Declaration dec> =
						(. dec = new Declaration();
							Expression exp = null;
							string ident = "";
						.)
	[ "-"				(. dec.Name += "-"; .)
	]
	identity<out ident>	(. dec.Name += ident; .)
	{ whitespace }
	':'
	{ whitespace }
	expr<out exp>	(. dec.Expression = exp; .)
	{ whitespace }
	[ "!" { whitespace } "important"	(. dec.Important = true; .)
	{ whitespace }
	]
.
expr<out Expression exp> =	(. exp = new Expression();
								char? sep = null;
								Term trm = null;
							.)
	term<out trm>			(. exp.Terms.Add(trm); .)
	{ whitespace }
	{ [ ('/'				(. sep = '/'; .)
		| ','				(. sep = ','; .)
		)
		{ whitespace }
	  ]
		term<out trm>		(.
								if (sep.HasValue) { trm.Seperator = sep.Value; }
								exp.Terms.Add(trm);
								sep = null;
							.)
		{ whitespace }
	}
.
term<out Term trm> =				(. trm = new Term();
										string val = "";
										Expression exp = null;
										string ident = null;
									.)
	(
		QuotedString<out val>		(. trm.Value = val; trm.Type = TermType.String; .)
	|
		URI<out val>				(. trm.Value = val; trm.Type = TermType.Url; .)
	|
		"U\\" identity<out ident>	(. trm.Value = "U\\" + ident; trm.Type = TermType.Unicode; .)
	|
		HexValue<out val>			(. trm.Value = val; trm.Type = TermType.Hex; .)
	|								(. bool minus = false; .)
		[ "-"						(. minus = true; .)
		]
		(
			identity<out ident>			(. trm.Value = ident; trm.Type = TermType.String; .)
										(. if (minus) { trm.Value = "-" + trm.Value; } .)
			[ { ( ':'						(. trm.Value += t.val; .)
				(
					[ ':'					(. trm.Value += t.val; .)
					]
					[ "-"					(. trm.Value += t.val; .)
					]
					identity<out ident>		(. trm.Value += ident; .)
				|
					HexValue<out val>		(. trm.Value += val; .)
				|
					{ digit					(. trm.Value += t.val; .)
					} [ '.'					(. trm.Value += "."; .)
						{ digit				(. trm.Value += t.val; .)
						}
					]
				)
			|
				'.'						(. trm.Value += t.val; .)
				[ "-"					(. trm.Value += t.val; .)
				]
				identity<out ident>		(. trm.Value += ident; .)
			|
				'='						(. trm.Value += t.val; .)
				[ "-"					(. trm.Value += t.val; .)
				]
				(identity<out ident>	(. trm.Value += ident; .)
				| { digit				(. trm.Value += t.val; .)
					}
				)
			) } ]
			[ '('
				{ whitespace }
				expr<out exp>			(. Function func = new Function();
											func.Name = trm.Value;
											func.Expression = exp;
											trm.Value = null;
											trm.Function = func;
											trm.Type = TermType.Function;
										.)
				{ whitespace }
				')'
			]
		|
			[ '+'						(. trm.Sign = '+'; .)
			]
										(. if (minus) { trm.Sign = '-'; } .)
			{ digit						(. val += t.val; .)
			} [ '.'						(. val += t.val; .)
				{ digit					(. val += t.val; .)
				}
			]
			[ (
				IF(la.val.ToLower().Equals("n"))
				/* func(4n+1) */
					"n"					(. val += t.val; .)
					[ ("+"				(. val += t.val; .)
					| "-"				(. val += t.val; .)
					) digit				(. val += t.val; .)
					{ digit				(. val += t.val; .)
					} ]
				| "%"					(. trm.Unit = Unit.Percent; .)
				| [ IF(IsUnit())
					identity<out ident>	(. try {
											trm.Unit = (Unit)Enum.Parse(typeof(Unit), ident, true);
										} catch {
											errors.SemErr(t.line, t.col, string.Format("Unrecognized unit '{0}'", ident));
										}
										.)
					]
			) ]							(. trm.Value = val; trm.Type = TermType.Number; .)
		)
	)
.
/*
Number<out string val> =			(. val = ""; .)
	[ ( "-"							(. val += t.val; .)
	  | "+"							(. val += t.val; .)
	  ) ]
	digit							(. val += t.val; .)
	{ digit							(. val += t.val; .)
	}
	[ "."							(. val += t.val; .)
	  { digit						(. val += t.val; .)
	  }
	]
.
*/
HexValue<out string val> =		(. val = "";
									bool found = false;
								.)
	'#'							(. val += t.val; .)
	(
		{ digit					(. val += t.val; .)
		}
	|
		IF(PartOfHex(val))
			ident				(. val += t.val; found = true; .)
	)
	[ IF(!found && PartOfHex(val))
		ident					(. val += t.val; .)
	]
.

END CSS3.