/*

 * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "classfile/genericSignatures.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "memory/resourceArea.hpp"

namespace generic {

// Helper class for parsing the generic signature Symbol in klass and methods

class DescriptorStream : public ResourceObj {

 private:

  Symbol* _symbol;

  int _offset;

  int _mark;

  const char* _parse_error;

  void set_parse_error(const char* error) {

    assert(error != NULL, "Can't set NULL error string");

    _parse_error = error;

  }

 public:

  DescriptorStream(Symbol* sym)

      : _symbol(sym), _offset(0), _mark(-1), _parse_error(NULL) {}

  const char* parse_error() const {

    return _parse_error;

  }

  bool at_end() { return _offset >= _symbol->utf8_length(); }

  char peek() {

    if (at_end()) {

      set_parse_error("Peeking past end of signature");

      return '\0';

    } else {

      return _symbol->byte_at(_offset);

    }

  }

  char read() {

    if (at_end()) {

      set_parse_error("Reading past end of signature");

      return '\0';

    } else {

      return _symbol->byte_at(_offset++);

    }

  }

  void read(char expected) {

    char c = read();

    assert_char(c, expected, 0);

  }

  void assert_char(char c, char expected, int pos = -1) {

    if (c != expected) {

      const char* fmt = "Parse error at %d: expected %c but got %c";

      size_t len = strlen(fmt) + 5;

      char* buffer = NEW_RESOURCE_ARRAY(char, len);

      jio_snprintf(buffer, len, fmt, _offset + pos, expected, c);

      set_parse_error(buffer);

    }

  }

  void push(char c) {

    assert(c == _symbol->byte_at(_offset - 1), "Pushing back wrong value");

    --_offset;

  }

  void expect_end() {

    if (!at_end()) {

      set_parse_error("Unexpected data trailing signature");

    }

  }

  bool has_mark() { return _mark != -1; }

  void set_mark() {

    _mark = _offset;

  }

  Identifier* identifier_from_mark() {

    assert(has_mark(), "Mark should be set");

    if (!has_mark()) {

      set_parse_error("Expected mark to be set");

      return NULL;

    } else {

      Identifier* id = new Identifier(_symbol, _mark, _offset - 1);

      _mark = -1;

      return id;

    }

  }

};

#define CHECK_FOR_PARSE_ERROR()         \

  if (STREAM->parse_error() != NULL) {   \

    if (VerifyGenericSignatures) {      \

      fatal(STREAM->parse_error());      \

    }                                   \

    return NULL;                        \

  } 0

#define READ() STREAM->read(); CHECK_FOR_PARSE_ERROR()

#define PEEK() STREAM->peek(); CHECK_FOR_PARSE_ERROR()

#define PUSH(c) STREAM->push(c)

#define EXPECT(c) STREAM->read(c); CHECK_FOR_PARSE_ERROR()

#define EXPECTED(c, ch) STREAM->assert_char(c, ch); CHECK_FOR_PARSE_ERROR()

#define EXPECT_END() STREAM->expect_end(); CHECK_FOR_PARSE_ERROR()

#define CHECK_STREAM STREAM); CHECK_FOR_PARSE_ERROR(); (0

#ifndef PRODUCT

void Identifier::print_on(outputStream* str) const {

  for (int i = _begin; i < _end; ++i) {

    str->print("%c", (char)_sym->byte_at(i));

  }

}

#endif // ndef PRODUCT

bool Identifier::equals(Identifier* other) {

  if (_sym == other->_sym && _begin == other->_begin && _end == other->_end) {

    return true;

  } else if (_end - _begin != other->_end - other->_begin) {

    return false;

  } else {

    size_t len = _end - _begin;

    char* addr = ((char*)_sym->bytes()) + _begin;

    char* oaddr = ((char*)other->_sym->bytes()) + other->_begin;

    return strncmp(addr, oaddr, len) == 0;

  }

}

bool Identifier::equals(Symbol* sym) {

  Identifier id(sym, 0, sym->utf8_length());

  return equals(&id);

}

/**

 * A formal type parameter may be found in the the enclosing class, but it could

 * also come from an enclosing method or outer class, in the case of inner-outer

 * classes or anonymous classes.  For example:

 *

 * class Outer<T,V> {

 *   class Inner<W> {

 *     void m(T t, V v, W w);

 *   }

 * }

 *

 * In this case, the type variables in m()'s signature are not all found in the

 * immediate enclosing class (Inner).  class Inner has only type parameter W,

 * but it's outer_class field will reference Outer's descriptor which contains

 * T & V (no outer_method in this case).

 *

 * If you have an anonymous class, it has both an enclosing method *and* an

 * enclosing class where type parameters can be declared:

 *

 * class MOuter<T> {

 *   <V> void bar(V v) {

 *     Runnable r = new Runnable() {

 *       public void run() {}

 *       public void foo(T t, V v) { ... }

 *     };

 *   }

 * }

 *

 * In this case, foo will be a member of some class, Runnable$1, which has no

 * formal parameters itself, but has an outer_method (bar()) which provides

 * type parameter V, and an outer class MOuter with type parameter T.

 *

 * It is also possible that the outer class is itself an inner class to some

 * other class (or an anonymous class with an enclosing method), so we need to

 * follow the outer_class/outer_method chain to it's end when looking for a

 * type parameter.

 */

