Changeset 3193

Timestamp:

12/11/08 04:41:30 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Removed optional fields of IntLiteralExpr?, CharLiteralExpr?, and VoidLiteralExpr?.

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (2 diffs)
• src/com/sun/fortress/compiler/disambiguator/ExprDisambiguator.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (3 diffs)
• src/com/sun/fortress/nodes_util/ExprFactory.java (modified) (5 diffs)
• src/com/sun/fortress/nodes_util/NodeFactory.java (modified) (1 diff)
• src/com/sun/fortress/parser_util/FortressUtil.java (modified) (1 diff)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -785 +785 @@
                                  * e.g.) 7
                                  */
-                                IntLiteralExpr(String text = in_intVal.toString(),
-                                               BigInteger intVal);
+                                IntLiteralExpr(BigInteger intVal);
                             /**
                              * char literal
                              * e.g.) 'c'
                              */
-                            CharLiteralExpr(int charVal = in_text.charAt(0));
+                            CharLiteralExpr(int charVal);
                             /**
                              * string literal
@@ -801 +800 @@
                              * e.g.) ()
                              */
-                            VoidLiteralExpr(String text = "");
+                            VoidLiteralExpr();
                         /**
                          * variable reference

trunk/ProjectFortress/src/com/sun/fortress/compiler/disambiguator/ExprDisambiguator.java

@@ -1166 +1166 @@
         Option<Expr> with = returnExpr_result.isSome() ?
             returnExpr_result :
-            wrap((Expr)new VoidLiteralExpr(that.getSpan()));
+            wrap((Expr)ExprFactory.makeVoidLiteralExpr(that.getSpan()));
 
         if (target.isNone() || _innerMostLabel.isNone()) {

trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/TypeChecker.java

@@ -2018 +2018 @@
         @Override
         public TypeCheckerResult forCharLiteralExpr(CharLiteralExpr that) {
-                CharLiteralExpr new_node = new CharLiteralExpr(that.getSpan(),
-                                that.isParenthesized(),
-                                Option.<Type>some(Types.CHAR),
-                                that.getText(),
-                                that.getCharVal());
+                CharLiteralExpr new_node = ExprFactory.makeCharLiteralExpr(that.getSpan(),
+                                                                           that.isParenthesized(),
+                                                                           Option.<Type>some(Types.CHAR),
+                                                                           that.getText(),
+                                                                           that.getCharVal());
                 return new TypeCheckerResult(new_node, Types.CHAR);
         }
@@ -2870 +2870 @@
         @Override
         public TypeCheckerResult forIntLiteralExpr(IntLiteralExpr that) {
-                IntLiteralExpr new_node = new IntLiteralExpr(that.getSpan(), Option.<Type>some(Types.INT_LITERAL), that.getText(), that.getIntVal());
+                IntLiteralExpr new_node = ExprFactory.makeIntLiteralExpr(that.getSpan(),
+                                                                         that.isParenthesized(),
+                                                                         Option.<Type>some(Types.INT_LITERAL),
+                                                                         that.getText(), that.getIntVal());
                 return new TypeCheckerResult(new_node, Types.INT_LITERAL);
         }
@@ -4464 +4467 @@
         @Override
         public TypeCheckerResult forVoidLiteralExpr(VoidLiteralExpr that) {
-                VoidLiteralExpr new_node = new VoidLiteralExpr(that.getSpan(),
-                                that.isParenthesized(),
-                                Option.<Type>some(Types.VOID),
-                                that.getText());
+                VoidLiteralExpr new_node = ExprFactory.makeVoidLiteralExpr(that.getSpan(),
+                                                                           that.isParenthesized(),
+                                                                           Option.<Type>some(Types.VOID),
+                                                                           that.getText());
                 return new TypeCheckerResult(new_node, Types.VOID);
         }

trunk/ProjectFortress/src/com/sun/fortress/nodes_util/ExprFactory.java

@@ -468 +468 @@
     }
 
+    public static IntLiteralExpr makeIntLiteralExpr(Span span, String s) {
+        BigInteger val;
+
+        // Delete every apostrophe and U+202F NARROW NO-BREAK SPACE
+        s = s.replace("'", "").replace("\u202F", "");
+
+        int underLoc = s.indexOf('_');
+        if (underLoc == -1) {
+            val = new BigInteger(s);
+        }
+        else {
+            String digits = s.substring(0, underLoc);
+            String base_digits = s.substring(underLoc + 1);
+            int base;
+            if (!Unicode.charactersOverlap(base_digits, "0123456789")) {
+                base = Unicode.numberToValue(base_digits);
+            }
+            else {
+                base = Integer.parseInt(base_digits);
+            }
+            digits = dozenalHack(digits, base);
+            val = new BigInteger(digits, base);
+        }
+        return makeIntLiteralExpr(span, s, val);
+    }
+
+    static String dozenalHack(String digits, int base) {
+        if (base == 12 && Unicode.charactersOverlap(digits, "xXeE")) {
+            digits = digits.replace('x', 'A');
+            digits = digits.replace('X', 'A');
+            digits = digits.replace('e', 'B');
+            digits = digits.replace('E', 'B');
+        }
+        return digits;
+    }
+
+    public static IntLiteralExpr makeIntLiteralExpr(Span span,
+                                                    BigInteger intVal) {
+        return makeIntLiteralExpr(span, intVal.toString(), intVal);
+    }
+
+    public static IntLiteralExpr makeIntLiteralExpr(Span span,
+                                                    String text,
+                                                    BigInteger intVal) {
+        return makeIntLiteralExpr(span, false, Option.<Type>none(),
+                                  text, intVal);
+    }
+
+    public static IntLiteralExpr makeIntLiteralExpr(Span span,
+                                                    boolean parenthesized,
+                                                    Option<Type> exprType,
+                                                    String text,
+                                                    BigInteger intVal) {
+        return new IntLiteralExpr(span, parenthesized, exprType, text, intVal);
+    }
+
+    public static CharLiteralExpr makeCharLiteralExpr(Span span, String s) {
+        return makeCharLiteralExpr(span, false, Option.<Type>none(),
+                                   s, s.charAt(0));
+    }
+
+    public static CharLiteralExpr makeCharLiteralExpr(Span span,
+                                                      boolean parenthesized,
+                                                      Option<Type> exprType,
+                                                      String text,
+                                                      int charVal) {
+        return new CharLiteralExpr(span, parenthesized, exprType, text, charVal);
+    }
+
+    public static VoidLiteralExpr makeVoidLiteralExpr(Span span) {
+        return makeVoidLiteralExpr(span, false, Option.<Type>none(), "");
+    }
+
+    public static VoidLiteralExpr makeVoidLiteralExpr(Span span,
+                                                      boolean parenthesized,
+                                                      Option<Type> exprType,
+                                                      String text) {
+        return new VoidLiteralExpr(span, parenthesized, exprType, text);
+    }
+
     /***************************************************************************************/
