/// <summary>
/// Validates the code content of a TextReader and returns the top of the compilation unit syntax tree.
/// If parsing resulted in syntax errors the result will be <c>null</c>.
/// </summary>
/// <param name="stream">The TextReader to parse code from.</param>
/// <returns>Top level node of an LSL syntax tree.</returns>
/// <exception cref="ArgumentNullException"><paramref name="stream"/> is <c>null</c>.</exception>
public ILSLCompilationUnitNode Validate(TextReader stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
HasSyntaxErrors = false;
var inputStream = new AntlrInputStream(stream);
var lexer = new LSLLexer(inputStream);
lexer.RemoveErrorListeners();
var tokenStream = new CommonTokenStream(lexer);
var parser = new LSLParser(tokenStream);
parser.RemoveErrorListeners();
parser.AddErrorListener(_antlrParserErrorHandler);
var parseTree = parser.compilationUnit();
if (parser.NumberOfSyntaxErrors > 0)
{
HasSyntaxErrors = true;
return(null);
}
try
{
var tree = _validatorVisitor.ValidateAndBuildTree(parseTree, lexer.Comments);
if (_validatorVisitor.HasSyntaxWarnings)
{
HasSyntaxWarnings = true;
}
if (tree.HasErrors)
{
HasSyntaxErrors = true;
return(null);
}
return(tree);
}
finally
{
_validatorVisitor.Reset();
}
}
/// <summary>
/// Parses an LSL list from a string and returns the simple expressions it contains as an enumerable.
/// <remarks>
/// Take note that parsing wont start to occur until you begin enumerating the returned value.
/// </remarks>
/// </summary>
/// <param name="list">The string containing the list.</param>
/// <param name="parsingFlags">Optional parsing flags.</param>
/// <returns>An enumerable of <see cref="ILSLListExpr"/> nodes parsed from the list string.</returns>
/// <exception cref="LSLListParserOptionsConstraintException">
/// When an
/// <see cref="LSLListParsingFlags" /> constraint is violated.
/// </exception>
/// <exception cref="LSLListParserSyntaxException">
/// Rotations must contain only literal values to be parsed, and cannot contain these types of expressions: rotations,
/// vectors, lists or strings.
/// or
/// Vectors must contain only literal values to be parsed, and cannot contain these types of expressions: rotations,
/// vectors, lists or strings.
/// or
/// Lists cannot contain other lists.
/// or
/// Cast expressions can only be used to specify that a list element is a 'key' and not a 'string'
/// or
/// Encountered an un-parseable expression in the list, only literal values and possibly variable names are acceptable
/// when parsing.
/// </exception>
public static IEnumerable <ILSLListExpr> ParseList(string list,
LSLListParsingFlags parsingFlags = LSLListParsingFlags.None)
{
var strm = new AntlrInputStream(new StringReader(list));
var lex = new LSLLexer(strm);
var parse = new LSLParser(new CommonTokenStream(lex));
parse.ErrorListeners.Clear();
lex.ErrorListeners.Clear();
var errorListener = new ErrorListener();
parse.AddErrorListener(errorListener);
parse.AddErrorListener(errorListener);
var production = parse.listLiteral();
if (production.expression_list == null)
{
throw new LSLListParserSyntaxException("List rule missing expression list, parsing error");
}
var listProduction = production.expression_list.expressionList();
if (listProduction == null)
{
yield break;
}
foreach (var child in EnumerateExpressionList(listProduction))
{
var atomToken = child as LSLParser.Expr_AtomContext;
var castExpression = child as LSLParser.Expr_TypeCastContext;
var negateOrPositive = child as LSLParser.Expr_PrefixOperationContext;
if (atomToken != null)
{
var maybeBasic = BasicAtomToExpr(atomToken);
if (maybeBasic != null)
{
yield return(maybeBasic);
}
if (atomToken.variable != null)
{
if ((parsingFlags & LSLListParsingFlags.AllowVariableReferencesInList) ==
LSLListParsingFlags.AllowVariableReferencesInList)
{
yield return(new LSLListStringExpr(atomToken.GetText()));
}
else
{
throw new LSLListParserOptionsConstraintException(
"Variable references are not allowed in the list.");
}
}
if (atomToken.rotation_literal != null)
{
yield return(ListExpressionFromRotation(parsingFlags, atomToken));
}
if (atomToken.vector_literal != null)
{
yield return(ListExpressionFromVector(parsingFlags, atomToken));
}
if (atomToken.list_literal != null)
{
throw new LSLListParserSyntaxException("Lists cannot contain other lists.");
}
}
else if (castExpression != null)
{
var stringLiteral = castExpression.expr_rvalue as LSLParser.Expr_AtomContext;
if (stringLiteral != null && stringLiteral.string_literal != null &&
castExpression.cast_type.Text == "key")
{
yield return(new LSLListKeyExpr(stringLiteral.GetText()));
}
else
{
throw new LSLListParserSyntaxException(
"Cast expressions can only be used to specify that a list element is a 'key' and not a 'string'");
}
}
else if (negateOrPositive != null)
{
var floatOrInt = negateOrPositive.expr_rvalue as LSLParser.Expr_AtomContext;
var operation = negateOrPositive.operation.Text;
var validType = floatOrInt != null &&
(floatOrInt.float_literal != null || floatOrInt.integer_literal != null);
if (validType && operation == "-" || operation == "+")
{
yield return(BasicAtomToExpr(floatOrInt, operation));
}
else
{
throw new LSLListParserSyntaxException(
string.Format(
"The Negative and Positive prefix operator can only be used on Floats and Integer list elements, operator '{0}' is not valid.",
operation));
}
}
else
{
throw new LSLListParserSyntaxException(
"Encountered an un-parseable expression in the list, only LSL literals and possibly variable names are acceptable list elements.");
}
}
}