TypeParameter* Descriptor::find_type_parameter(Identifier* id, int* depth) {

  int current_depth = 0;

  MethodDescriptor* outer_method = as_method_signature();

  ClassDescriptor* outer_class = as_class_signature();

  if (outer_class == NULL) { // 'this' is a method signature; use the holder

    outer_class = outer_method->outer_class();

  }

  while (outer_method != NULL || outer_class != NULL) {

    if (outer_method != NULL) {

      for (int i = 0; i < outer_method->type_parameters().length(); ++i) {

        TypeParameter* p = outer_method->type_parameters().at(i);

        if (p->identifier()->equals(id)) {

          *depth = -1; // indicates this this is a method parameter

          return p;

        }

      }

    }

    if (outer_class != NULL) {

      for (int i = 0; i < outer_class->type_parameters().length(); ++i) {

        TypeParameter* p = outer_class->type_parameters().at(i);

        if (p->identifier()->equals(id)) {

          *depth = current_depth;

          return p;

        }

      }

      outer_method = outer_class->outer_method();

      outer_class = outer_class->outer_class();

      ++current_depth;

    }

  }

  if (VerifyGenericSignatures) {

    fatal("Could not resolve identifier");

  }

  return NULL;

}

ClassDescriptor* ClassDescriptor::parse_generic_signature(Klass* klass, TRAPS) {

  return parse_generic_signature(klass, NULL, CHECK_NULL);

}

ClassDescriptor* ClassDescriptor::parse_generic_signature(

      Klass* klass, Symbol* original_name, TRAPS) {

  InstanceKlass* ik = InstanceKlass::cast(klass);

  Symbol* sym = ik->generic_signature();

  ClassDescriptor* spec;

  if (sym == NULL || (spec = ClassDescriptor::parse_generic_signature(sym)) == NULL) {

    spec = ClassDescriptor::placeholder(ik);

  }

  u2 outer_index = get_outer_class_index(ik, CHECK_NULL);

  if (outer_index != 0) {

    if (original_name == NULL) {

      original_name = ik->name();

    }

    Handle class_loader = Handle(THREAD, ik->class_loader());

    Handle protection_domain = Handle(THREAD, ik->protection_domain());

    Symbol* outer_name = ik->constants()->klass_name_at(outer_index);

    Klass* outer = SystemDictionary::find(

        outer_name, class_loader, protection_domain, CHECK_NULL);

    if (outer == NULL && !THREAD->is_Compiler_thread()) {

      outer = SystemDictionary::resolve_super_or_fail(original_name,

          outer_name, class_loader, protection_domain, false, CHECK_NULL);

    }

    InstanceKlass* outer_ik;

    ClassDescriptor* outer_spec = NULL;

    if (outer == NULL) {

      outer_spec = ClassDescriptor::placeholder(ik);

      assert(false, "Outer class not loaded and not loadable from here");

    } else {

      outer_ik = InstanceKlass::cast(outer);

      outer_spec = parse_generic_signature(outer, original_name, CHECK_NULL);

    }

    spec->set_outer_class(outer_spec);

    u2 encl_method_idx = ik->enclosing_method_method_index();

    if (encl_method_idx != 0 && outer_ik != NULL) {

      ConstantPool* cp = ik->constants();

      u2 name_index = cp->name_ref_index_at(encl_method_idx);

      u2 sig_index = cp->signature_ref_index_at(encl_method_idx);

      Symbol* name = cp->symbol_at(name_index);

      Symbol* sig = cp->symbol_at(sig_index);

      Method* m = outer_ik->find_method(name, sig);

      if (m != NULL) {

        Symbol* gsig = m->generic_signature();

        if (gsig != NULL) {

          MethodDescriptor* gms = MethodDescriptor::parse_generic_signature(gsig, outer_spec);

          spec->set_outer_method(gms);

        }

      } else if (VerifyGenericSignatures) {

        ResourceMark rm;

        stringStream ss;

        ss.print("Could not find method %s %s in class %s",

          name->as_C_string(), sig->as_C_string(), outer_name->as_C_string());

        fatal(ss.as_string());

      }

    }

  }

  spec->bind_variables_to_parameters();

  return spec;

}