-
-    public static CharLiteralExpr makeCharLiteralExpr(Span span, String s) {
-        return new CharLiteralExpr(span, false, s, s.charAt(0));
-    }
 
     public static Exit makeExit(Span span, Option<Type> typeOp, Option<Id> targetOp, Expr retExpr) {
@@ -595 +671 @@
     }
 
-    public static IntLiteralExpr makeIntLiteralExpr(Span span, BigInteger val) {
-        return new IntLiteralExpr(span, false, val.toString(), val);
-    }
-
-    public static IntLiteralExpr makeIntLiteralExpr(Span span, String s) {
-        BigInteger val;
-
-        // Delete every apostrophe and U+202F NARROW NO-BREAK SPACE
-        s = s.replace("'", "").replace("\u202F", "");
-
-        int underLoc = s.indexOf('_');
-        if (underLoc == -1) {
-            val = new BigInteger(s);
-        }
-        else {
-            String digits = s.substring(0, underLoc);
-            String base_digits = s.substring(underLoc + 1);
-            int base;
-            if (!Unicode.charactersOverlap(base_digits, "0123456789")) {
-                base = Unicode.numberToValue(base_digits);
-            }
-            else {
-                base = Integer.parseInt(base_digits);
-            }
-            digits = dozenalHack(digits, base);
-            val = new BigInteger(digits, base);
-        }
-        return new IntLiteralExpr(span, false, s, val);
-    }
-
-    static String dozenalHack(String digits, int base) {
-        if (base == 12 && Unicode.charactersOverlap(digits, "xXeE")) {
-            digits = digits.replace('x', 'A');
-            digits = digits.replace('X', 'A');
-            digits = digits.replace('e', 'B');
-            digits = digits.replace('E', 'B');
-        }
-        return digits;
-    }
-
 
     public static LetExpr makeLetExpr(final LetExpr let_expr, final List<Expr> body) {
@@ -745 +781 @@
     }
 
-    public static VoidLiteralExpr makeVoidLiteralExpr(Span span) {
-        return new VoidLiteralExpr(span, false, "");
-    }
-
     public static If makeIf(IfClause _if, Expr _else) {
         List<IfClause> ifclauses = Collections.singletonList(_if);
@@ -1042 +1074 @@
         }
         public Expr forIntLiteralExpr(IntLiteralExpr e) {
-            return new IntLiteralExpr(e.getSpan(), true, e.getText(),
-                    e.getIntVal());
+            return makeIntLiteralExpr(e.getSpan(), true, e.getExprType(),
+                                      e.getText(), e.getIntVal());
         }
         public Expr forCharLiteralExpr(CharLiteralExpr e) {
-            return new CharLiteralExpr(e.getSpan(), true, e.getText(),
-                    e.getCharVal());
+            return makeCharLiteralExpr(e.getSpan(), true, e.getExprType(),
+                                       e.getText(), e.getCharVal());
         }
         public Expr forStringLiteralExpr(StringLiteralExpr e) {
@@ -1053 +1085 @@
         }
         public Expr forVoidLiteralExpr(VoidLiteralExpr e) {
-            return new VoidLiteralExpr(e.getSpan(), true, e.getText());
+            return makeVoidLiteralExpr(e.getSpan(), true, e.getExprType(),
+                                       e.getText());
         }
         public Expr forVarRef(VarRef e) {

trunk/ProjectFortress/src/com/sun/fortress/nodes_util/NodeFactory.java

@@ -1231 +1231 @@
     public static IntExpr makeIntVal(String i) {
         Span span = new Span();
-        return new IntBase(span, new IntLiteralExpr(span,
-                new BigInteger(i)));
+        return new IntBase(span, ExprFactory.makeIntLiteralExpr(span,
+                                                                new BigInteger(i)));
     }
 

trunk/ProjectFortress/src/com/sun/fortress/parser_util/FortressUtil.java

@@ -48 +48 @@
 public final class FortressUtil {
     public static <T> T syntaxError(Span span, String msg) {
-        return ProgramError.<T>error(new VoidLiteralExpr(span), msg);
+        return ProgramError.<T>error(ExprFactory.makeVoidLiteralExpr(span), msg);
     }