iv-phonic 0.0.7 → 0.0.8

data/ext/include/iv/chars.h

@@ -3,78 +3,54 @@
 #include <cassert>
 #include <tr1/cstdint>
 #include "uchar.h"
-#include "ucdata.h"
+#include "character.h"
 
 namespace iv {
 namespace core {
 
 class Chars {
  public:
-  enum CharCategory {
-    UPPERCASE_LETTER = 1 << UC16::kUpperCaseLetter,
-    LOWERCASE_LETTER = 1 << UC16::kLowerCaseLetter,
-    TITLECASE_LETTER = 1 << UC16::kTitleCaseLetter,
-    MODIFIER_LETTER  = 1 << UC16::kModifierLetter,
-    OTHER_LETTER     = 1 << UC16::kOtherLetter,
-    NON_SPACING_MARK = 1 << UC16::kNonSpacingMark,
-    COMBINING_SPACING_MARK = 1 << UC16::kCombiningSpacingMark,
-    DECIMAL_DIGIT_NUMBER   = 1 << UC16::kDecimalDigitNumber,
-    SPACE_SEPARATOR = 1 << UC16::kSpaceSeparator,
-    CONNECTOR_PUNCTUATION  = 1 << UC16::kConnectorPunctuation
-  };
   static inline uint32_t Category(const int c) {
-    assert(c <= 0xffff+1);
-    return (c < 0) ? 1 : (1 << UnicodeData::kCategory[c]);
+    return (c < 0) ? 0 : character::GetCategory(c);
   }
   static inline bool IsASCII(const int c) {
-    return !(c & ~0x7F);
+    return (c >= 0) && character::IsASCII(c);
   }
   static inline bool IsASCIIAlpha(const int c) {
-    return (c | 0x20) >= 'a' && (c | 0x20) <= 'z';
+    return (c >= 0) && character::IsASCIIAlpha(c);
   }
   static inline bool IsASCIIAlphanumeric(const int c) {
-    return (c >= '0' && c <= '9') || ((c | 0x20) >= 'a' && (c | 0x20) <= 'z');
+    return (c >= 0) && character::IsASCIIAlphanumeric(c);
   }
   static inline bool IsNonASCIIIdentifierStart(const int c) {
-    return Category(c) & (UPPERCASE_LETTER | LOWERCASE_LETTER |
-                          TITLECASE_LETTER | MODIFIER_LETTER  | OTHER_LETTER);
+    return (c >= 0) && character::IsNonASCIIIdentifierStart(c);
   }
   static inline bool IsNonASCIIIdentifierPart(const int c) {
-    return Category(c) & (UPPERCASE_LETTER | LOWERCASE_LETTER |
-                          TITLECASE_LETTER | MODIFIER_LETTER  |
-                          OTHER_LETTER     | NON_SPACING_MARK |
-                          COMBINING_SPACING_MARK |
-                          DECIMAL_DIGIT_NUMBER   |
-                          CONNECTOR_PUNCTUATION);
+    return (c >= 0) && character::IsNonASCIIIdentifierPart(c);
   }
   static inline bool IsSeparatorSpace(const int c) {
-    return UnicodeData::kCategory[c] == UC16::kSpaceSeparator;
+    return (c >= 0) && character::IsSeparatorSpace(c);
   }
   static inline bool IsWhiteSpace(const int c) {
-    return IsASCII(c) ?
-        (c == ' ' || c == '\t' || c == 0xB || c == 0xC) : IsSeparatorSpace(c);
+    return (c >= 0) && character::IsWhiteSpace(c);
   }
   static inline bool IsLineTerminator(const int c) {
-    return c == '\r' || c == '\n' || (c & ~1) == 0x2028;
+    return (c >= 0) && character::IsLineTerminator(c);
   }
   static inline bool IsHexDigit(const int c) {
-    return (c >= '0' && c <= '9') || ((c | 0x20) >= 'a' && (c | 0x20) <= 'f');
+    return (c >= 0) && character::IsHexDigit(c);
   }
   static inline bool IsDecimalDigit(const int c) {
-    return c >= '0' && c <= '9';
+    return (c >= 0) && character::IsDecimalDigit(c);
   }
   static inline bool IsOctalDigit(const int c) {
-    return c >= '0' && c <= '7';
+    return (c >= 0) && character::IsOctalDigit(c);
   }
   static inline bool IsIdentifierStart(const int c) {
-    return IsASCII(c) ? c == '$'  || c == '_' ||
-                        c == '\\' || IsASCIIAlpha(c) :
-                        IsNonASCIIIdentifierStart(c);
+    return (c >= 0) && character::IsIdentifierStart(c);
   }
   static inline bool IsIdentifierPart(const int c) {
-    return IsASCII(c) ? c == '$'  || c == '_' ||
-                        c == '\\' || IsASCIIAlphanumeric(c) :
-                        IsNonASCIIIdentifierPart(c);
+    return (c >= 0) && character::IsIdentifierPart(c);
   }
 };
 

data/ext/include/iv/conversions.h

@@ -1,12 +1,13 @@
-#ifndef IV_CONVERSIONS_H_
-#define IV_CONVERSIONS_H_
+#ifndef _IV_CONVERSIONS_H_
+#define _IV_CONVERSIONS_H_
 #include <cstdio>
 #include <cmath>
 #include <string>
 #include <limits>
 #include <tr1/array>
 #include <tr1/cstdint>
-#include "chars.h"
+#include <tr1/cmath>
+#include "character.h"
 #include "dtoa.h"
 #include "ustringpiece.h"
 #include "none.h"
@@ -60,7 +61,7 @@ inline double StringToDouble(Iter it, Iter last, bool parse_float) {
   }
 
   while (it != last &&
-         (Chars::IsWhiteSpace(*it) || Chars::IsLineTerminator(*it))) {
+         (character::IsWhiteSpace(*it) || character::IsLineTerminator(*it))) {
     ++it;
   }
 
@@ -83,7 +84,7 @@ inline double StringToDouble(Iter it, Iter last, bool parse_float) {
     return Conversions::kNaN;
   }
 
-  if (Chars::IsDecimalDigit(*it)) {
+  if (character::IsDecimalDigit(*it)) {
     if (*it == '0') {
       is_found_zero = true;
       ++it;
@@ -99,14 +100,14 @@ inline double StringToDouble(Iter it, Iter last, bool parse_float) {
         buffer[pos++] = *it;
         ++it;
         ++significant_digits;
-        if (it == last || !Chars::IsHexDigit(*it)) {
+        if (it == last || !character::IsHexDigit(*it)) {
           return Conversions::kNaN;
         }
         // waste leading zero
         while (it != last && *it == '0') {
           ++it;
         }
-        while (it != last && Chars::IsHexDigit(*it)) {
+        while (it != last && character::IsHexDigit(*it)) {
           if (significant_digits < Conversions::kMaxSignificantDigits) {
             buffer[pos++] = *it;
             ++it;
@@ -124,7 +125,7 @@ inline double StringToDouble(Iter it, Iter last, bool parse_float) {
     }
     if (is_decimal) {
       while (it != last &&
-             Chars::IsDecimalDigit(*it)) {
+             character::IsDecimalDigit(*it)) {
         if (significant_digits < Conversions::kMaxSignificantDigits) {
           buffer[pos++] = *it;
           ++significant_digits;
@@ -137,7 +138,7 @@ inline double StringToDouble(Iter it, Iter last, bool parse_float) {
         buffer[pos++] = '.';
         ++it;
         while (it != last &&
-               Chars::IsDecimalDigit(*it)) {
+               character::IsDecimalDigit(*it)) {
           if (significant_digits < Conversions::kMaxSignificantDigits) {
             buffer[pos++] = *it;
             ++significant_digits;
@@ -152,7 +153,7 @@ inline double StringToDouble(Iter it, Iter last, bool parse_float) {
       ++it;
       const Iter start = it;
       while (it != last &&
-             Chars::IsDecimalDigit(*it)) {
+             character::IsDecimalDigit(*it)) {
         if (significant_digits < Conversions::kMaxSignificantDigits) {
           buffer[pos++] = *it;
           ++significant_digits;
@@ -173,7 +174,8 @@ inline double StringToDouble(Iter it, Iter last, bool parse_float) {
       }
       // infinity
       while (it != last &&
-             (Chars::IsWhiteSpace(*it) || Chars::IsLineTerminator(*it))) {
+             (character::IsWhiteSpace(*it) ||
+              character::IsLineTerminator(*it))) {
         ++it;
       }
       if (it == last || parse_float) {
@@ -209,7 +211,7 @@ inline double StringToDouble(Iter it, Iter last, bool parse_float) {
       ++it;
       is_signed_exp = true;
     }
-    if (it == last || !Chars::IsDecimalDigit(*it)) {
+    if (it == last || !character::IsDecimalDigit(*it)) {
       if (parse_float) {
         --it;
         --pos;
@@ -229,7 +231,7 @@ inline double StringToDouble(Iter it, Iter last, bool parse_float) {
         exponent = exponent * 10 + (*it - '0');
       }
       ++it;
-    } while (it != last && Chars::IsDecimalDigit(*it));
+    } while (it != last && character::IsDecimalDigit(*it));
     exponent+=insignificant_digits;
     if (exponent > 9999) {
       exponent = 9999;
@@ -242,7 +244,7 @@ inline double StringToDouble(Iter it, Iter last, bool parse_float) {
   exponent_pasing_done:
 
   while (it != last &&
-         (Chars::IsWhiteSpace(*it) || Chars::IsLineTerminator(*it))) {
+         (character::IsWhiteSpace(*it) || character::IsLineTerminator(*it))) {
     ++it;
   }
 
@@ -305,7 +307,7 @@ inline double StringToIntegerWithRadix(Iter it, Iter last,
                                        int radix, bool strip_prefix) {
   // remove leading white space
   while (it != last &&
-         (Chars::IsWhiteSpace(*it) || Chars::IsLineTerminator(*it))) {
+         (character::IsWhiteSpace(*it) || character::IsLineTerminator(*it))) {
     ++it;
   }
 
@@ -411,6 +413,27 @@ inline uint32_t DoubleToUInt32(double d) {
   return static_cast<uint32_t>(DoubleToInt32(d));
 }
 
+inline int64_t DoubleToInt64(double d) {
+  int64_t i = static_cast<int64_t>(d);
+  if (static_cast<double>(i) == d) {
+    return i;
+  }
+  if (!std::isfinite(d) || d == 0) {
+    return 0;
+  }
+  if (Conversions::DoubleToInt32_Two32 >= d) {
+    return static_cast<int64_t>(DoubleToInt32(d));
+  }
+  const int32_t lo = DoubleToInt32(
+      std::fmod(d, Conversions::DoubleToInt32_Two32));
+  const int32_t hi = DoubleToInt32(d / Conversions::DoubleToInt32_Two32);
+  return hi * 4294967296ULL + lo;
+}
+
+inline uint64_t DoubleToUInt64(double d) {
+  return static_cast<uint64_t>(DoubleToInt64(d));
+}
+
 inline double DoubleToInteger(double d) {
   if (std::isnan(d)) {
     return 0;
@@ -434,7 +457,7 @@ inline bool ConvertToUInt32(Iter it, const Iter last, uint32_t* value) {
       return true;
     }
   }
-  if (it != last && Chars::IsDecimalDigit(*it)) {
+  if (it != last && character::IsDecimalDigit(*it)) {
     ch = *it - '0';
     *value = ch;
   } else {
@@ -444,7 +467,7 @@ inline bool ConvertToUInt32(Iter it, const Iter last, uint32_t* value) {
   uint32_t prev = *value;
   for (;it != last; ++it) {
     prev = *value;
-    if (Chars::IsDecimalDigit(*it)) {
+    if (character::IsDecimalDigit(*it)) {
       ch = *it - '0';
       *value = ch + (prev * 10);
     } else {
@@ -512,4 +535,4 @@ inline std::string DoubleToStringWithRadix(double v, int radix) {
 }
 
 } }  // namespace iv::core
-#endif  // IV_CONVERSIONS_H_
+#endif  // _IV_CONVERSIONS_H_

data/ext/include/iv/dtoa.h

@@ -1,5 +1,5 @@
-#ifndef IV_LV5_DTOA_H_
-#define IV_LV5_DTOA_H_
+#ifndef _IV_DTOA_H_
+#define _IV_DTOA_H_
 // Double to String
 
 // David M Gay's algorithm and V8 fast-dtoa
@@ -16,5 +16,5 @@ namespace core {
 
 using v8::internal::DoubleToCString;
 
-} }  // namespace iv::lv5
-#endif  // IV_LV5_DTOA_H_
+} }  // namespace iv::core
+#endif  // _IV_DTOA_H_

data/ext/include/iv/lexer.h

@@ -364,7 +364,7 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
     return buffer16_;
   }
 
-  inline const std::string& Buffer8() const {
+  inline const std::vector<char>& Buffer8() const {
     return buffer8_;
   }
 
@@ -482,6 +482,17 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
     Advance();
   }
 
+  void Initialize(const Source* src) {
+    using std::swap;
+    source_ = src;
+    pos_ = 0;
+    end_ = source_->size();
+    has_line_terminator_before_next_ = false;
+    has_shebang_ = false;
+    line_number_ = 1;
+    swap(location_, Location());
+  }
+
   inline void Advance() {
     if (pos_ == end_) {
       c_ = -1;
@@ -795,13 +806,14 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
 
     if (type == OCTAL) {
       double val = 0;
-      for (std::string::const_iterator it = buffer8_.begin(),
+      for (typename std::vector<char>::const_iterator it = buffer8_.begin(),
            last = buffer8_.end(); it != last; ++it) {
         val = val * 8 + (*it - '0');
       }
       numeric_ = val;
     } else {
-      numeric_ = std::atof(buffer8_.c_str());
+      const std::string buf(buffer8_.begin(), buffer8_.end());
+      numeric_ = std::atof(buf.c_str());
     }
     type_ = type;
     return Token::NUMBER;
@@ -857,7 +869,7 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
   }
 
   const Source* source_;
-  std::string buffer8_;
+  std::vector<char> buffer8_;
   std::vector<uc16> buffer16_;
   double numeric_;
   State type_;

data/ext/include/iv/location.h

@@ -23,7 +23,9 @@ struct Location {
   }
 };
 
+#if defined(__GNUC__) && (__GNUC__ >= 4) && (__GNUC_MINOR__ >= 3)
 IV_STATIC_ASSERT(std::tr1::is_pod<Location>::value);
+#endif
 
 } }  // namespace iv::core
 #endif  // _IV_LOCATION_H_

data/ext/include/iv/parser.h

@@ -13,6 +13,7 @@
 #include "noncopyable.h"
 #include "utils.h"
 #include "ustring.h"
+#include "enable_if.h"
 #include "none.h"
 
 #define IS(token)\
@@ -134,11 +135,12 @@ const UString ParserData<T>::kSet(
 
 typedef detail::ParserData<None> ParserData;
 
-template<typename Factory, typename Source>
-class Parser : private Noncopyable<Parser<Factory, Source> >::type {
+template<typename Factory, typename Source, bool UseFunctionStatement>
+class Parser
+  : private Noncopyable<Parser<Factory, Source, UseFunctionStatement> >::type {
  public:
-  typedef Parser<Factory, Source> this_type;
-  typedef Parser<Factory, Source> parser_type;
+  typedef Parser<Factory, Source, UseFunctionStatement> this_type;
+  typedef this_type parser_type;
   typedef Lexer<Source> lexer_type;
 #define V(AST) typedef typename ast::AST<Factory> AST;
   AST_NODE_LIST(V)
@@ -213,7 +215,7 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
 
   class TargetScope : private Noncopyable<Target>::type {
    public:
-    TargetScope(parser_type* parser)
+    explicit TargetScope(parser_type* parser)
       : parser_(parser),
         target_(parser->target()),
         labels_(parser->labels()) {
@@ -266,33 +268,39 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
 //   : Statements
 //   | FunctionDeclaration
   bool ParseSourceElements(Token::Type end,
-                           FunctionLiteral* function, bool *res) {
+                           FunctionLiteral* function,
+                           bool *res) {
     Statement* stmt;
-    bool recognize_use_strict_directive = true;
+    bool recognize_directive = true;
     const StrictSwitcher switcher(this);
     while (token_ != end) {
       if (token_ == Token::FUNCTION) {
         // FunctionDeclaration
         stmt = ParseFunctionDeclaration(CHECK);
         function->AddStatement(stmt);
+        recognize_directive = false;
       } else {
         stmt = ParseStatement(CHECK);
-        // use strict directive check
-        if (recognize_use_strict_directive &&
-            !strict_ &&
-            stmt->AsExpressionStatement()) {
-          Expression* const expr = stmt->AsExpressionStatement()->expr();
-          if (expr->AsDirectivable()) {
-            if (expr->AsStringLiteral()->value().compare(
-                    ParserData::kUseStrict.data()) == 0) {
-              switcher.SwitchStrictMode();
-              function->set_strict(true);
+        // directive prologue
+        if (recognize_directive) {
+          if (stmt->AsExpressionStatement()) {
+            Expression* const expr = stmt->AsExpressionStatement()->expr();
+            if (expr->AsDirectivable()) {
+              // expression is directive
+              if (expr->AsStringLiteral()->value().compare(
+                      ParserData::kUseStrict.data()) == 0) {
+                switcher.SwitchStrictMode();
+                function->set_strict(true);
+              }
+            } else {
+              recognize_directive = false;
             }
+          } else {
+            recognize_directive = false;
           }
         }
         function->AddStatement(stmt);
       }
-      recognize_use_strict_directive = false;
     }
     return true;
   }
@@ -402,7 +410,7 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
       case Token::FUNCTION:
         // FunctionStatement (not in ECMA-262 5th)
         // FunctionExpression
-        result = ParseFunctionStatement(CHECK);
+        result = ParseFunctionStatement<UseFunctionStatement>(CHECK);
         break;
 
       case Token::IDENTIFIER:
@@ -784,6 +792,13 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
   Statement* ParseReturnStatement(bool *res) {
     assert(token_ == Token::RETURN);
     Next();
+
+    if (scope_->IsGlobal()) {
+      // return statement found in global
+      // SyntaxError
+      RAISE("\"return\" not in function");
+    }
+
     if (lexer_.has_line_terminator_before_next() ||
         token_ == Token::SEMICOLON ||
         token_ == Token::RBRACE ||
@@ -839,8 +854,21 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
 
     EXPECT(Token::LBRACE);
 
+    bool default_found = false;
     while (token_ != Token::RBRACE) {
-      case_clause = ParseCaseClause(CHECK);
+      if (token_ == Token::CASE ||
+          token_ == Token::DEFAULT) {
+        case_clause = ParseCaseClause(CHECK);
+      } else {
+        UNEXPECT(token_);
+      }
+      if (case_clause->IsDefault()) {
+        if (default_found) {
+          RAISE("duplicate default clause in switch");
+        } else {
+          default_found = true;
+        }
+      }
       switch_stmt->AddCaseClause(case_clause);
     }
     Next();
@@ -918,6 +946,7 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
 
     Next();
 
+    IS(Token::LBRACE);
     Block* const try_block = ParseBlock(CHECK);
 
     if (token_ == Token::CATCH) {
@@ -942,6 +971,7 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
         }
       }
       EXPECT(Token::RPAREN);
+      IS(Token::LBRACE);
       catch_block = ParseBlock(CHECK);
     }
 
@@ -949,6 +979,7 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
       // Finally
       has_catch_or_finally= true;
       Next();
+      IS(Token::LBRACE);
       finally_block = ParseBlock(CHECK);
     }
 
@@ -1008,7 +1039,9 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
     return factory_->NewExpressionStatement(expr);
   }
 
-  Statement* ParseFunctionStatement(bool *res) {
+  template<bool Use>
+  Statement* ParseFunctionStatement(bool *res,
+                                    typename enable_if_c<Use>::type* = 0) {
     assert(token_ == Token::FUNCTION);
     if (strict_) {
       RAISE("function statement not allowed in strict code");
@@ -1022,6 +1055,15 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
     return factory_->NewFunctionStatement(expr);
   }
 
+  template<bool Use>
+  Statement* ParseFunctionStatement(bool *res,
+                                    typename enable_if_c<!Use>::type* = 0) {
+    // FunctionStatement is not Standard
+    // so, if template parameter UseFunctionStatement is false,
+    // this parser reject FunctionStatement
+    RAISE("function statement is not Standard");
+  }
+
 //  Expression
 //    : AssignmentExpression
 //    | Expression ',' AssignmentExpression
@@ -1614,14 +1656,16 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
   template<typename Callable>
   Callable* ParseArguments(Callable* func, bool *res) {
     Next();
-    while (token_ != Token::RPAREN) {
-      Expression* const expr = ParseAssignmentExpression(true, CHECK);
-      func->AddArgument(expr);
-      if (token_ != Token::RPAREN) {
-        EXPECT(Token::COMMA);
+    if (token_ != Token::RPAREN) {
+      Expression* const first = ParseAssignmentExpression(true, CHECK);
+      func->AddArgument(first);
+      while (token_ == Token::COMMA) {
+        Next();
+        Expression* const expr = ParseAssignmentExpression(true, CHECK);
+        func->AddArgument(expr);
       }
     }
-    Next();
+    EXPECT(Token::RPAREN);
     return func;
   }
 
@@ -1871,29 +1915,33 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
       literal->AddParameter(ident);
       EXPECT(Token::RPAREN);
     } else {
-      while (token_ != Token::RPAREN) {
-        IS(Token::IDENTIFIER);
-        Identifier* const ident = ParseIdentifier(lexer_.Buffer());
-        if (!throw_error_if_strict_code) {
-          const EvalOrArguments val = IsEvalOrArguments(ident);
-          if (val) {
-            throw_error_if_strict_code = (val == kEval) ?
-                kDetectEvalParameter : kDetectArgumentsParameter;
-            throw_error_if_strict_code_line = lexer_.line_number();
+      if (token_ != Token::RPAREN) {
+        do {
+          IS(Token::IDENTIFIER);
+          Identifier* const ident = ParseIdentifier(lexer_.Buffer());
+          if (!throw_error_if_strict_code) {
+            const EvalOrArguments val = IsEvalOrArguments(ident);
+            if (val) {
+              throw_error_if_strict_code = (val == kEval) ?
+                  kDetectEvalParameter : kDetectArgumentsParameter;
+              throw_error_if_strict_code_line = lexer_.line_number();
+            }
+            if ((!throw_error_if_strict_code) &&
+                (param_set.find(ident) != param_set.end())) {
+              throw_error_if_strict_code = kDetectDuplicateParameter;
+              throw_error_if_strict_code_line = lexer_.line_number();
+            }
           }
-          if ((!throw_error_if_strict_code) &&
-              (param_set.find(ident) != param_set.end())) {
-            throw_error_if_strict_code = kDetectDuplicateParameter;
-            throw_error_if_strict_code_line = lexer_.line_number();
+          literal->AddParameter(ident);
+          param_set.insert(ident);
+          if (token_ == Token::COMMA) {
+            Next();
+          } else {
+            break;
           }
-        }
-        literal->AddParameter(ident);
-        param_set.insert(ident);
-        if (token_ != Token::RPAREN) {
-          EXPECT(Token::COMMA);
-        }
+        } while (true);
       }
-      Next();
+      EXPECT(Token::RPAREN);
     }
 
     //  '{' FunctionBody '}'
@@ -2032,9 +2080,9 @@ class Parser : private Noncopyable<Parser<Factory, Source> >::type {
   void SetErrorHeader(std::size_t line) {
     std::tr1::array<char, 40> buf;
     error_.append(lexer_.filename());
-    int num = std::snprintf(buf.data(), buf.size(),
-                                 ":%lu: SyntaxError: ",
-                                 static_cast<unsigned long>(line));  // NOLINT
+    const int num = std::snprintf(buf.data(), buf.size(),
+                                  ":%lu: SyntaxError: ",
+                                  static_cast<unsigned long>(line));  // NOLINT
     error_.append(buf.data(), num);
   }