lsm/Orchard
1
0
Fork 0
mirror of https://github.com/OrchardCMS/Orchard.git synced 2025-10-15 03:25:23 +08:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

More renames and re-org

Browse Source 
--HG--
branch : dev
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/AbstractSyntaxTree.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/AbstractSyntaxTree.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/AstNode.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/AstNode.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/BinaryAstNode.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/BinaryAstNode.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ConstantAstNode.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/ConstantAstNode.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ErrorAstNode.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/ErrorAstNode.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/IAstNodeWithToken.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/IAstNodeWithToken.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/UnaryAstNode.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/UnaryAstNode.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Lexer.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/Lexer.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Parser.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/Parser.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Terminal.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/Token.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/TerminalKind.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/TokenKind.cs
rename : src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Tokenizer.cs => src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/Tokenizer.cs
This commit is contained in:
Renaud Paquay
2010-11-27 17:56:32 -08:00
parent 847cf5fb66
commit 289ba2ff5e
20 changed files with 198 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/Orchard.Tests.Modules/SimpleScripting/EvaluatorTests.cs
View File

@@ -1,5 +1,6 @@
using NUnit.Framework;
using Orchard.Widgets.SimpleScripting;
using Orchard.Widgets.SimpleScripting.Compiler;
namespace Orchard.Tests.Modules.SimpleScriptingTests {
[TestFixture]

36
src/Orchard.Tests.Modules/SimpleScripting/ParserTests.cs
View File

@@ -2,6 +2,8 @@
using System.Diagnostics;
using NUnit.Framework;
using Orchard.Widgets.SimpleScripting;
using Orchard.Widgets.SimpleScripting.Ast;
using Orchard.Widgets.SimpleScripting.Compiler;
namespace Orchard.Tests.Modules.SimpleScriptingTests {
[TestFixture]
@@ -18,7 +20,7 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandBinaryExpressions() {
var tree = new Parser("true+true").Parse();
CheckTree(tree, new object[] {
"binop", TerminalKind.Plus,
"binop", TokenKind.Plus,
"const", true,
"const", true,
});
@@ -28,9 +30,9 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandOperatorPrecedence() {
var tree = new Parser("1+2*3").Parse();
CheckTree(tree, new object[] {
"binop", TerminalKind.Plus,
"binop", TokenKind.Plus,
"const", 1,
"binop", TerminalKind.Mul,
"binop", TokenKind.Mul,
"const", 2,
"const", 3,
});
@@ -40,8 +42,8 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandOperatorPrecedence2() {
var tree = new Parser("1*2+3").Parse();
CheckTree(tree, new object[] {
"binop", TerminalKind.Plus,
"binop", TerminalKind.Mul,
"binop", TokenKind.Plus,
"binop", TokenKind.Mul,
"const", 1,
"const", 2,
"const", 3,
@@ -52,8 +54,8 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandOperatorPrecedence3() {
var tree = new Parser("not true or true").Parse();
CheckTree(tree, new object[] {
"binop", TerminalKind.Or,
"unop", TerminalKind.Not,
"binop", TokenKind.Or,
"unop", TokenKind.Not,
"const", true,
"const", true,
});
@@ -63,8 +65,8 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandOperatorPrecedence4() {
var tree = new Parser("not (true or true)").Parse();
CheckTree(tree, new object[] {
"unop", TerminalKind.Not,
"binop", TerminalKind.Or,
"unop", TokenKind.Not,
"binop", TokenKind.Or,
"const", true,
"const", true,
});
@@ -74,9 +76,9 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandParenthesis() {
var tree = new Parser("1*(2+3)").Parse();
CheckTree(tree, new object[] {
"binop", TerminalKind.Mul,
"binop", TokenKind.Mul,
"const", 1,
"binop", TerminalKind.Plus,
"binop", TokenKind.Plus,
"const", 2,
"const", 3,
});
@@ -86,13 +88,13 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldUnderstandComplexExpressions() {
var tree = new Parser("not 1 * (2 / 4 * 6 + (3))").Parse();
CheckTree(tree, new object[] {
"unop", TerminalKind.Not,
"binop", TerminalKind.Mul,
"unop", TokenKind.Not,
"binop", TokenKind.Mul,
"const", 1,
"binop", TerminalKind.Plus,
"binop", TerminalKind.Div,
"binop", TokenKind.Plus,
"binop", TokenKind.Div,
"const", 2,
"binop", TerminalKind.Mul,
"binop", TokenKind.Mul,
"const", 4,
"const", 6,
"const", 3,
@@ -103,7 +105,7 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
public void ParserShouldContainErrorExpressions() {
var tree = new Parser("1 + not 3").Parse();
CheckTree(tree, new object[] {
"binop", TerminalKind.Plus,
"binop", TokenKind.Plus,
"const", 1,
"error",
});

51
src/Orchard.Tests.Modules/SimpleScripting/TokenizerTests.cs
View File

@@ -1,5 +1,6 @@
using NUnit.Framework;
using Orchard.Widgets.SimpleScripting;
using Orchard.Widgets.SimpleScripting.Compiler;
namespace Orchard.Tests.Modules.SimpleScriptingTests {
[TestFixture]
@@ -7,70 +8,70 @@ namespace Orchard.Tests.Modules.SimpleScriptingTests {
[Test]
public void LexerShouldProcessSingleQuotedStringLiteral() {
TestStringLiteral(@"'toto'", @"toto", TerminalKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'to\'to'", @"to'to", TerminalKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'to\\to'", @"to\to", TerminalKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'to\ato'", @"to\ato", TerminalKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'toto'", @"toto", TokenKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'to\'to'", @"to'to", TokenKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'to\\to'", @"to\to", TokenKind.SingleQuotedStringLiteral);
TestStringLiteral(@"'to\ato'", @"to\ato", TokenKind.SingleQuotedStringLiteral);
}
[Test]
public void LexerShouldProcessStringLiteral() {
TestStringLiteral(@"""toto""", @"toto", TerminalKind.StringLiteral);
TestStringLiteral(@"""to\'to""", @"to'to", TerminalKind.StringLiteral);
TestStringLiteral(@"""to\\to""", @"to\to", TerminalKind.StringLiteral);
TestStringLiteral(@"""to\ato""", @"toato", TerminalKind.StringLiteral);
TestStringLiteral(@"""toto""", @"toto", TokenKind.StringLiteral);
TestStringLiteral(@"""to\'to""", @"to'to", TokenKind.StringLiteral);
TestStringLiteral(@"""to\\to""", @"to\to", TokenKind.StringLiteral);
TestStringLiteral(@"""to\ato""", @"toato", TokenKind.StringLiteral);
}
private void TestStringLiteral(string value, string expected, TerminalKind expectedTerminalKind) {
private void TestStringLiteral(string value, string expected, TokenKind expectedTokenKind) {
var lexer = new Tokenizer(value);
var token1 = lexer.NextToken();
Assert.That(token1.Kind, Is.EqualTo(expectedTerminalKind));
Assert.That(token1.Kind, Is.EqualTo(expectedTokenKind));
Assert.That(token1.Value, Is.EqualTo(expected));
var token2 = lexer.NextToken();
Assert.That(token2.Kind, Is.EqualTo(TerminalKind.Eof));
Assert.That(token2.Kind, Is.EqualTo(TokenKind.Eof));
}
[Test]
public void LexerShouldProcessReservedWords() {
TestReservedWord("true", true, TerminalKind.True);
TestReservedWord("false", false, TerminalKind.False);
TestReservedWord("not", null, TerminalKind.Not);
TestReservedWord("and", null, TerminalKind.And);
TestReservedWord("or", null, TerminalKind.Or);
TestReservedWord("true", true, TokenKind.True);
TestReservedWord("false", false, TokenKind.False);
TestReservedWord("not", null, TokenKind.Not);
TestReservedWord("and", null, TokenKind.And);
TestReservedWord("or", null, TokenKind.Or);
}
private void TestReservedWord(string expression, object value, TerminalKind expectedTerminalKind) {
private void TestReservedWord(string expression, object value, TokenKind expectedTokenKind) {
var lexer = new Tokenizer(expression);
var token1 = lexer.NextToken();
Assert.That(token1.Kind, Is.EqualTo(expectedTerminalKind));
Assert.That(token1.Kind, Is.EqualTo(expectedTokenKind));
Assert.That(token1.Value, Is.EqualTo(value));
var token2 = lexer.NextToken();
Assert.That(token2.Kind, Is.EqualTo(TerminalKind.Eof));
Assert.That(token2.Kind, Is.EqualTo(TokenKind.Eof));
}
[Test]
public void LexerShouldProcesSequenceOfTokens() {
CheckTokenSequence("true false", TerminalKind.True, TerminalKind.False);
CheckTokenSequence("true toto false", TerminalKind.True, TerminalKind.Identifier, TerminalKind.False);
CheckTokenSequence("true false", TokenKind.True, TokenKind.False);
CheckTokenSequence("true toto false", TokenKind.True, TokenKind.Identifier, TokenKind.False);
}
[Test]
public void LexerShouldProcesSequenceOfTokens2() {
CheckTokenSequence("1+2*3", TerminalKind.Integer, TerminalKind.Plus, TerminalKind.Integer, TerminalKind.Mul, TerminalKind.Integer);
CheckTokenSequence("1+2*3", TokenKind.Integer, TokenKind.Plus, TokenKind.Integer, TokenKind.Mul, TokenKind.Integer);
}
private void CheckTokenSequence(string expression, params TerminalKind[] terminalKinds) {
private void CheckTokenSequence(string expression, params TokenKind[] tokenKinds) {
var lexer = new Tokenizer(expression);
foreach (var kind in terminalKinds) {
foreach (var kind in tokenKinds) {
var token = lexer.NextToken();
Assert.That(token.Kind, Is.EqualTo(kind));
}
var token2 = lexer.NextToken();
Assert.That(token2.Kind, Is.EqualTo(TerminalKind.Eof));
Assert.That(token2.Kind, Is.EqualTo(TokenKind.Eof));
}
}
}

24
src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj
View File

@@ -75,19 +75,19 @@
<Compile Include="Services\RuleContext.cs" />
<Compile Include="Services\WidgetsService.cs" />
<Compile Include="Shapes.cs" />
<Compile Include="SimpleScripting\AstNode.cs" />
<Compile Include="SimpleScripting\BinaryAstNode.cs" />
<Compile Include="SimpleScripting\ConstantAstNode.cs" />
<Compile Include="SimpleScripting\ErrorAstNode.cs" />
<Compile Include="SimpleScripting\Lexer.cs" />
<Compile Include="SimpleScripting\Tokenizer.cs" />
<Compile Include="SimpleScripting\Parser.cs" />
<Compile Include="SimpleScripting\AbstractSyntaxTree.cs" />
<Compile Include="SimpleScripting\IAstNodeWithToken.cs" />
<Compile Include="SimpleScripting\Ast\AstNode.cs" />
<Compile Include="SimpleScripting\Ast\BinaryAstNode.cs" />
<Compile Include="SimpleScripting\Ast\ConstantAstNode.cs" />
<Compile Include="SimpleScripting\Ast\ErrorAstNode.cs" />
<Compile Include="SimpleScripting\Compiler\Lexer.cs" />
<Compile Include="SimpleScripting\Compiler\Tokenizer.cs" />
<Compile Include="SimpleScripting\Compiler\Parser.cs" />
<Compile Include="SimpleScripting\Ast\AbstractSyntaxTree.cs" />
<Compile Include="SimpleScripting\Ast\IAstNodeWithToken.cs" />
<Compile Include="SimpleScripting\ScriptingManager.cs" />
<Compile Include="SimpleScripting\Terminal.cs" />
<Compile Include="SimpleScripting\TerminalKind.cs" />
<Compile Include="SimpleScripting\UnaryAstNode.cs" />
<Compile Include="SimpleScripting\Compiler\Token.cs" />
<Compile Include="SimpleScripting\Compiler\TokenKind.cs" />
<Compile Include="SimpleScripting\Ast\UnaryAstNode.cs" />
<Compile Include="ViewModels\WidgetsIndexViewModel.cs" />
</ItemGroup>
<ItemGroup>

2
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/AbstractSyntaxTree.cs → src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/AbstractSyntaxTree.cs
View File

@@ -1,4 +1,4 @@
namespace Orchard.Widgets.SimpleScripting {
namespace Orchard.Widgets.SimpleScripting.Ast {
public class AbstractSyntaxTree {
public AstNode Root { get; set; }
}

4
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/AstNode.cs → src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/AstNode.cs
View File

@@ -2,7 +2,7 @@
using System.Linq;
using System.Text;
namespace Orchard.Widgets.SimpleScripting {
namespace Orchard.Widgets.SimpleScripting.Ast {
public class AstNode {
public virtual IEnumerable<AstNode> Children {
get {
@@ -16,7 +16,7 @@ namespace Orchard.Widgets.SimpleScripting {
var ewt = (this as IAstNodeWithToken);
if (ewt != null) {
sb.Append(" - ");
sb.Append(ewt.Terminal);
sb.Append(ewt.Token);
}
return sb.ToString();
}

17
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/BinaryAstNode.cs → src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/BinaryAstNode.cs
View File

@@ -1,23 +1,24 @@
using System.Collections.Generic;
using Orchard.Widgets.SimpleScripting.Compiler;
namespace Orchard.Widgets.SimpleScripting {
namespace Orchard.Widgets.SimpleScripting.Ast {
public class BinaryAstNode : AstNode, IAstNodeWithToken {
private readonly AstNode _left;
private readonly Terminal _terminal;
private readonly Token _token;
private readonly AstNode _right;
public BinaryAstNode(AstNode left, Terminal terminal, AstNode right) {
public BinaryAstNode(AstNode left, Token token, AstNode right) {
_left = left;
_terminal = terminal;
_token = token;
_right = right;
}
public Terminal Terminal {
get { return _terminal; }
public Token Token {
get { return _token; }
}
public Terminal Operator {
get { return _terminal; }
public Token Operator {
get { return _token; }
}
public override IEnumerable<AstNode> Children {

17
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/ConstantAstNode.cs Normal file
View File

@@ -0,0 +1,17 @@
using Orchard.Widgets.SimpleScripting.Compiler;
namespace Orchard.Widgets.SimpleScripting.Ast {
public class ConstantAstNode : AstNode, IAstNodeWithToken {
private readonly Token _token;
public ConstantAstNode(Token token) {
_token = token;
}
public Token Token {
get { return _token; }
}
public object Value { get { return _token.Value; } }
}
}

13
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ErrorAstNode.cs → src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/ErrorAstNode.cs
View File

@@ -1,17 +1,18 @@
using System;
using Orchard.Widgets.SimpleScripting.Compiler;
namespace Orchard.Widgets.SimpleScripting {
namespace Orchard.Widgets.SimpleScripting.Ast {
public class ErrorAstNode : AstNode, IAstNodeWithToken {
private readonly Terminal _terminal;
private readonly Token _token;
private readonly string _message;
public ErrorAstNode(Terminal terminal, string message) {
_terminal = terminal;
public ErrorAstNode(Token token, string message) {
_token = token;
_message = message;
}
public Terminal Terminal {
get { return _terminal; }
public Token Token {
get { return _token; }
}
public string Message {

7
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/IAstNodeWithToken.cs Normal file
View File

@@ -0,0 +1,7 @@
using Orchard.Widgets.SimpleScripting.Compiler;
namespace Orchard.Widgets.SimpleScripting.Ast {
public interface IAstNodeWithToken {
Token Token { get; }
}
}

29
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Ast/UnaryAstNode.cs Normal file
View File

@@ -0,0 +1,29 @@
using System.Collections.Generic;
using Orchard.Widgets.SimpleScripting.Compiler;
namespace Orchard.Widgets.SimpleScripting.Ast {
public class UnaryAstNode : AstNode, IAstNodeWithToken {
private readonly AstNode _expr;
private readonly Token _token;
public UnaryAstNode(AstNode expr, Token token) {
_expr = expr;
_token = token;
}
public Token Token {
get { return _token; }
}
public Token Operator {
get { return _token; }
}
public override IEnumerable<AstNode> Children {
get {
yield return _expr;
}
}
}
}

6
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Lexer.cs → src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/Lexer.cs
View File

@@ -1,16 +1,16 @@
using System.Collections.Generic;
namespace Orchard.Widgets.SimpleScripting {
namespace Orchard.Widgets.SimpleScripting.Compiler {
public class Lexer {
private readonly Tokenizer _tokenizer;
private readonly List<Terminal> _tokens= new List<Terminal>();
private readonly List<Token> _tokens= new List<Token>();
private int _tokenIndex;
public Lexer(Tokenizer tokenizer) {
_tokenizer = tokenizer;
}
public Terminal Token() {
public Token Token() {
if (_tokenIndex == _tokens.Count) {
_tokens.Add(_tokenizer.NextToken());
}

56
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Parser.cs → src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/Parser.cs
View File

@@ -1,7 +1,7 @@
using System;
using System.Collections.Generic;
using System.Collections.Generic;
using Orchard.Widgets.SimpleScripting.Ast;
namespace Orchard.Widgets.SimpleScripting {
namespace Orchard.Widgets.SimpleScripting.Compiler {
public class Parser {
private readonly string _expression;
private readonly Lexer _lexer;
@@ -28,7 +28,7 @@ namespace Orchard.Widgets.SimpleScripting {
private AstNode ParseKeywordOrExpression() {
var expr = ParseKeywordAndExpression();
var token = IsMatch(TerminalKind.Or);
var token = IsMatch(TokenKind.Or);
if (token != null)
{
var right = ParseKeywordOrExpression();
@@ -42,7 +42,7 @@ namespace Orchard.Widgets.SimpleScripting {
private AstNode ParseKeywordAndExpression() {
var expr = ParseKeywordNotExpression();
var token = IsMatch(TerminalKind.And);
var token = IsMatch(TokenKind.And);
if (token != null) {
var right = ParseKeywordAndExpression();
@@ -53,7 +53,7 @@ namespace Orchard.Widgets.SimpleScripting {
}
private AstNode ParseKeywordNotExpression() {
var token = IsMatch(TerminalKind.Not);
var token = IsMatch(TokenKind.Not);
if (token != null) {
var expr = ParseKeywordNotExpression();
@@ -66,15 +66,15 @@ namespace Orchard.Widgets.SimpleScripting {
private AstNode ParseRelationalExpression() {
var expr = ParseAdditiveExpression();
//TODO
//var Terminal = IsMatch(TokenKind.Not);
//if (Terminal != null) {
//var Token = IsMatch(TokenKind.Not);
//if (Token != null) {
return expr;
}
private AstNode ParseAdditiveExpression() {
var expr = ParseMultiplicativeExpression();
var token = IsMatch(TerminalKind.Plus, TerminalKind.Minus);
var token = IsMatch(TokenKind.Plus, TokenKind.Minus);
if (token != null) {
var right = ParseAdditiveExpression();
@@ -87,7 +87,7 @@ namespace Orchard.Widgets.SimpleScripting {
private AstNode ParseMultiplicativeExpression() {
var expr = ParseUnaryExpression();
var token = IsMatch(TerminalKind.Mul, TerminalKind.Div);
var token = IsMatch(TokenKind.Mul, TokenKind.Div);
if (token != null) {
var right = ParseMultiplicativeExpression();
@@ -105,47 +105,47 @@ namespace Orchard.Widgets.SimpleScripting {
private AstNode ParsePrimaryExpression() {
var token = _lexer.Token();
switch(_lexer.Token().Kind) {
case TerminalKind.True:
case TerminalKind.False:
case TerminalKind.SingleQuotedStringLiteral:
case TerminalKind.StringLiteral:
case TerminalKind.Integer:
case TokenKind.True:
case TokenKind.False:
case TokenKind.SingleQuotedStringLiteral:
case TokenKind.StringLiteral:
case TokenKind.Integer:
return ProduceConstant(token);
case TerminalKind.OpenParen:
case TokenKind.OpenParen:
return ParseParenthesizedExpression();
default:
return ProduceError(token);
}
}
private AstNode ProduceConstant(Terminal terminal) {
private AstNode ProduceConstant(Token token) {
_lexer.NextToken();
return new ConstantAstNode(terminal);
return new ConstantAstNode(token);
}
private AstNode ProduceError(Terminal terminal) {
private AstNode ProduceError(Token token) {
_lexer.NextToken();
return new ErrorAstNode(terminal,
string.Format("Unexptected Terminal in primary expression ({0})", terminal));
return new ErrorAstNode(token,
string.Format("Unexptected Token in primary expression ({0})", token));
}
private AstNode ParseParenthesizedExpression() {
Match(TerminalKind.OpenParen);
Match(TokenKind.OpenParen);
var expr = ParseExpression();
Match(TerminalKind.CloseParen);
Match(TokenKind.CloseParen);
return expr;
}
private void Match(TerminalKind kind) {
private void Match(TokenKind kind) {
var token = _lexer.Token();
if (token.Kind == kind) {
_lexer.NextToken();
return;
}
AddError(token, string.Format("Expected Terminal {0}", kind));
AddError(token, string.Format("Expected Token {0}", kind));
}
private Terminal IsMatch(TerminalKind kind) {
private Token IsMatch(TokenKind kind) {
var token = _lexer.Token();
if (token.Kind == kind) {
_lexer.NextToken();
@@ -154,7 +154,7 @@ namespace Orchard.Widgets.SimpleScripting {
return null;
}
private Terminal IsMatch(TerminalKind kind, TerminalKind kind2) {
private Token IsMatch(TokenKind kind, TokenKind kind2) {
var token = _lexer.Token();
if (token.Kind == kind || token.Kind == kind2) {
_lexer.NextToken();
@@ -163,7 +163,7 @@ namespace Orchard.Widgets.SimpleScripting {
return null;
}
private void AddError(Terminal terminal, string message) {
private void AddError(Token token, string message) {
_errors.Add(message);
}
}

6
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Terminal.cs → src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/Token.cs
View File

@@ -1,8 +1,8 @@
using System;
namespace Orchard.Widgets.SimpleScripting {
public class Terminal {
public TerminalKind Kind { get; set; }
namespace Orchard.Widgets.SimpleScripting.Compiler {
public class Token {
public TokenKind Kind { get; set; }
public int Position { get; set; }
public object Value { get; set; }

4
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/TerminalKind.cs → src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/TokenKind.cs
View File

@@ -1,5 +1,5 @@
namespace Orchard.Widgets.SimpleScripting {
public enum TerminalKind {
namespace Orchard.Widgets.SimpleScripting.Compiler {
public enum TokenKind {
Eof,
OpenParen,
CloseParen,

60
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Tokenizer.cs → src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/Compiler/Tokenizer.cs
View File

@@ -1,7 +1,7 @@
using System;
using System.Text;
namespace Orchard.Widgets.SimpleScripting {
namespace Orchard.Widgets.SimpleScripting.Compiler {
public class Tokenizer {
private readonly string _expression;
private readonly StringBuilder _stringBuilder;
@@ -13,9 +13,9 @@ namespace Orchard.Widgets.SimpleScripting {
_stringBuilder = new StringBuilder();
}
public Terminal NextToken() {
public Token NextToken() {
if (Eof())
return CreateToken(TerminalKind.Eof);
return CreateToken(TokenKind.Eof);
LexAgain:
_startTokenIndex = _index;
@@ -23,22 +23,22 @@ namespace Orchard.Widgets.SimpleScripting {
switch (ch) {
case '(':
NextCharacter();
return CreateToken(TerminalKind.OpenParen);
return CreateToken(TokenKind.OpenParen);
case ')':
NextCharacter();
return CreateToken(TerminalKind.CloseParen);
return CreateToken(TokenKind.CloseParen);
case '+':
NextCharacter();
return CreateToken(TerminalKind.Plus);
return CreateToken(TokenKind.Plus);
case '-':
NextCharacter();
return CreateToken(TerminalKind.Minus);
return CreateToken(TokenKind.Minus);
case '*':
NextCharacter();
return CreateToken(TerminalKind.Mul);
return CreateToken(TokenKind.Mul);
case '/':
NextCharacter();
return CreateToken(TerminalKind.Div);
return CreateToken(TokenKind.Div);
case '"':
return LexStringLiteral();
case '\'':
@@ -56,10 +56,10 @@ namespace Orchard.Widgets.SimpleScripting {
goto LexAgain;
}
return CreateToken(TerminalKind.Invalid, "Unrecognized character");
return CreateToken(TokenKind.Invalid, "Unrecognized character");
}
private Terminal LexIdentifierOrKeyword() {
private Token LexIdentifierOrKeyword() {
_stringBuilder.Clear();
_stringBuilder.Append(Character());
@@ -75,7 +75,7 @@ namespace Orchard.Widgets.SimpleScripting {
}
}
private Terminal LexInteger() {
private Token LexInteger() {
_stringBuilder.Clear();
_stringBuilder.Append(Character());
@@ -86,25 +86,25 @@ namespace Orchard.Widgets.SimpleScripting {
_stringBuilder.Append(Character());
}
else {
return CreateToken(TerminalKind.Integer, Int32.Parse(_stringBuilder.ToString()));
return CreateToken(TokenKind.Integer, Int32.Parse(_stringBuilder.ToString()));
}
}
}
private Terminal CreateIdentiferOrKeyword(string identifier) {
private Token CreateIdentiferOrKeyword(string identifier) {
switch (identifier) {
case "true":
return CreateToken(TerminalKind.True, true);
return CreateToken(TokenKind.True, true);
case "false":
return CreateToken(TerminalKind.False, false);
return CreateToken(TokenKind.False, false);
case "or":
return CreateToken(TerminalKind.Or, null);
return CreateToken(TokenKind.Or, null);
case "and":
return CreateToken(TerminalKind.And, null);
return CreateToken(TokenKind.And, null);
case "not":
return CreateToken(TerminalKind.Not, null);
return CreateToken(TokenKind.Not, null);
default:
return CreateToken(TerminalKind.Identifier, identifier);
return CreateToken(TokenKind.Identifier, identifier);
}
}
@@ -123,26 +123,26 @@ namespace Orchard.Widgets.SimpleScripting {
return ch >= '0' && ch <= '9';
}
private Terminal LexSingleQuotedStringLiteral() {
private Token LexSingleQuotedStringLiteral() {
_stringBuilder.Clear();
while (true) {
NextCharacter();
if (Eof())
return CreateToken(TerminalKind.Invalid, "Unterminated string literal");
return CreateToken(TokenKind.Invalid, "Unterminated string literal");
// Termination
if (Character() == '\'') {
NextCharacter();
return CreateToken(TerminalKind.SingleQuotedStringLiteral, _stringBuilder.ToString());
return CreateToken(TokenKind.SingleQuotedStringLiteral, _stringBuilder.ToString());
}
// backslash notation
else if (Character() == '\\') {
NextCharacter();
if (Eof())
return CreateToken(TerminalKind.Invalid, "Unterminated string literal");
return CreateToken(TokenKind.Invalid, "Unterminated string literal");
if (Character() == '\\') {
_stringBuilder.Append('\\');
@@ -162,26 +162,26 @@ namespace Orchard.Widgets.SimpleScripting {
}
}
private Terminal LexStringLiteral() {
private Token LexStringLiteral() {
_stringBuilder.Clear();
while (true) {
NextCharacter();
if (Eof())
return CreateToken(TerminalKind.Invalid, "Unterminated string literal");
return CreateToken(TokenKind.Invalid, "Unterminated string literal");
// Termination
if (Character() == '"') {
NextCharacter();
return CreateToken(TerminalKind.StringLiteral, _stringBuilder.ToString());
return CreateToken(TokenKind.StringLiteral, _stringBuilder.ToString());
}
// backslash notation
else if (Character() == '\\') {
NextCharacter();
if (Eof())
return CreateToken(TerminalKind.Invalid, "Unterminated string literal");
return CreateToken(TokenKind.Invalid, "Unterminated string literal");
_stringBuilder.Append(Character());
}
@@ -200,8 +200,8 @@ namespace Orchard.Widgets.SimpleScripting {
return _expression[_index];
}
private Terminal CreateToken(TerminalKind kind, object value = null) {
return new Terminal {
private Token CreateToken(TokenKind kind, object value = null) {
return new Token {
Kind = kind,
Position = _startTokenIndex,
Value = value

15
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ConstantAstNode.cs
View File

@@ -1,15 +0,0 @@
namespace Orchard.Widgets.SimpleScripting {
public class ConstantAstNode : AstNode, IAstNodeWithToken {
private readonly Terminal _terminal;
public ConstantAstNode(Terminal terminal) {
_terminal = terminal;
}
public Terminal Terminal {
get { return _terminal; }
}
public object Value { get { return _terminal.Value; } }
}
}

5
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/IAstNodeWithToken.cs
View File

@@ -1,5 +0,0 @@
namespace Orchard.Widgets.SimpleScripting {
public interface IAstNodeWithToken {
Terminal Terminal { get; }
}
}

2
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/ScriptingManager.cs
View File

@@ -3,6 +3,8 @@ using System.Collections.Generic;
using System.Linq;
using Orchard.Caching;
using Orchard.Widgets.Services;
using Orchard.Widgets.SimpleScripting.Ast;
using Orchard.Widgets.SimpleScripting.Compiler;
namespace Orchard.Widgets.SimpleScripting {
public interface IScriptingEngine : IDependency {

28
src/Orchard.Web/Modules/Orchard.Widgets/SimpleScripting/UnaryAstNode.cs
View File

@@ -1,28 +0,0 @@
using System.Collections.Generic;
namespace Orchard.Widgets.SimpleScripting {
public class UnaryAstNode : AstNode, IAstNodeWithToken {
private readonly AstNode _expr;
private readonly Terminal _terminal;
public UnaryAstNode(AstNode expr, Terminal terminal) {
_expr = expr;
_terminal = terminal;
}
public Terminal Terminal {
get { return _terminal; }
}
public Terminal Operator {
get { return _terminal; }
}
public override IEnumerable<AstNode> Children {
get {
yield return _expr;
}
}
}
}