package net.sourceforge.jenesis4java.impl;
   
   /*
    * #%L
    * Jenesis 4 Java Code Generator
    * %%
    * Copyright (C) 2000 - 2015 jenesis4java
    * %%
    * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation, either version 3 of the
   * License, or (at your option) any later version.
   * 
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Lesser Public License for more details.
   * 
   * You should have received a copy of the GNU General Lesser Public
   * License along with this program.  If not, see
   * <http://www.gnu.org/licenses/lgpl-3.0.html>.
   * #L%
   */
  
  /**
   * Copyright (C) 2008, 2010 Richard van Nieuwenhoven - ritchie [at] gmx [dot] at
   * Copyright (C) 2000, 2001 Paul Cody Johnston - pcj@inxar.org <br>
   * This file is part of Jenesis4java. Jenesis4java is free software: you can
   * redistribute it and/or modify it under the terms of the GNU Lesser General
   * Public License as published by the Free Software Foundation, either version 3
   * of the License, or (at your option) any later version.<br>
   * Jenesis4java is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
   * details.<br>
   * You should have received a copy of the GNU Lesser General Public License
   * along with Jenesis4java. If not, see <http://www.gnu.org/licenses/>.
   */
  
  import net.sourceforge.jenesis4java.*;
  import net.sourceforge.jenesis4java.impl.util.VisitorUtils;
  
  import java.util.*;
  
  import static java.lang.String.format;
  
  /**
   * Standard {@code Literal} implementations.
   */
  public abstract class MLiteral extends MVM.MCodeable implements Literal {
  
      /**
       * BOOLEAN LITERAL
       */
      static class MBooleanLiteral extends MLiteral implements BooleanLiteral {
  
          MBooleanLiteral(MVM vm, boolean val) {
              super(vm, vm.BOOLEAN, val, val ? "true" : "false");
          }
  
          @Override
          public boolean toBoolean() {
              return (Boolean) val;
          }
      }
  
      /**
       * BYTE LITERAL
       */
      static class MByteLiteral extends MLiteral implements ByteLiteral {
  
          MByteLiteral(MVM vm, byte val) {
              super(vm, vm.BYTE, val, "(byte) " + val);
          }
  
          @Override
          public byte toByte() {
              return (Byte) val;
          }
      }
  
      /**
       * CHAR LITERAL
       */
      static class MCharLiteral extends MLiteral implements CharLiteral {
  
          /**
           * Control characters that are not actually printable characters and
           * therefor need to be escaped with UTF-8 syntax.
           */
          private static final Set<Character> CONTROL_CODES;
  
          /**
           * Characters, for which Java provides a special encoding.
           */
          private static final Map<Character, String> SPECIAL_ENCODINGS;
  
          MCharLiteral(MVM vm, char val) {
              super(vm, vm.CHAR, val, escapedValue(val));
         }
 
         private static String escapedValue(char val) {
             StringBuilder b = new StringBuilder();
             b.append("'");
             escape(val, b, false);
             b.append("'");
             return b.toString();
         }
 
         static {
             CONTROL_CODES = new HashSet<>();
             CONTROL_CODES.addAll(Arrays.asList( //
                     '\u0001', '\u0002', '\u0003', '\u0004', '\u0005', '\u0006', //
                     '\u0007', '\u000B', '\u000E', '\u000F', '\u0010', '\u0011', //
                     '\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017', //
                     '\u0018', '\u0019', '\u001A', '\u001B', '\u001C', '\u001D', //
                     '\u001E', '\u001F'));
 
             SPECIAL_ENCODINGS = new HashMap<>();
             SPECIAL_ENCODINGS.put('\0', "\\0");
             SPECIAL_ENCODINGS.put('\b', "\\b");
             SPECIAL_ENCODINGS.put('\t', "\\t");
             SPECIAL_ENCODINGS.put('\n', "\\n");
             SPECIAL_ENCODINGS.put('\f', "\\f");
             SPECIAL_ENCODINGS.put('\r', "\\r");
             SPECIAL_ENCODINGS.put('\\', "\\\\");
         }
 
         static void escape(char c, StringBuilder b, boolean escapeForString) {
             // Check if the char is in the ACSII range.
 
             if (c == '"' && escapeForString //
                     || c == '\'' && !escapeForString) {
                 b.append("\\");
                 b.append(c);
 
             } else if (CONTROL_CODES.contains(c)) {
                 String charString = Integer.toHexString(c);
                 b.append("\\u");
                 b.append("0000".substring(charString.length()));
                 b.append(charString);
 
             } else if (SPECIAL_ENCODINGS.containsKey(c)) {
                 b.append(SPECIAL_ENCODINGS.get(c));
 
             } else {
                 b.append(c);
             }
         }
 
         @Override
         public char toChar() {
             return (Character) val;
         }
     }
 
     /**
      * CLASS LITERAL
      */
     static class MClassLiteral extends MLiteral implements ClassLiteral {
 
         MClassLiteral(MVM vm, ClassType val) {
             super(vm, val, val, val.toString() + ".class");
         }
 
     }
 
     /**
      * DOUBLE LITERAL
      */
     static class MDoubleLiteral extends MLiteral implements DoubleLiteral {
 
         MDoubleLiteral(MVM vm, double val) {
             super(vm, vm.DOUBLE, val, Double.toString(val) + "D");
         }
 
         @Override
         public double toDouble() {
             return (Double) val;
         }
     }
 
     /**
      * FALSE LITERAL
      */
     static class MFalse extends MBooleanLiteral implements False {
 
         MFalse(MVM vm) {
             super(vm, false);
         }
     }
 
     /**
      * FLOAT LITERAL
      */
     static class MFloatLiteral extends MLiteral implements FloatLiteral {
 
         MFloatLiteral(MVM vm, float val) {
             super(vm, vm.FLOAT, val, Float.toString(val) + "F");
         }
 
         @Override
         public float toFloat() {
             return (Float) val;
         }
     }
 
     /**
      * INT LITERAL
      */
     static class MIntLiteral extends MLiteral implements IntLiteral {
 
         MIntLiteral(MVM vm, int val) {
             super(vm, vm.INT, val, Integer.toString(val));
         }
 
         @Override
         public int toInt() {
             return (Integer) val;
         }
     }
 
     /**
      * LONG LITERAL
      */
     static class MLongLiteral extends MLiteral implements LongLiteral {
 
         MLongLiteral(MVM vm, long val) {
             super(vm, vm.LONG, val, Long.toString(val) + 'L');
         }
 
         @Override
         public long toLong() {
             return (Long) val;
         }
     }
 
     /**
      * NULL LITERAL
      */
     static class MNull extends MLiteral implements Null {
 
         MNull(MVM vm) {
             super(vm, vm.NULL, null, "null");
         }
     }
 
     /**
      * OCTAL LITERAL
      */
     static class MOctalLiteral extends MCharLiteral implements OctalLiteral {
 
         MOctalLiteral(MVM vm, char val) {
             super(vm, val);
             label = "'\\" + Integer.toOctalString(val) + "'";
         }
     }
 
     /**
      * SCIENTIFIC LITERAL
      */
     static class MScientificLiteral extends MLiteral implements ScientificLiteral {
 
         final int precision;
 
         final int scale;
 
         final int exponent;
 
         MScientificLiteral(MVM vm, int precision, int scale, int exponent) {
             super(vm, vm.DOUBLE, null, format("%d.%de%d", precision, scale, exponent));
             this.precision = precision;
             this.scale = scale;
             this.exponent = exponent;
         }
 
         @Override
         public int getExponent() {
             return exponent;
         }
 
         @Override
         public int getPrecision() {
             return precision;
         }
 
         @Override
         public int getScale() {
             return scale;
         }
     }
 
     /**
      * SHORT LITERAL
      */
     static class MShortLiteral extends MLiteral implements ShortLiteral {
 
         MShortLiteral(MVM vm, short val) {
             super(vm, vm.SHORT, val, "(short) " + val);
         }
 
         @Override
         public short toShort() {
             return (short) val;
         }
     }
 
     /**
      * STRING LITERAL
      */
     static class MStringLiteral extends MLiteral implements StringLiteral {
 
         MStringLiteral(MVM vm, String val) {
             super(vm, vm.STRING, val, escapeValue(val));
         }
 
         private static void escape(String s, StringBuilder b) {
             // Cache the length of the String to escape.
             int len = s.length();
             // Iterate over the length of the string.
             for (int i = 0; i < len; i++) {
                 MCharLiteral.escape(s.charAt(i), b, true);
             }
         }
 
         private static String escapeValue(String val) {
             StringBuilder b = new StringBuilder();
             b.append("\"");
             escape(val, b);
             b.append("\"");
             return b.toString();
         }
     }
 
     /**
      * TRUE LITERAL
      */
     static class MTrue extends MBooleanLiteral implements True {
 
         MTrue(MVM vm) {
             super(vm, true);
         }
     }
 
     /**
      * UNICODE LITERAL
      */
     static class MUnicodeLiteral extends MCharLiteral implements UnicodeLiteral {
 
         MUnicodeLiteral(MVM vm, char val) {
             super(vm, val);
             label = "'\\u" + Integer.toHexString(val) + "'";
         }
     }
 
     private Comment comment;
 
     private Type type;
 
     final Object val;
 
     String label;
 
     MLiteral(MVM vm, Type type, Object val, String label) {
         super(vm);
         this.type = type;
         this.val = val;
         this.label = label;
     }
 
     @Override
     public Comment getComment() {
         return comment;
     }
 
     public MLiteral setComment(Comment comment) {
         this.comment = comment;
         return this;
     }
 
     @Override
     public Type getType() {
         return type;
     }
 
     @Override
     public CodeWriter toCode(CodeWriter out) {
         out.queue(comment);
         out.write(label);
         return out;
     }
 
     @Override
     public Object toObject() {
         return val;
     }
 
     @Override
     public void visit(ReplacingVisitor visitor) {
         super.visit(visitor);
         type = VisitorUtils.visit(type, this, visitor);
         comment = VisitorUtils.visit(comment, this, visitor);
     }
 }