root/trunk/ProjectFortress/src/com/sun/fortress/parser/Literal.rats @ 2737

/*******************************************************************************
    Copyright 2008 Sun Microsystems, Inc.,
    4150 Network Circle, Santa Clara, California 95054, U.S.A.
    All rights reserved.

    U.S. Government Rights - Commercial software.
    Government users are subject to the Sun Microsystems, Inc. standard
    license agreement and applicable provisions of the FAR and its supplements.

    Use is subject to license terms.

    This distribution may include materials developed by third parties.

    Sun, Sun Microsystems, the Sun logo and Java are trademarks or registered
    trademarks of Sun Microsystems, Inc. in the U.S. and other countries.
 ******************************************************************************/

/*
 * Definition of Fortress literals.
 */
module com.sun.fortress.parser.Literal(MayNewlineHeader, DelimitedExpr,
                                       NoSpaceExpr, Symbol, Spacing,
                                       Identifier);

import MayNewlineHeader;
import DelimitedExpr;
import NoSpaceExpr;
import Symbol;
import Spacing;
import Identifier;

/* LiteralExpr ::=
     ( w )
   | NumericLiteralExpr
   | CharLiteralExpr
   | StringLiteralExpr
 */
Expr LiteralExpr =
     <VOID> VoidLiteralExpr
   / <NUMERICAL> NumericLiteralExpr
   / <CHAR>CharLiteralExpr
   / <STRING> StringLiteralExpr
   ;

/* ArrayExpr ::= [ StaticArgs? w RectElements w ] */
ArrayElements ArrayExpr =
     void:opensquare a1:StaticArgs? w a2:RectElements w void:closesquare
     { if (a1 == null) yyValue = FortressUtil.finalizeArrayExpr(a2);
       else            yyValue = FortressUtil.addStaticArgsToArrayExpr(a1, a2);
     };

/* RectElements ::= NoSpaceExpr MultiDimCons* */
private ArrayElements RectElements =
     a1:NoSpaceExpr a2s:MultiDimCons*
     { if (a2s == null || a2s.isEmpty()) {
             List<ArrayExpr> list = new ArrayList<ArrayExpr>();
             list.add(new ArrayElement(a1.getSpan(), false, a1));
             yyValue = new ArrayElements(a1.getSpan(), false, 1, list);
         } else
           yyValue = FortressUtil.multiDimCons(a1, a2s.list());
     };

/* MultiDimCons ::= RectSeparator NoSpaceExpr */
com.sun.fortress.useful.Pair<Integer,Expr> MultiDimCons =
     a1:RectSeparator a2:NoSpaceExpr
     { yyValue = new com.sun.fortress.useful.Pair<Integer,Expr>(a1,a2); };

Expr VoidLiteralExpr =
     <FIRST> openparen w closeparen
     { yyValue = ExprFactory.makeVoidLiteralExpr(createSpan(yyStart,yyCount)); };

NumberLiteralExpr NumericLiteralExpr =
    a1:NumericWord a2s:RestNumericWord+ "_" a3:RadixSpecifier &{ NodeUtil.validNumericLiteral(a1, a2s.list(), a3) }
    { String numeral = a1;
      for (String numericWord: a2s.list()) {
          numeral += numericWord;
      }
      yyValue = ExprFactory.makeFloatLiteralExpr(createSpan(yyStart,yyCount),
                                                 numeral+"_"+NodeUtil.radix2Number(a3));
    }
  / a1:NumericWord a2s:RestNumericWord+ &{ NodeUtil.validNumericLiteral(a1, a2s.size()) }
    { String numeral = a1;
      for (String numericWord: a2s.list()) {
          numeral += numericWord;
      }
      yyValue = ExprFactory.makeFloatLiteralExpr(createSpan(yyStart,yyCount), numeral);
    }
  / FloatLiteralExpr
  / IntLiteralExpr ;

private transient String RestNumericWord =
    a1:NumericSeparator a2:NumericWord { yyValue = a1+a2; };

