commit a3dce1f48ce565387783c1c916d8bf73ec1ac660
author Ben Gruver <bgruv@google.com> Mon Sep 24 18:17:39 2012 -0700
committer Ben Gruver <bgruv@google.com> Mon Sep 24 18:17:39 2012 -0700
tree 50b64d2adef305acc5e2bdc51d2e55c913802141
parent de3a5f95ae35478159786155474a95c744b2cbc4

Move parseFloat and parseDouble to LiteralTools

smali/src/main/antlr3/smaliTreeWalker.g

diff --git a/smali/src/main/antlr3/smaliTreeWalker.g b/smali/src/main/antlr3/smaliTreeWalker.g
index 44c0078..326d5bd 100644
--- a/smali/src/main/antlr3/smaliTreeWalker.g
+++ b/smali/src/main/antlr3/smaliTreeWalker.g
@@ -96,42 +96,6 @@
     return val;
   }
 
-  private static Pattern specialFloatRegex = Pattern.compile("((-)?infinityf)|(nanf)", Pattern.CASE_INSENSITIVE);
-  private float parseFloat(String floatString) {
-    Matcher m = specialFloatRegex.matcher(floatString);
-    if (m.matches()) {
-      //got an infinity
-      if (m.start(1) != -1) {
-        if (m.start(2) != -1) {
-          return Float.NEGATIVE_INFINITY;
-        } else {
-          return Float.POSITIVE_INFINITY;
-        }
-      } else {
-        return Float.NaN;
-      }
-    }
-    return Float.parseFloat(floatString);
-  }
-
-  private static Pattern specialDoubleRegex = Pattern.compile("((-)?infinityd?)|(nand?)", Pattern.CASE_INSENSITIVE);
-  private double parseDouble(String doubleString) {
-    Matcher m = specialDoubleRegex.matcher(doubleString);
-    if (m.matches()) {
-      //got an infinity
-      if (m.start(1) != -1) {
-        if (m.start(2) != -1) {
-          return Double.NEGATIVE_INFINITY;
-        } else {
-          return Double.POSITIVE_INFINITY;
-        }
-      } else {
-        return Double.NaN;
-      }
-    }
-    return Double.parseDouble(doubleString);
-  }
-
   public String getErrorMessage(RecognitionException e, String[] tokenNames) {
     if ( e instanceof SemanticException ) {
       return e.getMessage();
@@ -1503,10 +1467,10 @@
   : BYTE_LITERAL { $value = LiteralTools.parseByte($BYTE_LITERAL.text); };
 
 float_literal returns[float value]
-  : FLOAT_LITERAL { $value = parseFloat($FLOAT_LITERAL.text); };
+  : FLOAT_LITERAL { $value = LiteralTools.parseFloat($FLOAT_LITERAL.text); };
 
 double_literal returns[double value]
-  : DOUBLE_LITERAL { $value = parseDouble($DOUBLE_LITERAL.text); };
+  : DOUBLE_LITERAL { $value = LiteralTools.parseDouble($DOUBLE_LITERAL.text); };
 
 char_literal returns[char value]
   : CHAR_LITERAL { $value = $CHAR_LITERAL.text.charAt(1); };

smali/src/main/java/org/jf/smali/LiteralTools.java

diff --git a/smali/src/main/java/org/jf/smali/LiteralTools.java b/smali/src/main/java/org/jf/smali/LiteralTools.java
index 1c7fb78..e2262c1 100644
--- a/smali/src/main/java/org/jf/smali/LiteralTools.java
+++ b/smali/src/main/java/org/jf/smali/LiteralTools.java
@@ -28,6 +28,9 @@
 
 package org.jf.smali;
 
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 public class LiteralTools
 {
     public static byte parseByte(String byteLiteral)
@@ -304,6 +307,42 @@
         }
     }
 
+    private static Pattern specialFloatRegex = Pattern.compile("((-)?infinityf)|(nanf)", Pattern.CASE_INSENSITIVE);
+    public static float parseFloat(String floatString) {
+        Matcher m = specialFloatRegex.matcher(floatString);
+        if (m.matches()) {
+            //got an infinity
+            if (m.start(1) != -1) {
+                if (m.start(2) != -1) {
+                    return Float.NEGATIVE_INFINITY;
+                } else {
+                    return Float.POSITIVE_INFINITY;
+                }
+            } else {
+                return Float.NaN;
+            }
+        }
+        return Float.parseFloat(floatString);
+    }
+
+    private static Pattern specialDoubleRegex = Pattern.compile("((-)?infinityd?)|(nand?)", Pattern.CASE_INSENSITIVE);
+    public static double parseDouble(String doubleString) {
+        Matcher m = specialDoubleRegex.matcher(doubleString);
+        if (m.matches()) {
+            //got an infinity
+            if (m.start(1) != -1) {
+                if (m.start(2) != -1) {
+                    return Double.NEGATIVE_INFINITY;
+                } else {
+                    return Double.POSITIVE_INFINITY;
+                }
+            } else {
+                return Double.NaN;
+            }
+        }
+        return Double.parseDouble(doubleString);
+    }
+
     public static byte[] longToBytes(long value) {
         byte[] bytes = new byte[8];