ClassDescriptor* ClassDescriptor::placeholder(InstanceKlass* klass) {

  GrowableArray<TypeParameter*> formals;

  GrowableArray<ClassType*> interfaces;

  ClassType* super_type = NULL;

  Klass* super_klass = klass->super();

  if (super_klass != NULL) {

    InstanceKlass* super = InstanceKlass::cast(super_klass);

    super_type = ClassType::from_symbol(super->name());

  }

  for (int i = 0; i < klass->local_interfaces()->length(); ++i) {

    InstanceKlass* iface = InstanceKlass::cast(klass->local_interfaces()->at(i));

    interfaces.append(ClassType::from_symbol(iface->name()));

  }

  return new ClassDescriptor(formals, super_type, interfaces);

}

ClassDescriptor* ClassDescriptor::parse_generic_signature(Symbol* sym) {

  DescriptorStream ds(sym);

  DescriptorStream* STREAM = &ds;

  GrowableArray<TypeParameter*> parameters(8);

  char c = READ();

  if (c == '<') {

    c = READ();

    while (c != '>') {

      PUSH(c);

      TypeParameter* ftp = TypeParameter::parse_generic_signature(CHECK_STREAM);

      parameters.append(ftp);

      c = READ();

    }

  } else {

    PUSH(c);

  }

  EXPECT('L');

  ClassType* super = ClassType::parse_generic_signature(CHECK_STREAM);

  GrowableArray<ClassType*> signatures(2);

  while (!STREAM->at_end()) {

    EXPECT('L');

    ClassType* iface = ClassType::parse_generic_signature(CHECK_STREAM);

    signatures.append(iface);

  }

  EXPECT_END();

  return new ClassDescriptor(parameters, super, signatures);

}

#ifndef PRODUCT

void ClassDescriptor::print_on(outputStream* str) const {

  str->indent().print_cr("ClassDescriptor {");

  {

    streamIndentor si(str);

    if (_type_parameters.length() > 0) {

      str->indent().print_cr("Formals {");

      {

        streamIndentor si(str);

        for (int i = 0; i < _type_parameters.length(); ++i) {

          _type_parameters.at(i)->print_on(str);

        }

      }

      str->indent().print_cr("}");

    }

    if (_super != NULL) {

      str->indent().print_cr("Superclass: ");

      {

        streamIndentor si(str);

        _super->print_on(str);

      }

    }

    if (_interfaces.length() > 0) {

      str->indent().print_cr("SuperInterfaces: {");

      {

        streamIndentor si(str);

        for (int i = 0; i < _interfaces.length(); ++i) {

          _interfaces.at(i)->print_on(str);

        }

      }

      str->indent().print_cr("}");

    }

    if (_outer_method != NULL) {

      str->indent().print_cr("Outer Method: {");

      {

        streamIndentor si(str);

        _outer_method->print_on(str);

      }

      str->indent().print_cr("}");

    }

    if (_outer_class != NULL) {

      str->indent().print_cr("Outer Class: {");

      {

        streamIndentor si(str);

        _outer_class->print_on(str);

      }

      str->indent().print_cr("}");

    }

  }

  str->indent().print_cr("}");

}