transient FloatLiteralExpr FloatLiteralExpr =
    <ErrorProduction> DigitString dot DigitString (dot DigitString)+
    { yyValue = syntaxError(createSpan(yyStart,yyCount),
                            "Numerals contain no more than one `.' character.");
    }
  / <FIRST> a1:DigitString dot a2:DigitString
    { yyValue = ExprFactory.makeFloatLiteralExpr(createSpan(yyStart,yyCount),
                                                 a1 + "." + a2);
    };

transient IntLiteralExpr IntLiteralExpr =
    <FIRST> a1:NumericWord "_" a2:RadixSpecifier &{ NodeUtil.validNumericLiteral(a1, a2) }
    { Span span = createSpan(yyStart,yyCount);
      yyValue = ExprFactory.makeIntLiteralExpr(span, a1+"_"+NodeUtil.radix2Number(a2));
    }
  / a1:NumericWord &{ NodeUtil.validNumericLiteral(a1) }
    { yyValue = ExprFactory.makeIntLiteralExpr(createSpan(yyStart,yyCount), a1); }
  / a1:DigitString
    { yyValue = ExprFactory.makeIntLiteralExpr(createSpan(yyStart,yyCount),
                                               a1);
    };

private transient String NumericCharacter = [0-9a-zA-Z];
private transient String NumericWord =
    a1s:NumericCharacter+ a2s:(NumericSpace / NumericCharacter)* &{ NodeUtil.validNumericWord(a2s.list()) }
    { yyValue = "";
      for (String n: a1s.list()) {
          yyValue += n;
      }
      for (String n: a2s.list()) {
          yyValue += n;
      }
    };

private transient String NumericSpace = "'" / "\u202f" ;
private transient String NumericSeparator = "." ;

private transient String RadixSpecifier =
     RadixDigits
   / RadixNames ;

private transient String RadixDigits =
     "16"
   / "15"
   / "14"
   / "13"
   / "12"
   / "11"
   / "10"
   / "9"
   / "8"
   / "7"
   / "6"
   / "5"
   / "4"
   / "3"
   / "2" ;

private transient String RadixNames =
     "SIXTEEN"
   / "FIFTEEN"
   / "FOURTEEN"
   / "THIRTEEN"
   / "TWELVE"
   / "ELEVEN"
   / "TEN"
   / "NINE"
   / "EIGHT"
   / "SEVEN"
   / "SIX"
   / "FIVE"
   / "FOUR"
   / "THREE"
   / "TWO" ;

private transient String DigitString = [0-9]+;

CharLiteralExpr CharLiteralExpr =
     <FIRST> "'" a1:CharLiteralContent "'"
     { yyValue = ExprFactory.makeCharLiteralExpr(createSpan(yyStart,yyCount),
                                                 a1);
     };

StringLiteralExpr StringLiteralExpr =
     <FIRST> ["] a1:StringLiteralContent* ["]
     { String str = "";
       for (String c : (List<String>)a1.list()) {
           str = str.concat(c);
       }
       yyValue = new StringLiteralExpr(createSpan(yyStart,yyCount), false, str);
     };
private String StringLiteralContent =
     EscapeSequence
   / a1:(!["\\] _) { yyValue = String.valueOf(a1); };

private String EscapeSequence = '\\' a1:[btnfr"\\]
     { switch (a1) {
           case 'b': { yyValue = "\b"; break; }
           case 't': { yyValue = "\t"; break; }
           case 'n': { yyValue = "\n"; break; }
           case 'f': { yyValue = "\f"; break; }
           case 'r': { yyValue = "\r"; break; }
           case '"': { yyValue = "\""; break; }
           case '\'': { yyValue = "\'"; break; }
           case '\\': { yyValue = "\\"; break; }
           default: { yyValue = ""; }
       }
     };

private String CharLiteralContent =
     EscapeSequence
   / a1:(![\\] _) { yyValue = String.valueOf(a1); };