public static void Rule(List lhs, OpenBracket openBracket, OptionalListBody optionalListBody, CloseBracket closeBracket)
{
if (optionalListBody.CodeList == null)
{
lhs.CodeList = new CodeList();
}
else
{
lhs.CodeList = optionalListBody.CodeList;
}
}
public static void Rule(List lhs, OpenBracket openBracket, OptionalListBody optionalListBody, CloseBracket closeBracket)
{
if (optionalListBody.CodeList == null)
{
lhs.CodeList = new CodeList();
}
else
{
lhs.CodeList = optionalListBody.CodeList;
}
}
protected virtual OpenBracket VisitOpenBracket(OpenBracket node)
{
return(VisitSyntaxNode(node) as OpenBracket);
}
protected override OpenBracket VisitOpenBracket(OpenBracket node)
{
visitedOpenBracket = true;
Assert.IsTrue(node.Value == "[");
return(base.VisitOpenBracket(node));
}
public override bool Parse(ItemFactory itemFactory, ITextProvider text, TokenStream tokens)
{
if (tokens.CurrentToken.TokenType != CssTokenType.OpenSquareBracket)
{
return(false);
}
// Collect each piece of "[ name = value ]", any of which could be missing after the '['
OpenBracket = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.SquareBracket);
if (ItemName.IsAtItemName(tokens))
{
AttributeName = itemFactory.CreateSpecific <ItemName>(this);
AttributeName.Parse(itemFactory, text, tokens);
AttributeName.Context = CssClassifierContextCache.FromTypeEnum(CssClassifierContextType.ElementAttribute);
Children.Add(AttributeName);
}
else
{
OpenBracket.AddParseError(ParseErrorType.AttributeSelectorElementMissing, ParseErrorLocation.AfterItem);
}
switch (tokens.CurrentToken.TokenType)
{
case CssTokenType.BeginsWith: // ^=
case CssTokenType.EndsWith: // $=
case CssTokenType.OneOf: // ~=
case CssTokenType.ListBeginsWith: // |=
case CssTokenType.ContainsString: // *=
case CssTokenType.Equals: // =
Operation = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.SelectorOperator);
break;
}
if (tokens.CurrentToken.TokenType == CssTokenType.Identifier)
{
AttributeValue = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.ElementAttributeValue);
}
else if (tokens.CurrentToken.IsString())
{
AttributeValue = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.ElementAttributeValue);
}
if (AttributeValue != null && Operation == null)
{
AttributeValue.AddParseError(ParseErrorType.AttributeSelectorOperationMissing, ParseErrorLocation.BeforeItem);
}
else if (AttributeValue == null && Operation != null)
{
Operation.AddParseError(ParseErrorType.AttributeSelectorValueMissing, ParseErrorLocation.AfterItem);
}
if (AttributeValue != null && tokens.CurrentToken.TokenType == CssTokenType.Identifier)
{
OperationModifier = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.SelectorOperator);
if (OperationModifier.Length != 1 || text[OperationModifier.Start] != 'i')
{
OperationModifier.AddParseError(ParseErrorType.UnexpectedToken, ParseErrorLocation.WholeItem);
}
}
if (tokens.CurrentToken.TokenType == CssTokenType.CloseSquareBracket)
{
CloseBracket = Children.AddCurrentAndAdvance(tokens, CssClassifierContextType.SquareBracket);
}
else
{
AddParseError(ParseErrorType.AttributeSelectorCloseBracketMissing, ParseErrorLocation.AfterItem);
}
return(Children.Count > 0);
}
public static void Rule(List lhs, OpenBracket openBracket, OptionalListBody optionalListBody, CloseBracket closeBracket)
{
lhs.CodeList = optionalListBody.CodeList ?? new CodeList();
}
private bool ReadToken(out Token token)
{
var currentState = InputState.Start;
var tokenStr = new StringBuilder();
for (; _pos < _expression.Length; _pos++)
{
var symbol = _expression[_pos];
var pair = _table.Get(new KeyValuePair <InputState, char>(currentState, symbol));
if (pair.Key == InputState.Start)
{
continue;
}
if (pair.Key == InputState.Finish)
{
switch (pair.Value)
{
case OutputState.Add:
token = new Add();
Step();
return(true);
case OutputState.Sub:
token = new Substract();
Step();
return(true);
case OutputState.Mul:
token = new Multiply();
return(true);
case OutputState.Div:
token = new Divide();
Step();
return(true);
case OutputState.Pow:
token = new Power();
Step();
return(true);
case OutputState.LBr:
token = new OpenBracket();
Step();
return(true);
case OutputState.RBr:
token = new CloseBracket();
Step();
return(true);
case OutputState.LPart:
token = new Digit(tokenStr.ToString());
return(true);
case OutputState.RPart:
token = new Digit(tokenStr.ToString());
return(true);
}
}
currentState = pair.Key;
tokenStr.Append(symbol);
}
token = null;
return(false);
}
public static void Rule(List lhs, OpenBracket openBracket, OptionalListBody optionalListBody, CloseBracket closeBracket)
{
lhs.CodeList = optionalListBody.CodeList ?? new CodeList();
}