#endif // ndef PRODUCT

ClassType* ClassDescriptor::interface_desc(Symbol* sym) {

  for (int i = 0; i < _interfaces.length(); ++i) {

    if (_interfaces.at(i)->identifier()->equals(sym)) {

      return _interfaces.at(i);

    }

  }

  if (VerifyGenericSignatures) {

    fatal("Did not find expected interface");

  }

  return NULL;

}

void ClassDescriptor::bind_variables_to_parameters() {

  if (_outer_class != NULL) {

    _outer_class->bind_variables_to_parameters();

  }

  if (_outer_method != NULL) {

    _outer_method->bind_variables_to_parameters();

  }

  for (int i = 0; i < _type_parameters.length(); ++i) {

    _type_parameters.at(i)->bind_variables_to_parameters(this, i);

  }

  if (_super != NULL) {

    _super->bind_variables_to_parameters(this);

  }

  for (int i = 0; i < _interfaces.length(); ++i) {

    _interfaces.at(i)->bind_variables_to_parameters(this);

  }

}

ClassDescriptor* ClassDescriptor::canonicalize(Context* ctx) {

  GrowableArray<TypeParameter*> type_params(_type_parameters.length());

  for (int i = 0; i < _type_parameters.length(); ++i) {

    type_params.append(_type_parameters.at(i)->canonicalize(ctx, 0));

  }

  ClassDescriptor* outer = _outer_class == NULL ? NULL :

      _outer_class->canonicalize(ctx);

  ClassType* super = _super == NULL ? NULL : _super->canonicalize(ctx, 0);

  GrowableArray<ClassType*> interfaces(_interfaces.length());

  for (int i = 0; i < _interfaces.length(); ++i) {

    interfaces.append(_interfaces.at(i)->canonicalize(ctx, 0));

  }

  MethodDescriptor* md = _outer_method == NULL ? NULL :

      _outer_method->canonicalize(ctx);

  return new ClassDescriptor(type_params, super, interfaces, outer, md);

}

u2 ClassDescriptor::get_outer_class_index(InstanceKlass* klass, TRAPS) {

  int inner_index = InstanceKlass::inner_class_inner_class_info_offset;

  int outer_index = InstanceKlass::inner_class_outer_class_info_offset;

  int name_offset = InstanceKlass::inner_class_inner_name_offset;

  int next_offset = InstanceKlass::inner_class_next_offset;

  if (klass->inner_classes() == NULL || klass->inner_classes()->length() == 0) {

    // No inner class info => no declaring class

    return 0;

  }

  Array<u2>* i_icls = klass->inner_classes();

  ConstantPool* i_cp = klass->constants();

  int i_length = i_icls->length();

  // Find inner_klass attribute

  for (int i = 0; i + next_offset < i_length; i += next_offset) {

    u2 ioff = i_icls->at(i + inner_index);

    u2 ooff = i_icls->at(i + outer_index);

    u2 noff = i_icls->at(i + name_offset);

    if (ioff != 0) {

      // Check to see if the name matches the class we're looking for

      // before attempting to find the class.

      if (i_cp->klass_name_at_matches(klass, ioff) && ooff != 0) {

        return ooff;

      }

    }

  }

  // It may be anonymous; try for that.

  u2 encl_method_class_idx = klass->enclosing_method_class_index();

  if (encl_method_class_idx != 0) {

    return encl_method_class_idx;

  }

  return 0;

}

MethodDescriptor* MethodDescriptor::parse_generic_signature(Method* m, ClassDescriptor* outer) {

  Symbol* generic_sig = m->generic_signature();

  MethodDescriptor* md = NULL;

  if (generic_sig == NULL || (md = parse_generic_signature(generic_sig, outer)) == NULL) {

    md = parse_generic_signature(m->signature(), outer);

  }

  assert(md != NULL, "Could not parse method signature");

  md->bind_variables_to_parameters();

  return md;

}

MethodDescriptor* MethodDescriptor::parse_generic_signature(Symbol* sym, ClassDescriptor* outer) {

  DescriptorStream ds(sym);

  DescriptorStream* STREAM = &ds;

  GrowableArray<TypeParameter*> params(8);

  char c = READ();

  if (c == '<') {