make preprocessor always use "option compare text" mode

retailcoder · Mar 4, 2016 · 8437dfc · 8437dfc
1 parent 9e88a71
commit 8437dfc
Show file tree

Hide file tree

Showing 17 changed files with 28 additions and 161 deletions.
diff --git a/Rubberduck.Parsing/Preprocessing/LogicalEqualsExpression.cs b/Rubberduck.Parsing/Preprocessing/LogicalEqualsExpression.cs
@@ -4,13 +4,11 @@ public sealed class LogicalEqualsExpression : Expression
     {
         private readonly IExpression _left;
         private readonly IExpression _right;
-        private readonly VBAOptionCompare _optionCompare;
 
-        public LogicalEqualsExpression(IExpression left, IExpression right, VBAOptionCompare optionCompare)
+        public LogicalEqualsExpression(IExpression left, IExpression right)
         {
             _left = left;
             _right = right;
-            _optionCompare = optionCompare;
         }
 
         public override IValue Evaluate()
@@ -27,14 +25,7 @@ public override IValue Evaluate()
             {
                 var leftValue = left.AsString;
                 var rightValue = right.AsString;
-                if (_optionCompare == VBAOptionCompare.Binary)
-                {
-                    return new BoolValue(string.CompareOrdinal(leftValue, rightValue) == 0);
-                }
-                else
-                {
-                    return new BoolValue(leftValue.CompareTo(rightValue) == 0);
-                }
+                return new BoolValue(leftValue.CompareTo(rightValue) == 0);
             }
             else
             {

diff --git a/Rubberduck.Parsing/Preprocessing/LogicalGreaterOrEqualsExpression.cs b/Rubberduck.Parsing/Preprocessing/LogicalGreaterOrEqualsExpression.cs
@@ -4,18 +4,16 @@ public sealed class LogicalGreaterOrEqualsExpression : Expression
     {
         private readonly IExpression _left;
         private readonly IExpression _right;
-        private readonly VBAOptionCompare _optionCompare;
 
-        public LogicalGreaterOrEqualsExpression(IExpression left, IExpression right, VBAOptionCompare optionCompare)
+        public LogicalGreaterOrEqualsExpression(IExpression left, IExpression right)
         {
             _left = left;
             _right = right;
-            _optionCompare = optionCompare;
         }
 
         public override IValue Evaluate()
         {
-            var result = new LogicalLessThanExpression(_left, _right, _optionCompare).Evaluate();
+            var result = new LogicalLessThanExpression(_left, _right).Evaluate();
             if (result == null)
             {
                 return null;

diff --git a/Rubberduck.Parsing/Preprocessing/LogicalGreaterThanExpression.cs b/Rubberduck.Parsing/Preprocessing/LogicalGreaterThanExpression.cs
@@ -4,19 +4,17 @@ public sealed class LogicalGreaterThanExpression : Expression
     {
         private readonly IExpression _left;
         private readonly IExpression _right;
-        private readonly VBAOptionCompare _optionCompare;
 
-        public LogicalGreaterThanExpression(IExpression left, IExpression right, VBAOptionCompare optionCompare)
+        public LogicalGreaterThanExpression(IExpression left, IExpression right)
         {
             _left = left;
             _right = right;
-            _optionCompare = optionCompare;
         }
 
         public override IValue Evaluate()
         {
-            var lt = new LogicalLessThanExpression(_left, _right, _optionCompare).Evaluate();
-            var eq = new LogicalEqualsExpression(_left, _right, _optionCompare).Evaluate();
+            var lt = new LogicalLessThanExpression(_left, _right).Evaluate();
+            var eq = new LogicalEqualsExpression(_left, _right).Evaluate();
             if (lt == null || eq == null)
             {
                 return null;

diff --git a/Rubberduck.Parsing/Preprocessing/LogicalLessOrEqualsExpression.cs b/Rubberduck.Parsing/Preprocessing/LogicalLessOrEqualsExpression.cs
@@ -4,19 +4,17 @@ public sealed class LogicalLessOrEqualsExpression : Expression
     {
         private readonly IExpression _left;
         private readonly IExpression _right;
-        private readonly VBAOptionCompare _optionCompare;
 
-        public LogicalLessOrEqualsExpression(IExpression left, IExpression right, VBAOptionCompare optionCompare)
+        public LogicalLessOrEqualsExpression(IExpression left, IExpression right)
         {
             _left = left;
             _right = right;
-            _optionCompare = optionCompare;
         }
 
         public override IValue Evaluate()
         {
-            var lt = new LogicalLessThanExpression(_left, _right, _optionCompare).Evaluate();
-            var eq = new LogicalEqualsExpression(_left, _right, _optionCompare).Evaluate();
+            var lt = new LogicalLessThanExpression(_left, _right).Evaluate();
+            var eq = new LogicalEqualsExpression(_left, _right).Evaluate();
             if (lt == null || eq == null)
             {
                 return null;

diff --git a/Rubberduck.Parsing/Preprocessing/LogicalLessThanExpression.cs b/Rubberduck.Parsing/Preprocessing/LogicalLessThanExpression.cs
@@ -4,13 +4,11 @@ public sealed class LogicalLessThanExpression : Expression
     {
         private readonly IExpression _left;
         private readonly IExpression _right;
-        private readonly VBAOptionCompare _optionCompare;
 
-        public LogicalLessThanExpression(IExpression left, IExpression right, VBAOptionCompare optionCompare)
+        public LogicalLessThanExpression(IExpression left, IExpression right)
         {
             _left = left;
             _right = right;
-            _optionCompare = optionCompare;
         }
 
         public override IValue Evaluate()
@@ -26,14 +24,7 @@ public override IValue Evaluate()
             {
                 var leftValue = left.AsString;
                 var rightValue = right.AsString;
-                if (_optionCompare == VBAOptionCompare.Binary)
-                {
-                    return new BoolValue(string.CompareOrdinal(leftValue, rightValue) < 0);
-                }
-                else
-                {
-                    return new BoolValue(leftValue.CompareTo(rightValue) < 0);
-                }
+                return new BoolValue(leftValue.CompareTo(rightValue) < 0);
             }
             else
             {

diff --git a/Rubberduck.Parsing/Preprocessing/LogicalNotEqualsExpression.cs b/Rubberduck.Parsing/Preprocessing/LogicalNotEqualsExpression.cs
@@ -4,18 +4,16 @@ public sealed class LogicalNotEqualsExpression : Expression
     {
         private readonly IExpression _left;
         private readonly IExpression _right;
-        private readonly VBAOptionCompare _optionCompare;
 
-        public LogicalNotEqualsExpression(IExpression left, IExpression right, VBAOptionCompare optionCompare)
+        public LogicalNotEqualsExpression(IExpression left, IExpression right)
         {
             _left = left;
             _right = right;
-            _optionCompare = optionCompare;
         }
 
         public override IValue Evaluate()
         {
-            var eq = new LogicalEqualsExpression(_left, _right, _optionCompare).Evaluate();
+            var eq = new LogicalEqualsExpression(_left, _right).Evaluate();
             if (eq == null)
             {
                 return null;

diff --git a/Rubberduck.Parsing/Preprocessing/OptionCompareListener.cs b/Rubberduck.Parsing/Preprocessing/OptionCompareListener.cs
diff --git a/Rubberduck.Parsing/Preprocessing/OptionCompareParser.cs b/Rubberduck.Parsing/Preprocessing/OptionCompareParser.cs
diff --git a/...k.Parsing/Preprocessing/VBAEnvironment.cs → ...rduck.Parsing/Preprocessing/VBALibrary.cs b/...k.Parsing/Preprocessing/VBAEnvironment.cs → ...rduck.Parsing/Preprocessing/VBALibrary.cs
@@ -3,7 +3,7 @@
 
 namespace Rubberduck.Parsing.Preprocessing
 {
-    public static class VBAEnvironment
+    public static class VBALibrary
     {
         private static readonly Dictionary<string, Func<IExpression, IExpression>> _libraryFunctions = new Dictionary<string, Func<IExpression, IExpression>>()
         {

diff --git a/Rubberduck.Parsing/Preprocessing/VBAOptionCompare.cs b/Rubberduck.Parsing/Preprocessing/VBAOptionCompare.cs
diff --git a/Rubberduck.Parsing/Preprocessing/VBAPreprocessor.cs b/Rubberduck.Parsing/Preprocessing/VBAPreprocessor.cs
@@ -7,12 +7,10 @@ namespace Rubberduck.Parsing.Preprocessing
     public sealed class VBAPreprocessor
     {
         private readonly double _vbaVersion;
-        private readonly VBAOptionCompare _optionCompare;
 
-        public VBAPreprocessor(double vbaVersion, VBAOptionCompare optionCompare)
+        public VBAPreprocessor(double vbaVersion)
         {
             _vbaVersion = vbaVersion;
-            _optionCompare = optionCompare;
         }
 
         public string Execute(string unprocessedCode)
@@ -35,7 +33,7 @@ private string Preprocess(string unprocessedCode)
             var tokens = new CommonTokenStream(lexer);
             var parser = new VBAConditionalCompilationParser(tokens);
             parser.AddErrorListener(new ExceptionErrorListener());
-            var evaluator = new VBAPreprocessorVisitor(symbolTable, new VBAPredefinedCompilationConstants(_vbaVersion), _optionCompare);
+            var evaluator = new VBAPreprocessorVisitor(symbolTable, new VBAPredefinedCompilationConstants(_vbaVersion));
             var tree = parser.compilationUnit();
             var expr = evaluator.Visit(tree);
             return expr.Evaluate().AsString;

diff --git a/Rubberduck.Parsing/Preprocessing/VBAPreprocessorVisitor.cs b/Rubberduck.Parsing/Preprocessing/VBAPreprocessorVisitor.cs
@@ -8,12 +8,10 @@ namespace Rubberduck.Parsing.Preprocessing
     public sealed class VBAPreprocessorVisitor : VBAConditionalCompilationBaseVisitor<IExpression>
     {
         private readonly SymbolTable<string, IValue> _symbolTable;
-        private readonly VBAOptionCompare _optionCompare;
 
         public VBAPreprocessorVisitor(
             SymbolTable<string, IValue> symbolTable, 
-            VBAPredefinedCompilationConstants predefinedConstants,
-            VBAOptionCompare optionCompare)
+            VBAPredefinedCompilationConstants predefinedConstants)
         {
             _symbolTable = symbolTable;
             _symbolTable.Add(VBAPredefinedCompilationConstants.VBA6_NAME, new BoolValue(predefinedConstants.VBA6));
@@ -22,7 +20,6 @@ public sealed class VBAPreprocessorVisitor : VBAConditionalCompilationBaseVisito
             _symbolTable.Add(VBAPredefinedCompilationConstants.WIN32_NAME, new BoolValue(predefinedConstants.Win32));
             _symbolTable.Add(VBAPredefinedCompilationConstants.WIN16_NAME, new BoolValue(predefinedConstants.Win16));
             _symbolTable.Add(VBAPredefinedCompilationConstants.MAC_NAME, new BoolValue(predefinedConstants.Mac));
-            _optionCompare = optionCompare;
         }
 
         public override IExpression VisitCompilationUnit([NotNull] VBAConditionalCompilationParser.CompilationUnitContext context)
@@ -228,7 +225,7 @@ private IExpression VisitLibraryFunction(VBAConditionalCompilationParser.CcExpre
             var intrinsicFunction = context.intrinsicFunction();
             var functionName = intrinsicFunction.intrinsicFunctionName().GetText();
             var argument = Visit(intrinsicFunction.ccExpression());
-            return VBAEnvironment.CreateLibraryFunction(functionName, argument);
+            return VBALibrary.CreateLibraryFunction(functionName, argument);
         }
 
         private IExpression VisitLike(VBAConditionalCompilationParser.CcExpressionContext context)
@@ -284,42 +281,42 @@ private IExpression VisitGeq(VBAConditionalCompilationParser.CcExpressionContext
         {
             var left = Visit(context.ccExpression()[0]);
             var right = Visit(context.ccExpression()[1]);
-            return new LogicalGreaterOrEqualsExpression(left, right, _optionCompare);
+            return new LogicalGreaterOrEqualsExpression(left, right);
         }
 
         private IExpression VisitLeq(VBAConditionalCompilationParser.CcExpressionContext context)
         {
             var left = Visit(context.ccExpression()[0]);
             var right = Visit(context.ccExpression()[1]);
-            return new LogicalLessOrEqualsExpression(left, right, _optionCompare);
+            return new LogicalLessOrEqualsExpression(left, right);
         }
 
         private IExpression VisitGt(VBAConditionalCompilationParser.CcExpressionContext context)
         {
             var left = Visit(context.ccExpression()[0]);
             var right = Visit(context.ccExpression()[1]);
-            return new LogicalGreaterThanExpression(left, right, _optionCompare);
+            return new LogicalGreaterThanExpression(left, right);
         }
 
         private IExpression VisitLt(VBAConditionalCompilationParser.CcExpressionContext context)
         {
             var left = Visit(context.ccExpression()[0]);
             var right = Visit(context.ccExpression()[1]);
-            return new LogicalLessThanExpression(left, right, _optionCompare);
+            return new LogicalLessThanExpression(left, right);
         }
 
         private IExpression VisitNeq(VBAConditionalCompilationParser.CcExpressionContext context)
         {
             var left = Visit(context.ccExpression()[0]);
             var right = Visit(context.ccExpression()[1]);
-            return new LogicalNotEqualsExpression(left, right, _optionCompare);
+            return new LogicalNotEqualsExpression(left, right);
         }
 
         private IExpression VisitEq(VBAConditionalCompilationParser.CcExpressionContext context)
         {
             var left = Visit(context.ccExpression()[0]);
             var right = Visit(context.ccExpression()[1]);
-            return new LogicalEqualsExpression(left, right, _optionCompare);
+            return new LogicalEqualsExpression(left, right);
         }
 
         private IExpression VisitConcat(VBAConditionalCompilationParser.CcExpressionContext context)

diff --git a/Rubberduck.Parsing/Rubberduck.Parsing.csproj b/Rubberduck.Parsing/Rubberduck.Parsing.csproj
@@ -92,8 +92,6 @@
     <Compile Include="Preprocessing\NameExpression.cs" />
     <Compile Include="Preprocessing\NumberLiteralExpression.cs" />
     <Compile Include="Preprocessing\OctNumberLiteralExpression.cs" />
-    <Compile Include="Preprocessing\OptionCompareListener.cs" />
-    <Compile Include="Preprocessing\OptionCompareParser.cs" />
     <Compile Include="Preprocessing\PowExpression.cs" />
     <Compile Include="Preprocessing\CSngLibraryFunctionExpression.cs" />
     <Compile Include="Preprocessing\CLngPtrLibraryFunctionExpression.cs" />
@@ -139,14 +137,13 @@
     <Compile Include="Preprocessing\VBAConditionalCompilationListener.cs" />
     <Compile Include="Preprocessing\VBAConditionalCompilationParser.cs" />
     <Compile Include="Preprocessing\VBAConditionalCompilationVisitor.cs" />
-    <Compile Include="Preprocessing\VBAEnvironment.cs" />
+    <Compile Include="Preprocessing\VBALibrary.cs" />
     <Compile Include="Preprocessing\VBALikeBaseListener.cs" />
     <Compile Include="Preprocessing\VBALikeBaseVisitor.cs" />
     <Compile Include="Preprocessing\VBALikeLexer.cs" />
     <Compile Include="Preprocessing\VBALikeListener.cs" />
     <Compile Include="Preprocessing\VBALikeParser.cs" />
     <Compile Include="Preprocessing\VBALikeVisitor.cs" />
-    <Compile Include="Preprocessing\VBAOptionCompare.cs" />
     <Compile Include="Preprocessing\VBAPreprocessorException.cs" />
     <Compile Include="Preprocessing\VBADateConstants.cs" />
     <Compile Include="Preprocessing\SymbolTable.cs" />

diff --git a/Rubberduck.Parsing/VBA/RubberduckParser.cs b/Rubberduck.Parsing/VBA/RubberduckParser.cs
@@ -225,7 +225,7 @@ private void ParseInternal(VBComponent vbComponent, string code, CancellationTok
 
             token.ThrowIfCancellationRequested();
 
-            var preprocessor = new VBAPreprocessor(double.Parse(_vbe.Version), OptionCompareParser.Parse(vbComponent.CodeModule));
+            var preprocessor = new VBAPreprocessor(double.Parse(_vbe.Version));
             string preprocessedModuleBody;
             try
             {