Experimental parser: rename YYCTYPE

src/lexer/experimental-scanner.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 211 matching lines @@
 
   bool harmony_numeric_literals_;
   bool harmony_modules_;
   bool harmony_scoping_;
 
  private:
   static std::set<ScannerBase*>* scanners_;
 };
 
 
-template<typename YYCTYPE>
+template<typename Char>
 class ExperimentalScanner : public ScannerBase {
  public:
   explicit ExperimentalScanner(
       Handle<String> source,
       Isolate* isolate)
       : ScannerBase(isolate),
         source_handle_(source),
         buffer_(NULL),
         buffer_end_(NULL),
         start_(NULL),
         cursor_(NULL),
         marker_(NULL) {
     ASSERT(source->IsFlat());
     SetBufferBasedOnHandle();
     Scan();
   }
 
   virtual ~ExperimentalScanner() { }
 
   virtual void Scan();
   virtual uc32 ScanHexNumber(int length);
 
   virtual void SetBufferBasedOnHandle() {
     // We get a raw pointer from the Handle, but we also update it every time
     // there is a GC, so it is safe.
     DisallowHeapAllocation no_gc;
-    const YYCTYPE* new_buffer = GetNewBufferBasedOnHandle();
+    const Char* new_buffer = GetNewBufferBasedOnHandle();
     if (new_buffer != buffer_) {
       int start_offset = start_ - buffer_;
       int cursor_offset = cursor_ - buffer_;
       int marker_offset = marker_ - buffer_;
       buffer_ = new_buffer;
       buffer_end_ = buffer_ + source_handle_->length();
       start_ = buffer_ + start_offset;
       cursor_ = buffer_ + cursor_offset;
       marker_ = buffer_ + marker_offset;
     }
   }
 
-  const YYCTYPE* GetNewBufferBasedOnHandle() const;
+  const Char* GetNewBufferBasedOnHandle() const;
 
  private:
   Handle<String> source_handle_;
-  const YYCTYPE* buffer_;
-  const YYCTYPE* buffer_end_;
-  const YYCTYPE* start_;
-  const YYCTYPE* cursor_;
-  const YYCTYPE* marker_;
+  const Char* buffer_;
+  const Char* buffer_end_;
+  const Char* start_;
+  const Char* cursor_;
+  const Char* marker_;
 };
 
 
-template<typename YYCTYPE>
-uc32 ExperimentalScanner<YYCTYPE>::ScanHexNumber(int length) {
+template<typename Char>
+uc32 ExperimentalScanner<Char>::ScanHexNumber(int length) {
   // We have seen \uXXXX, let's see what it is.
   // FIXME: we never end up in here if only a subset of the 4 chars are valid
   // hex digits -> handle the case where they're not.
   uc32 x = 0;
-  for (const YYCTYPE* s = cursor_ - length; s != cursor_; ++s) {
+  for (const Char* s = cursor_ - length; s != cursor_; ++s) {
     int d = HexValue(*s);
     if (d < 0) {
       return -1;
     }
     x = x * 16 + d;
   }
   return x;
 }
 
 
 } }
 
 #endif  // V8_LEXER_EXPERIMENTAL_SCANNER_H