Fraction class prototype and test (not to be committed).

runtime/vm/parser.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 607 matching lines @@
 
 
 RawInteger* Parser::CurrentIntegerLiteral() const {
   literal_token_ ^= tokens_iterator_.CurrentToken();
   ASSERT(literal_token_.kind() == Token::kINTEGER);
   RawInteger* ri = Integer::RawCast(literal_token_.value());
   return ri;
 }
 
 
+RawFraction* Parser::CurrentRationalLiteral() const {
+  literal_token_ ^= tokens_iterator_.CurrentToken();
+  ASSERT(literal_token_.kind() == Token::kRATIONAL);
+  return Fraction::RawCast(literal_token_.value());
+}
+
+
 struct ParamDesc {
   ParamDesc()
       : type(NULL),
         name_pos(TokenPosition::kNoSource),
         name(NULL),
         default_value(NULL),
         metadata(NULL),
         var(NULL),
         is_final(false),
         is_field_initializer(false),
@@ skipping 3879 matching lines @@
     cls ^= obj.raw();
     if (is_patch) {
       // Preserve and reuse the original type parameters and bounds since the
       // ones defined in the patch class will not be finalized.
       orig_type_parameters = cls.type_parameters();
       cls = Class::New(library_, class_name, script_, declaration_pos);
     } else {
       // Not patching a class, but it has been found. This must be one of the
       // pre-registered classes from object.cc or a duplicate definition.
       if (!(cls.is_prefinalized() ||
+            cls.is_refinalize_after_patch() ||  // TODO(regis): Remove.
             RawObject::IsImplicitFieldClassId(cls.id()))) {
         ReportError(classname_pos, "class '%s' is already defined",
                     class_name.ToCString());
       }
       // Pre-registered classes need their scripts connected at this time.
       cls.set_script(script_);
       cls.set_token_pos(declaration_pos);
     }
   }
   ASSERT(!cls.IsNull());
@@ skipping 3384 matching lines @@
     // 'type' is not a type parameter (an unresolved type will not get resolved
     // to a type parameter later) and if 'type' has no type arguments, then it
     // will be instantiated at class finalization time. Otherwise, we return
     // false, since the type test would not be possible at finalization time for
     // an uninstantiated type.
     return false;
   }
   if (CurrentToken() == Token::kINTEGER) {
     *value = CurrentIntegerLiteral();
     return true;
+  } else if (CurrentToken() == Token::kRATIONAL) {
+    *value = CurrentRationalLiteral();
+    return true;
   } else if (CurrentToken() == Token::kDOUBLE) {
     *value = CurrentDoubleLiteral();
     return true;
   } else if (CurrentToken() == Token::kSTRING) {
     *value = CurrentLiteral()->raw();
     return true;
   } else if (CurrentToken() == Token::kTRUE) {
     *value = Bool::True().raw();
     return true;
   } else if (CurrentToken() == Token::kFALSE) {
@@ skipping 6135 matching lines @@
     ConsumeToken();
   } else if (token == Token::kNULL) {
     primary = new(Z) LiteralNode(TokenPos(), Object::null_instance());
     ConsumeToken();
   } else if (token == Token::kLPAREN) {
     ConsumeToken();
     const bool saved_mode = SetAllowFunctionLiterals(true);
     primary = ParseExpr(kAllowConst, kConsumeCascades);
     SetAllowFunctionLiterals(saved_mode);
     ExpectToken(Token::kRPAREN);
+  } else if (token == Token::kRATIONAL) {
+    const Fraction& rational_value =
+        Fraction::ZoneHandle(Z, CurrentRationalLiteral());
+    if (rational_value.IsNull()) {
+      ReportError("invalid rational literal");
+    }
+    primary = new(Z) LiteralNode(TokenPos(), rational_value);
+    ConsumeToken();
   } else if (token == Token::kDOUBLE) {
     const Double& double_value = Double::ZoneHandle(Z, CurrentDoubleLiteral());
     if (double_value.IsNull()) {
       ReportError("invalid double literal");
     }
     primary = new(Z) LiteralNode(TokenPos(), double_value);
     ConsumeToken();
   } else if (token == Token::kSTRING) {
     primary = ParseStringLiteral(true);
   } else if (token == Token::kNEW) {
@@ skipping 273 matching lines @@
     SkipFunctionLiteral();
     return;
   }
   switch (CurrentToken()) {
     case Token::kTHIS:
     case Token::kSUPER:
     case Token::kNULL:
     case Token::kTRUE:
     case Token::kFALSE:
     case Token::kINTEGER:
+    case Token::kRATIONAL:
     case Token::kDOUBLE:
       ConsumeToken();
       break;
     case Token::kIDENT:
       ConsumeToken();
       break;
     case Token::kSTRING:
       SkipStringLiteral();
       break;
     case Token::kLPAREN:
@@ skipping 251 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME