/// <summary>
/// Performs the code parsing, asynchronously.
/// </summary>
/// <returns></returns>
public async Task<CompilationResult> DoAnalysisAsync(string outputFilePath)
{
string programName = null;
try
{
await Task.Factory.StartNew(StartAnalysis);
}
catch (CompilationException ex)
{
int column = _lexical.Position.Column - _token.Lexeme.Length;
if (_position.HasValue)
{
return new CompilationResult { Error = new CompilationError(_position.Value, ex.Message) };
}
return new CompilationResult { Error = new CompilationError(_lexical.Position, ex.Message) };
}
finally
{
_expressionAnalyzer = null;
programName = _symbolTable.GetProgramName();
_symbolTable.Clear();
_funcInfo = null;
_level = 0;
}
await _codeGenerator.SaveToFileAsync(outputFilePath);
return new CompilationResult { Error = null, ProgramName = programName };
}
public void TestEquality(Expression <Func <User, bool> > exp, string expectedMark)
{
var result = new ExpressionAnalyzer(exp).GetAnalysisResult();
Assert.Equal(string.Format("[TAB].Age {0} @P0", expectedMark), string.Join(" ", result.StackList));
Assert.Equal(1, result.ParamList["P0"]);
}
/// <summary>
/// Returns an async caching strategy that cached individual items returned from the method by their specified key. The cache source type, method name, and item key will be used for the cache key and the method will be used as the retrieval mechanism for items not found in the cache
/// </summary>
public static BulkCacheStrategyAsync <TKey, TResult> Method <T, TKey, TResult>(this Cache <T> cache, Expression <Func <T, Task <ICollection <KeyValuePair <TKey, TResult> > > > > method)
{
ExpressionAnalyzer analyzer = new ExpressionAnalyzer();
return(analyzer.CreateAsyncBulkCacheStrategy(cache, method)
.RetrieveUsingMethod());
}
private ItemType AnalyzeExpressionType()
{
_expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
AnalyzeExpression();
var type = ItemType.None;
try
{
var tokens = _expressionAnalyzer.Analyze(out type);
GenerateCodeForExpression(tokens);
}
catch (ExpressionException ex)
{
throw new CompilationException(string.Format(GenericErrorMessage, _lexical.Position.Line,
_lexical.Position.Column, ex.Message));
}
catch (Exception ex)
{
//Todo: log error here.
throw new CompilationException(ex.Message);
}
return(type);
}
public Analyzer(List <Statement> program)
{
var environment = new Environment();
var expressionAnalyzer = new ExpressionAnalyzer(environment);
statementAnalyzer = new StatementAnalyzer(program, expressionAnalyzer, environment);
}
/// <summary>
/// Returns an async caching strategy for the specified method. The cache source type and method name will be used for the cache key and the method will be used as the retrieval mechanism if the item is not found in the cache
/// </summary>
public static CacheStrategyAsync <TResult> Method <T, TResult>(this Cache <T> cache, Expression <Func <T, Task <TResult> > > method)
{
ExpressionAnalyzer analyzer = new ExpressionAnalyzer();
return(analyzer.CreateAsyncCacheStrategy(cache, method)
.RetrieveUsingMethod());
}
public void TestOrderBy()
{
Expression <Func <User, object> > exp = x => x.Name;
var result = new ExpressionAnalyzer(exp).GetAnalysisResult();
Assert.Equal("[TAB].Name", string.Join(" ", result.StackList));
}
public void BOOLEAN_EXPRESSION_TEST()
{
var expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
var output = string.Empty;
var expectedOutput = "fnaogou";
var token = new Token {
Lexeme = "nao", Symbol = Symbols.SNao
};
var type = ItemType.None;
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "f", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "ou", Symbol = Symbols.SOu
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "g", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
expressionAnalyzer.Analyze(out type);
output = expressionAnalyzer.ToString();
Assert.AreEqual(type, ItemType.Boolean);
Assert.AreEqual(output, expectedOutput);
}
public void TestTrue()
{
Expression <Func <User, bool> > exp = x => x.Enabled == true;
var result = new ExpressionAnalyzer(exp).GetAnalysisResult();
Assert.Equal("[TAB].Enabled = @P0", string.Join(" ", result.StackList));
Assert.Equal("1", result.ParamList["P0"]);
}
public void TestNull()
{
Expression <Func <User, bool> > exp = x => x.Name == null;
var result = new ExpressionAnalyzer(exp).GetAnalysisResult();
Assert.Equal("[TAB].Name IS NULL", string.Join(" ", result.StackList));
Assert.Equal(0, result.ParamList.Count);
}
public void INTEGER_BOOLEAN_EXPRESSION_TEST()
{
var expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
var output = string.Empty;
var expectedOutput = "ab+cd-<";
var token = new Token {
Lexeme = "(", Symbol = Symbols.SAbreParenteses
};
var type = ItemType.None;
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "a", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "+", Symbol = Symbols.SMais
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "b", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = ")", Symbol = Symbols.SFechaParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "<", Symbol = Symbols.SMenorIg
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "(", Symbol = Symbols.SAbreParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "c", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "-", Symbol = Symbols.SMenos
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "d", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = ")", Symbol = Symbols.SFechaParenteses
};
expressionAnalyzer.Add(token);
expressionAnalyzer.Analyze(out type);
output = expressionAnalyzer.ToString();
Assert.AreEqual(type, ItemType.Boolean);
Assert.AreEqual(output, expectedOutput);
}
public void TestLikeEndWith()
{
Expression <Func <User, bool> > exp = x => x.Name.EndsWith("Hello");
var result = new ExpressionAnalyzer(exp).GetAnalysisResult();
Assert.Equal("[TAB].Name LIKE '%' + @P0", string.Join(" ", result.StackList));
Assert.Equal("Hello", result.ParamList["P0"]);
}
public void TestLogicNot()
{
Expression <Func <User, bool> > exp = x => !(x.Name == "Test");
var result = new ExpressionAnalyzer(exp).GetAnalysisResult();
Assert.Equal("NOT ( [TAB].Name = @P0 )", string.Join(" ", result.StackList));
Assert.Equal("Test", result.ParamList["P0"]);
}
public void TestLogicAnd()
{
Expression <Func <User, bool> > exp = x => x.Name == "Test" && x.Age == 1;
var result = new ExpressionAnalyzer(exp).GetAnalysisResult();
Assert.Equal("( [TAB].Name = @P0 ) AND ( [TAB].Age = @P1 )", string.Join(" ", result.StackList));
Assert.Equal("Test", result.ParamList["P0"]);
Assert.Equal(1, result.ParamList["P1"]);
}
public void INTEGER_UNARY_EXPRESSION_TEST()
{
var expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
var output = string.Empty;
var expectedOutput = "a-cd-e*+";
var token = new Token {
Lexeme = "-", Symbol = Symbols.SMaisUnario
};
var type = ItemType.None;
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "a", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "+", Symbol = Symbols.SMais
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "(", Symbol = Symbols.SAbreParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "c", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "-", Symbol = Symbols.SMenos
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "d", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = ")", Symbol = Symbols.SFechaParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "*", Symbol = Symbols.SMult
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "e", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
expressionAnalyzer.Analyze(out type);
output = expressionAnalyzer.ToString();
Assert.AreEqual(type, ItemType.Integer);
Assert.AreEqual(output, expectedOutput);
}
public void TestLogic()
{
Expression <Func <User, bool> > exp = x => (x.Age > 0 || x.Id == 1) && x.Name.Contains("Test");
var result = new ExpressionAnalyzer(exp).GetAnalysisResult();
Assert.Equal("( ( [TAB].Age > @P0 ) OR ( [TAB].Id = @P1 ) ) AND ( [TAB].Name LIKE '%' + @P2 + '%' )", string.Join(" ", result.StackList));
Assert.Equal(0, result.ParamList["P0"]);
Assert.Equal(1, result.ParamList["P1"]);
Assert.Equal("Test", result.ParamList["P2"]);
}
public void INTEGER_EXPRESSION_TEST()
{
var expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
var output = string.Empty;
var expectedOutput = "ab+cd*+e+";
var token = new Token {
Lexeme = "a", Symbol = Symbols.SIdentificador
};
var type = ItemType.None;
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "+", Symbol = Symbols.SMais
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "b", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "+", Symbol = Symbols.SMais
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "c", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "*", Symbol = Symbols.SMult
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "d", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "+", Symbol = Symbols.SMais
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "e", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
expressionAnalyzer.Analyze(out type);
output = expressionAnalyzer.ToString();
Assert.AreEqual(type, ItemType.Integer);
Assert.AreEqual(output, expectedOutput);
}
public object GetFirstParameterValue <T>(T source, Expression <Action> expression)
{
var invocationCall = expression.Body as InvocationExpression;
ExpressionAnalyzer analyzer = new ExpressionAnalyzer();
bool dontIgnore = analyzer.TryProcessParameter(source, invocationCall.Arguments.First(), checkForParameterDoNotCache: true, parameterValue: out object parameterValue);
if (!dontIgnore)
{
Assert.Fail("Should not have been ignore");
}
return(parameterValue);
}
public string Parse()
{
Guard.Argument(_expression).NotNull();
var analyzer = new ExpressionAnalyzer();
var context = analyzer.Analyze(_expression);
StartQuery(context, _queryString);
QueryParametrs(context, _queryString);
_queryString.Append("{");
StartQueryBody(context, _queryString);
EndQueryBody(context, _queryString);
_queryString.Append("}");
return(_queryString.ToString());
}
public void Property <T>(string property_name, Expression <Func <T> > getter)
{
log.Trace(string.Format("Adding property {0} of type {1}", property_name, typeof(T)));
var property = new DelegatePropertyDescriptor(property_name, this, typeof(T));
var compiled_getter = getter.Compile();
property.Getter = x => compiled_getter();
// Analyse getter for dependencies
var tree = ExpressionAnalyzer.Analyze(getter);
property.AddDependencies(tree, () => NotifyPropertyChanged(property_name));
AddProperty(property);
}
public void CorrectlyFindsDependencies()
{
// Arrange
var analyzer = new ExpressionAnalyzer();
var sourceId = Guid.NewGuid();
var result = new Result <int>(sourceId);
Expression <Func <int> > expr = () => result.Get();
// Act
analyzer.Visit(expr);
// Assert
Assert.That(analyzer.IsValid, Is.True);
Assert.That(analyzer.Dependencies.Count, Is.EqualTo(1));
Assert.That(analyzer.Dependencies[0], Is.EqualTo(sourceId));
}
public void Dependency <T>(string native_property, Expression <Func <T> > dependencies)
{
var property_info = GetType().GetProperty(native_property);
var property = new DelegatePropertyDescriptor(native_property, this, typeof(T));
property.Getter = x => property_info.GetValue(this, null);
if (property_info.CanWrite)
{
property.Setter = (x, v) => property_info.SetValue(this, v, null);
}
// Analyse getter for dependencies
var tree = ExpressionAnalyzer.Analyze(dependencies);
property.AddDependencies(tree, () => NotifyPropertyChanged(native_property));
AddProperty(property);
}
static void Main()
{
Console.Write("Enter an expression to evaluate: ");
string expression = Console.ReadLine();
bool isBalanced = ExpressionAnalyzer.IsBalanced(expression);
if (!isBalanced)
{
Console.WriteLine("Your expression is not balanced (contains misnesting brackets).");
}
string[] tokens = ExpressionAnalyzer.Parse(expression);
string[] rpnTokens = ExpressionAnalyzer.TranslateInReversePolishNotation(tokens);
double value = RpnExpressionProcessor.Evaluate(rpnTokens);
Console.WriteLine("Your expression has been evaluated to {0:N4}.", value);
}
public void INTEGER_CONSTS_ONLY_TEST()
{
var expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
var output = string.Empty;
var expectedOutput = "32-45*+";
var token = new Token {
Lexeme = "3", Symbol = Symbols.SNumero
};
var type = ItemType.None;
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "-", Symbol = Symbols.SMenos
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "2", Symbol = Symbols.SNumero
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "+", Symbol = Symbols.SMais
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "4", Symbol = Symbols.SNumero
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "*", Symbol = Symbols.SMult
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "5", Symbol = Symbols.SNumero
};
expressionAnalyzer.Add(token);
expressionAnalyzer.Analyze(out type);
output = expressionAnalyzer.ToString();
Assert.AreEqual(type, ItemType.Integer);
Assert.AreEqual(output, expectedOutput);
}
public void BOOLEAN_EXPRESSION_TEST()
{
var expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
var output = string.Empty;
var expectedOutput = "fnaogou";
var token = new Token { Lexeme = "nao", Symbol = Symbols.SNao };
var type = ItemType.None;
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "f", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "ou", Symbol = Symbols.SOu };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "g", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
expressionAnalyzer.Analyze(out type);
output = expressionAnalyzer.ToString();
Assert.AreEqual(type, ItemType.Boolean);
Assert.AreEqual(output, expectedOutput);
}
/// <summary>
/// Performs the code parsing, asynchronously.
/// </summary>
/// <returns></returns>
public async Task <CompilationResult> DoAnalysisAsync(string outputFilePath)
{
string programName = null;
try
{
await Task.Factory.StartNew(StartAnalysis);
}
catch (CompilationException ex)
{
int column = _lexical.Position.Column - _token.Lexeme.Length;
if (_position.HasValue)
{
return(new CompilationResult {
Error = new CompilationError(_position.Value, ex.Message)
});
}
return(new CompilationResult {
Error = new CompilationError(_lexical.Position, ex.Message)
});
}
finally
{
_expressionAnalyzer = null;
programName = _symbolTable.GetProgramName();
_symbolTable.Clear();
_funcInfo = null;
_level = 0;
}
await _codeGenerator.SaveToFileAsync(outputFilePath);
return(new CompilationResult {
Error = null, ProgramName = programName
});
}
public IReactiveCollection <T> Collection <T>(string property_name, Expression <Func <IEnumerable <T> > > items)
{
log.Trace(string.Format("Adding collection property {0} of element type {1}", property_name, typeof(T)));
// Create reactive collection
var reactive_collection = new ReactiveCollection <T>();
// Create property
var property = new DelegatePropertyDescriptor(property_name, this, typeof(ObservableCollection <ViewModelBase>));
property.Getter = x => reactive_collection.WrappedCollection;
// Analyse items for dependencies
var tree = ExpressionAnalyzer.Analyze(items);
// Create and attach a collection node to the tree
var property_node = tree.GetPropertyNode(property_name);
var collection_node = new CollectionNode <T>(property_node, reactive_collection);
property_node.Children.Add(collection_node);
// Subscribe to events
property.AddDependencies(tree, () => NotifyPropertyChanged(property_name));
AddProperty(property);
return(reactive_collection);
}
public DependencyMethod <T> OnChanged <TResult>(Expression <Func <T, TResult> > property_accessor)
{
// Build property access tree from expression
PropertyAccessTree property_access_tree = ExpressionAnalyzer.Analyze(property_accessor);
if (!property_access_tree.DoesEntireTreeSupportINotifyPropertyChangedAndChanging())
{
throw new ArgumentException("All objects must implement INotifyPropertyChanged and INotifyPropertyChanging");
}
if (property_change_subscribers == null)
{
property_change_subscribers = new List <PropertyAccessTreeSubscriber <DependencyMethod <T> > >();
}
// Build subscription tree from property access tree
log.Trace("Creating subscription tree");
var subscriber = property_access_tree.CreateSubscriptionTree <DependencyMethod <T> >(OnAnyPropertyInSubscriptionChanges);
subscriber.DumpToLog();
property_change_subscribers.Add(subscriber);
return(this);
}
public void INTEGER_BOOLEAN_EXPRESSION_COMPLEX_TEST()
{
var expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
var output = string.Empty;
var expectedOutput = "a-badivab-**<nao";
var token = new Token { Lexeme = "nao", Symbol = Symbols.SNao };
var type = ItemType.None;
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "(", Symbol = Symbols.SAbreParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "(", Symbol = Symbols.SAbreParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "-", Symbol = Symbols.SMenosUnario };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "a", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = ")", Symbol = Symbols.SFechaParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "<", Symbol = Symbols.SMenor };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "(", Symbol = Symbols.SAbreParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "(", Symbol = Symbols.SAbreParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "b", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "div", Symbol = Symbols.SDiv };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "a", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = ")", Symbol = Symbols.SFechaParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "*", Symbol = Symbols.SMult };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "(", Symbol = Symbols.SAbreParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "a", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "*", Symbol = Symbols.SMult };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "(", Symbol = Symbols.SAbreParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "-", Symbol = Symbols.SMenosUnario };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "b", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = ")", Symbol = Symbols.SFechaParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = ")", Symbol = Symbols.SFechaParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = ")", Symbol = Symbols.SFechaParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = ")", Symbol = Symbols.SFechaParenteses };
expressionAnalyzer.Add(token);
expressionAnalyzer.Analyze(out type);
output = expressionAnalyzer.ToString();
Assert.AreEqual(type, ItemType.Boolean);
Assert.AreEqual(output, expectedOutput);
}
public void INTEGER_UNARY_EXPRESSION_TEST()
{
var expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
var output = string.Empty;
var expectedOutput = "a-cd-e*+";
var token = new Token { Lexeme = "-", Symbol = Symbols.SMaisUnario };
var type = ItemType.None;
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "a", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "+", Symbol = Symbols.SMais };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "(", Symbol = Symbols.SAbreParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "c", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "-", Symbol = Symbols.SMenos };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "d", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = ")", Symbol = Symbols.SFechaParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "*", Symbol = Symbols.SMult };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "e", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
expressionAnalyzer.Analyze(out type);
output = expressionAnalyzer.ToString();
Assert.AreEqual(type, ItemType.Integer);
Assert.AreEqual(output, expectedOutput);
}
public void INTEGER_EXPRESSION_TEST()
{
var expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
var output = string.Empty;
var expectedOutput = "ab+cd*+e+";
var token = new Token { Lexeme = "a", Symbol = Symbols.SIdentificador };
var type = ItemType.None;
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "+", Symbol = Symbols.SMais };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "b", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "+", Symbol = Symbols.SMais };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "c", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "*", Symbol = Symbols.SMult };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "d", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "+", Symbol = Symbols.SMais };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "e", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
expressionAnalyzer.Analyze(out type);
output = expressionAnalyzer.ToString();
Assert.AreEqual(type, ItemType.Integer);
Assert.AreEqual(output, expectedOutput);
}
public void INTEGER_CONSTS_ONLY_TEST()
{
var expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
var output = string.Empty;
var expectedOutput = "32-45*+";
var token = new Token { Lexeme = "3", Symbol = Symbols.SNumero };
var type = ItemType.None;
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "-", Symbol = Symbols.SMenos };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "2", Symbol = Symbols.SNumero };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "+", Symbol = Symbols.SMais };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "4", Symbol = Symbols.SNumero };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "*", Symbol = Symbols.SMult };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "5", Symbol = Symbols.SNumero };
expressionAnalyzer.Add(token);
expressionAnalyzer.Analyze(out type);
output = expressionAnalyzer.ToString();
Assert.AreEqual(type, ItemType.Integer);
Assert.AreEqual(output, expectedOutput);
}
public void INTEGER_BOOLEAN_EXPRESSION_TEST()
{
var expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
var output = string.Empty;
var expectedOutput = "ab+cd-<";
var token = new Token { Lexeme = "(", Symbol = Symbols.SAbreParenteses };
var type = ItemType.None;
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "a", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "+", Symbol = Symbols.SMais };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "b", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = ")", Symbol = Symbols.SFechaParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "<", Symbol = Symbols.SMenorIg };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "(", Symbol = Symbols.SAbreParenteses };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "c", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "-", Symbol = Symbols.SMenos };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = "d", Symbol = Symbols.SIdentificador };
expressionAnalyzer.Add(token);
token = new Token { Lexeme = ")", Symbol = Symbols.SFechaParenteses };
expressionAnalyzer.Add(token);
expressionAnalyzer.Analyze(out type);
output = expressionAnalyzer.ToString();
Assert.AreEqual(type, ItemType.Boolean);
Assert.AreEqual(output, expectedOutput);
}
private ItemType AnalyzeExpressionType()
{
_expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
AnalyzeExpression();
var type = ItemType.None;
try
{
var tokens = _expressionAnalyzer.Analyze(out type);
GenerateCodeForExpression(tokens);
}
catch (ExpressionException ex)
{
throw new CompilationException(string.Format(GenericErrorMessage, _lexical.Position.Line,
_lexical.Position.Column, ex.Message));
}
catch (Exception ex)
{
//Todo: log error here.
throw new CompilationException(ex.Message);
}
return type;
}
static MicroModelExtensions()
{
_analyser = new ExpressionAnalyzer(new ExternalDependencyExtractor(), new StaticDependencyExtractor());
}
public void INTEGER_BOOLEAN_EXPRESSION_COMPLEX_TEST()
{
var expressionAnalyzer = new ExpressionAnalyzer(_symbolTable);
var output = string.Empty;
var expectedOutput = "a-badivab-**<nao";
var token = new Token {
Lexeme = "nao", Symbol = Symbols.SNao
};
var type = ItemType.None;
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "(", Symbol = Symbols.SAbreParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "(", Symbol = Symbols.SAbreParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "-", Symbol = Symbols.SMenosUnario
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "a", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = ")", Symbol = Symbols.SFechaParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "<", Symbol = Symbols.SMenor
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "(", Symbol = Symbols.SAbreParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "(", Symbol = Symbols.SAbreParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "b", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "div", Symbol = Symbols.SDiv
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "a", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = ")", Symbol = Symbols.SFechaParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "*", Symbol = Symbols.SMult
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "(", Symbol = Symbols.SAbreParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "a", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "*", Symbol = Symbols.SMult
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "(", Symbol = Symbols.SAbreParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "-", Symbol = Symbols.SMenosUnario
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = "b", Symbol = Symbols.SIdentificador
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = ")", Symbol = Symbols.SFechaParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = ")", Symbol = Symbols.SFechaParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = ")", Symbol = Symbols.SFechaParenteses
};
expressionAnalyzer.Add(token);
token = new Token {
Lexeme = ")", Symbol = Symbols.SFechaParenteses
};
expressionAnalyzer.Add(token);
expressionAnalyzer.Analyze(out type);
output = expressionAnalyzer.ToString();
Assert.AreEqual(type, ItemType.Boolean);
Assert.AreEqual(output, expectedOutput);
}
public StatementAnalyzer(List <Statement> program, ExpressionAnalyzer expressionAnalyzer, Environment environment)
{
this.program = program;
this.environment = environment;
this.expressionAnalyzer = expressionAnalyzer;
}
