/* (c) https://github.com/MontiCore/monticore */
package de.monticore.literals;

/* This is a MontiCore stable grammar.
 * Adaptations -- if any -- are conservative. */

import de.monticore.literals.*;

/**
 * This grammar defines Java compliant literals.
 * The scope of this grammar is to
 * ease the reuse of literals structures in Java-like sublanguages, e.g., by 
 * grammar inheritance or grammar embedment.
 * The grammar contains literals from Java, e.g., Boolean, Char, String, ....
*/

component grammar MCCommonLiterals 
          extends de.monticore.MCBasics,
                  MCLiteralsBasis {


  /*========================================================================*/
  /*======================= INTERFACE DEFINITIONS ==========================*/
  /*========================================================================*/


  /** ASTSignedLiteral is the interface for all literals (NullLiteral,
        BooleanLiteral, CharLiteral, StringLiteral and all NumericLiterals).
        Compared to Literal it also includes negative NumericLiterals
    */
  interface SignedLiteral;


  /** The interface ASTNumericLiteral combines the numeric literal types for
        Integer, Long, Float and Double without '-' at the beginning)
    */
  interface NumericLiteral extends Literal <100>;


  /** The interface ASTNumericLiteral combines the numeric literal types for
        Integer, Long, Float and Double.
        Compared to NumericLiteral it also includes negative numbers.
    */
  interface SignedNumericLiteral extends SignedLiteral <100>;


  /*========================================================================*/
  /*============================ PARSER RULES ==============================*/
  /*========================================================================*/
  
  /** ASTNullLiteral represents 'null'
    */
  NullLiteral implements Literal, SignedLiteral =
    "null";


  /** ASTBooleanLiteral represents "true" or "false"
        @attribute source String-representation (including '"').
    */
  BooleanLiteral implements Literal, SignedLiteral =
    source:["true" | "false"];


  /** ASTCharLiteral represents any valid character parenthesized with "'".
        @attribute source String-representation (including "'").
    */
  CharLiteral implements Literal, SignedLiteral =
    source:Char;


  /** ASTStringLiteral represents any valid character sequence parenthesized
        with '"'.
        @attribute source String-representation (including '"').
    */
  StringLiteral implements Literal, SignedLiteral =
    source:String;


  /** ASTNatLiteral represents a positive Decimal number.
        @attribute source String-representation (including '"').
    */
  NatLiteral implements NumericLiteral<1> =
    Digits;

  /** ASTSignedNatLiteral represents a positive or negative Decimal number.
        @attribute source String-representation (including '"').
    */
  SignedNatLiteral implements SignedNumericLiteral<1> =
    {noSpace(2)}? (negative:["-"]) Digits |
                                   Digits;

  /** ASTLongLiteral represents a positive Decimal number.
         @attribute source String-representation (including '"').
    */
  BasicLongLiteral implements NumericLiteral<1> =
    { cmpToken(2,"l","L") && noSpace(2) }? Digits key("l" | "L");

  /** ASTSignedLongLiteral represents a positive or negative Decimal number.
         @attribute source String-representation (including '"').
    */
  SignedBasicLongLiteral implements SignedNumericLiteral<1> =
    { cmpToken(3,"l","L") && noSpace(2,3) }? 
      negative:["-"] Digits key("l" | "L") 
      |
    { cmpToken(2,"l","L") && noSpace(2) }? 
                     Digits key("l" | "L");

  /** ASTFloatLiteral represents a positive float.
        @attribute source String-representation (including '"').
    */
  BasicFloatLiteral implements NumericLiteral<1> =
    { cmpToken(4,"f","F") && noSpace(2,3,4) }?
      pre:Digits "." post:Digits key("f" | "F");

  /** ASTSignedFloatLiteral represents a positive or negative float.
        @attribute source String-representation (including '"').
    */
  SignedBasicFloatLiteral implements SignedNumericLiteral<1> =
    { cmpToken(5,"f","F") && noSpace(2,3,4,5)}?
      negative:["-"] pre:Digits "." post:Digits key("f" | "F") |
    { cmpToken(4,"f","F") && noSpace(2,3,4) }?
      pre:Digits "." post:Digits key("f" | "F");

  /** ASTDoubleLiteral represents a positive double.
        @attribute source String-representation (including '"').
    */
  BasicDoubleLiteral implements NumericLiteral<1> =
    { noSpace(2,3) }? pre:Digits "." post:Digits;

  /** ASTSignedDoubleLiteral represents a positive or negative double.
        @attribute source String-representation (including '"').
    */
  SignedBasicDoubleLiteral implements SignedNumericLiteral<1> =
    { noSpace(2,3,4) }? negative:["-"] pre:Digits "." post:Digits |
    { noSpace(2,3) }?                  pre:Digits "." post:Digits;

  /*========================================================================*/
  /*============================ LEXER RULES ===============================*/
  /*========================================================================*/
  

  /*========================================================================*/
  /* The following section is adapted from                                  */
  /* https://github.com/antlr/grammars-v4/blob/master/java/Java.g4          */
  /*========================================================================*/
  
  // §3.10.1 Integer Literals

  token Digits
    = Digit+;

  fragment token Digit
    = '0'..'9';

  // §3.10.4 Character Literals
  token Char
    = '\'' (SingleCharacter|EscapeSequence) '\''
    : {setText(getText().substring(1, getText().length() - 1));};

  fragment token SingleCharacter
    = ~ ('\'');


  // §3.10.5 String Literals
  token String
    = '"' (StringCharacters)? '"'
    : {setText(getText().substring(1, getText().length() - 1));};

  fragment token StringCharacters
    = (StringCharacter)+;

  fragment token StringCharacter
    = ~ ('"' | '\\') | EscapeSequence;


  // §3.10.6 Escape Sequences for Character and String Literals
  fragment token EscapeSequence
    = '\\' ('b' | 't' | 'n' | 'f' | 'r' | '"' | '\'' | '\\') 
      | OctalEscape | UnicodeEscape;

  fragment token OctalEscape
    = '\\' OctalDigit | '\\' OctalDigit OctalDigit 
      | '\\' ZeroToThree OctalDigit OctalDigit;

  fragment token UnicodeEscape
    = '\\' 'u' HexDigit HexDigit HexDigit HexDigit;

  fragment token ZeroToThree
    = '0'..'3' ;

  fragment token HexDigit
    = '0'..'9'  | 'a'..'f'  | 'A'..'F' ;

  fragment token OctalDigit
    = '0'..'7' ;


  /*========================================================================*/
  /*======================= AST DEFINITIONS ================================*/
  /*========================================================================*/

  astrule BooleanLiteral =
    method public boolean getValue() {
      return this.source == ASTConstantsMCCommonLiterals.TRUE;
    }
  ;

  astrule CharLiteral =
    method public char getValue() {
      return de.monticore.literals.MCLiteralsDecoder.decodeChar(
        getSource());
    }
  ;

  astrule StringLiteral =
    method public String getValue() {
      return de.monticore.literals.MCLiteralsDecoder.decodeString(
        getSource());
    }
  ;

   astrule NatLiteral =
    method public String getSource() {
         return getDigits();
    }
    method public int getValue() {
      return de.monticore.literals.MCLiteralsDecoder.decodeNat(
        getSource());
    }
  ;

  astrule SignedNatLiteral =
    method public String getSource() {
      return (negative?"-":"") + getDigits();
    }
    method public int getValue() {
      return de.monticore.literals.MCLiteralsDecoder.decodeNat(
        getSource());
    }
  ;

   astrule BasicLongLiteral =
    method public String getSource() {
         return getDigits() + "L";
    }
    method public long getValue() {
      return de.monticore.literals.MCLiteralsDecoder.decodeLong(getSource());
    }
  ;

  astrule SignedBasicLongLiteral =
    method public String getSource() {
      return (negative?"-":"") + getDigits() + "L";
    }
    method public long getValue() {
      return de.monticore.literals.MCLiteralsDecoder.decodeLong(getSource());
    }
  ;

  astrule BasicFloatLiteral =
    method public String getSource() {
      return getPre() + "." + getPost() + "F";
    }
    method public float getValue() {
      return de.monticore.literals.MCLiteralsDecoder.decodeFloat(getSource());
    }
  ;

  astrule SignedBasicFloatLiteral =
    method public String getSource() {
      return  (isNegative()?"-":"") + getPre() + "." + getPost() + "F";
    }
    method public float getValue() {
      return de.monticore.literals.MCLiteralsDecoder.decodeFloat(getSource());
    }
  ;

  astrule BasicDoubleLiteral =
    method public String getSource() {
      return getPre() + "." + getPost();
    }
    method public double getValue() {
      return de.monticore.literals.MCLiteralsDecoder.decodeDouble(getSource());
    }
  ;

  astrule SignedBasicDoubleLiteral =
    method public String getSource() {
      return (isNegative()?"-":"") + getPre() + "." + getPost();
    }
    method public double getValue() {
      return de.monticore.literals.MCLiteralsDecoder.decodeDouble(getSource());
    }
  ;

}