// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/natives.h"

#include "src/base/logging.h"
#include "src/list.h"
#include "src/list-inl.h"
#include "src/snapshot-source-sink.h"
#include "src/vector.h"

namespace v8 {
namespace internal {


/**
 * NativesStore stores the 'native' (builtin) JS libraries.
 *
 * NativesStore needs to be initialized before using V8, usually by the
 * embedder calling v8::SetNativesDataBlob, which calls SetNativesFromFile
 * below.
 */
class NativesStore {
 public:
  ~NativesStore() {}

  int GetBuiltinsCount() { return native_names_.length(); }
  int GetDebuggerCount() { return debugger_count_; }
  Vector<const char> GetScriptName(int index) { return native_names_[index]; }
  Vector<const char> GetRawScriptSource(int index) {
    return native_source_[index];
  }

  int GetIndex(const char* name) {
    for (int i = 0; i < native_names_.length(); ++i) {
      int native_name_length = native_names_[i].length();
      if ((static_cast<int>(strlen(name)) == native_name_length) &&
          (strncmp(name, native_names_[i].start(), native_name_length) == 0)) {
        return i;
      }
    }
    DCHECK(false);
    return -1;
  }

  int GetRawScriptsSize() {
    DCHECK(false);  // Used for compression. Doesn't really make sense here.
    return 0;
  }

  Vector<const byte> GetScriptsSource() {
    DCHECK(false);  // Used for compression. Doesn't really make sense here.
    return Vector<const byte>();
  }

  static NativesStore* MakeFromScriptsSource(SnapshotByteSource* source) {
    NativesStore* store = new NativesStore;

    // We expect the libraries in the following format:
    //   int: # of debugger sources.
    //   2N blobs: N pairs of source name + actual source.
    //   then, repeat for non-debugger sources.
    int debugger_count = source->GetInt();
    for (int i = 0; i < debugger_count; ++i)
      store->ReadNameAndContentPair(source);
    int library_count = source->GetInt();
    for (int i = 0; i < library_count; ++i)
      store->ReadNameAndContentPair(source);

    store->debugger_count_ = debugger_count;
    return store;
  }

 private:
  NativesStore() : debugger_count_(0) {}

  bool ReadNameAndContentPair(SnapshotByteSource* bytes) {
    const byte* name;
    int name_length;
    const byte* source;
    int source_length;
    bool success = bytes->GetBlob(&name, &name_length) &&
                   bytes->GetBlob(&source, &source_length);
    if (success) {
      Vector<const char> name_vector(
          reinterpret_cast<const char*>(name), name_length);
      Vector<const char> source_vector(
          reinterpret_cast<const char*>(source), source_length);
      native_names_.Add(name_vector);
      native_source_.Add(source_vector);
    }
    return success;
  }

  List<Vector<const char> > native_names_;
  List<Vector<const char> > native_source_;
  int debugger_count_;

  DISALLOW_COPY_AND_ASSIGN(NativesStore);
};


template<NativeType type>
class NativesHolder {
 public:
  static NativesStore* get() {
    DCHECK(holder_);
    return holder_;
  }
  static void set(NativesStore* store) {
    DCHECK(store);
    holder_ = store;
  }

 private:
  static NativesStore* holder_;
};

template<NativeType type>
NativesStore* NativesHolder<type>::holder_ = NULL;


/**
 * Read the Natives (library sources) blob, as generated by js2c + the build
 * system.
 */
void SetNativesFromFile(StartupData* natives_blob) {
  DCHECK(natives_blob);
  DCHECK(natives_blob->data);
  DCHECK(natives_blob->raw_size > 0);

  SnapshotByteSource bytes(
      reinterpret_cast<const byte*>(natives_blob->data),
      natives_blob->raw_size);
  NativesHolder<CORE>::set(NativesStore::MakeFromScriptsSource(&bytes));
  NativesHolder<EXPERIMENTAL>::set(NativesStore::MakeFromScriptsSource(&bytes));
  DCHECK(!bytes.HasMore());
}


// Implement NativesCollection<T> bsaed on NativesHolder + NativesStore.
//
// (The callers expect a purely static interface, since this is how the
//  natives are usually compiled in. Since we implement them based on
//  runtime content, we have to implement this indirection to offer
//  a static interface.)
template<NativeType type>
int NativesCollection<type>::GetBuiltinsCount() {
  return NativesHolder<type>::get()->GetBuiltinsCount();
}

template<NativeType type>
int NativesCollection<type>::GetDebuggerCount() {
  return NativesHolder<type>::get()->GetDebuggerCount();
}

template<NativeType type>
int NativesCollection<type>::GetIndex(const char* name) {
  return NativesHolder<type>::get()->GetIndex(name);
}

template<NativeType type>
int NativesCollection<type>::GetRawScriptsSize() {
  return NativesHolder<type>::get()->GetRawScriptsSize();
}

template<NativeType type>
Vector<const char> NativesCollection<type>::GetRawScriptSource(int index) {
  return NativesHolder<type>::get()->GetRawScriptSource(index);
}

template<NativeType type>
Vector<const char> NativesCollection<type>::GetScriptName(int index) {
  return NativesHolder<type>::get()->GetScriptName(index);
}

template<NativeType type>
Vector<const byte> NativesCollection<type>::GetScriptsSource() {
  return NativesHolder<type>::get()->GetScriptsSource();
}

template<NativeType type>
void NativesCollection<type>::SetRawScriptsSource(
    Vector<const char> raw_source) {
  CHECK(false);  // Use SetNativesFromFile for this implementation.
}


// The compiler can't 'see' all uses of the static methods and hence
// my chose to elide them. This we'll explicitly instantiate these.
template class NativesCollection<CORE>;
template class NativesCollection<EXPERIMENTAL>;
template class NativesCollection<D8>;
template class NativesCollection<TEST>;

}  // namespace v8::internal
}  // namespace v8