src/share/vm/runtime/signature.cpp - platform/external/jetbrains/jdk8u_hotspot - Git at Google

 /*
  * Copyright (c) 1997, 2014, 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/symbolTable.hpp"
 #include "classfile/systemDictionary.hpp"
 #include "memory/oopFactory.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/oop.inline.hpp"
 #include "oops/symbol.hpp"
 #include "oops/typeArrayKlass.hpp"
 #include "runtime/signature.hpp"

 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC

 // Implementation of SignatureIterator

 // Signature syntax:
 //
 // Signature  = "(" {Parameter} ")" ReturnType.
 // Parameter  = FieldType.
 // ReturnType = FieldType | "V".
 // FieldType  = "B" | "C" | "D" | "F" | "I" | "J" | "S" | "Z" | "L" ClassName ";" | "[" FieldType.
 // ClassName  = string.


 SignatureIterator::SignatureIterator(Symbol* signature) {
   _signature       = signature;
   _parameter_index = 0;
 }

 void SignatureIterator::expect(char c) {
   if (_signature->byte_at(_index) != c) fatal(err_msg("expecting %c", c));
   _index++;
 }


 void SignatureIterator::skip_optional_size() {
   Symbol* sig = _signature;
   char c = sig->byte_at(_index);
   while ('0' <= c && c <= '9') c = sig->byte_at(++_index);
 }


 int SignatureIterator::parse_type() {
   // Note: This function could be simplified by using "return T_XXX_size;"
   //       instead of the assignment and the break statements. However, it
   //       seems that the product build for win32_i486 with MS VC++ 6.0 doesn't
   //       work (stack underflow for some tests) - this seems to be a VC++ 6.0
   //       compiler bug (was problem - gri 4/27/2000).
   int size = -1;
   switch(_signature->byte_at(_index)) {
     case 'B': do_byte  (); if (_parameter_index < 0 ) _return_type = T_BYTE;
               _index++; size = T_BYTE_size   ; break;
     case 'C': do_char  (); if (_parameter_index < 0 ) _return_type = T_CHAR;
               _index++; size = T_CHAR_size   ; break;
     case 'D': do_double(); if (_parameter_index < 0 ) _return_type = T_DOUBLE;
               _index++; size = T_DOUBLE_size ; break;
     case 'F': do_float (); if (_parameter_index < 0 ) _return_type = T_FLOAT;
               _index++; size = T_FLOAT_size  ; break;
     case 'I': do_int   (); if (_parameter_index < 0 ) _return_type = T_INT;
               _index++; size = T_INT_size    ; break;
     case 'J': do_long  (); if (_parameter_index < 0 ) _return_type = T_LONG;
               _index++; size = T_LONG_size   ; break;
     case 'S': do_short (); if (_parameter_index < 0 ) _return_type = T_SHORT;
               _index++; size = T_SHORT_size  ; break;
     case 'Z': do_bool  (); if (_parameter_index < 0 ) _return_type = T_BOOLEAN;
               _index++; size = T_BOOLEAN_size; break;
     case 'V': do_void  (); if (_parameter_index < 0 ) _return_type = T_VOID;
               _index++; size = T_VOID_size;  ; break;
     case 'L':
       { int begin = ++_index;
         Symbol* sig = _signature;
         while (sig->byte_at(_index++) != ';') ;
         do_object(begin, _index);
       }
       if (_parameter_index < 0 ) _return_type = T_OBJECT;
       size = T_OBJECT_size;
       break;
     case '[':
       { int begin = ++_index;
         skip_optional_size();
         Symbol* sig = _signature;
         while (sig->byte_at(_index) == '[') {
           _index++;
           skip_optional_size();
         }
         if (sig->byte_at(_index) == 'L') {
           while (sig->byte_at(_index++) != ';') ;
         } else {
           _index++;
         }
         do_array(begin, _index);
        if (_parameter_index < 0 ) _return_type = T_ARRAY;
       }
       size = T_ARRAY_size;
       break;
     default:
       ShouldNotReachHere();
       break;
   }
   assert(size >= 0, "size must be set");
   return size;
 }


 void SignatureIterator::check_signature_end() {
   if (_index < _signature->utf8_length()) {
     tty->print_cr("too many chars in signature");
     _signature->print_value_on(tty);
     tty->print_cr(" @ %d", _index);
   }
 }


 void SignatureIterator::dispatch_field() {
   // no '(', just one (field) type
   _index = 0;
   _parameter_index = 0;
   parse_type();
   check_signature_end();
 }


 void SignatureIterator::iterate_parameters() {
   // Parse parameters
   _index = 0;
   _parameter_index = 0;
   expect('(');
   while (_signature->byte_at(_index) != ')') _parameter_index += parse_type();
   expect(')');
   _parameter_index = 0;
 }

 // Optimized version of iterat_parameters when fingerprint is known
 void SignatureIterator::iterate_parameters( uint64_t fingerprint ) {
   uint64_t saved_fingerprint = fingerprint;

   // Check for too many arguments
   if ( fingerprint == UCONST64(-1) ) {
     SignatureIterator::iterate_parameters();
     return;
   }

   assert(fingerprint, "Fingerprint should not be 0");

   _parameter_index = 0;
   fingerprint = fingerprint >> (static_feature_size + result_feature_size);
   while ( 1 ) {
     switch ( fingerprint & parameter_feature_mask ) {
       case bool_parm:
         do_bool();
         _parameter_index += T_BOOLEAN_size;
         break;
       case byte_parm:
         do_byte();
         _parameter_index += T_BYTE_size;
         break;
       case char_parm:
         do_char();
         _parameter_index += T_CHAR_size;
         break;
       case short_parm:
         do_short();
         _parameter_index += T_SHORT_size;
         break;
       case int_parm:
         do_int();
         _parameter_index += T_INT_size;
         break;
       case obj_parm:
         do_object(0, 0);
         _parameter_index += T_OBJECT_size;
         break;
       case long_parm:
         do_long();
         _parameter_index += T_LONG_size;
         break;
       case float_parm:
         do_float();
         _parameter_index += T_FLOAT_size;
         break;
       case double_parm:
         do_double();
         _parameter_index += T_DOUBLE_size;
         break;
       case done_parm:
         return;
         break;
       default:
         tty->print_cr("*** parameter is %d", fingerprint & parameter_feature_mask);
         tty->print_cr("*** fingerprint is " PTR64_FORMAT, saved_fingerprint);
         ShouldNotReachHere();
         break;
     }
     fingerprint >>= parameter_feature_size;
   }
   _parameter_index = 0;
 }


 void SignatureIterator::iterate_returntype() {
   // Ignore parameters
   _index = 0;
   expect('(');
   Symbol* sig = _signature;
   // Need to skip over each type in the signature's argument list until a
   // closing ')' is found., then get the return type.  We cannot just scan
   // for the first ')' because ')' is a legal character in a type name.
   while (sig->byte_at(_index) != ')') {
     switch(sig->byte_at(_index)) {
       case 'B':
       case 'C':
       case 'D':
       case 'F':
       case 'I':
       case 'J':
       case 'S':
       case 'Z':
       case 'V':
         {
           _index++;
         }
         break;
       case 'L':
         {
           while (sig->byte_at(_index++) != ';') ;
         }
         break;
       case '[':
         {
           int begin = ++_index;
           skip_optional_size();
           while (sig->byte_at(_index) == '[') {
             _index++;
             skip_optional_size();
           }
           if (sig->byte_at(_index) == 'L') {
             while (sig->byte_at(_index++) != ';') ;
           } else {
             _index++;
           }
         }
         break;
       default:
         ShouldNotReachHere();
         break;
     }
   }
   expect(')');
   // Parse return type
   _parameter_index = -1;
   parse_type();
   check_signature_end();
   _parameter_index = 0;
 }


 void SignatureIterator::iterate() {
   // Parse parameters
   _parameter_index = 0;
   _index = 0;
   expect('(');
   while (_signature->byte_at(_index) != ')') _parameter_index += parse_type();
   expect(')');
   // Parse return type
   _parameter_index = -1;
   parse_type();
   check_signature_end();
   _parameter_index = 0;
 }


 // Implementation of SignatureStream
 SignatureStream::SignatureStream(Symbol* signature, bool is_method) :
                    _signature(signature), _at_return_type(false) {
   _begin = _end = (is_method ? 1 : 0);  // skip first '(' in method signatures
   _names = new GrowableArray<Symbol*>(10);
   next();
 }

 SignatureStream::~SignatureStream() {
   // decrement refcount for names created during signature parsing
   for (int i = 0; i < _names->length(); i++) {
     _names->at(i)->decrement_refcount();
   }
 }

 bool SignatureStream::is_done() const {
   return _end > _signature->utf8_length();
 }


 void SignatureStream::next_non_primitive(int t) {
   switch (t) {
     case 'L': {
       _type = T_OBJECT;
       Symbol* sig = _signature;
       while (sig->byte_at(_end++) != ';');
       break;
     }
     case '[': {
       _type = T_ARRAY;
       Symbol* sig = _signature;
       char c = sig->byte_at(_end);
       while ('0' <= c && c <= '9') c = sig->byte_at(_end++);
       while (sig->byte_at(_end) == '[') {
         _end++;
         c = sig->byte_at(_end);
         while ('0' <= c && c <= '9') c = sig->byte_at(_end++);
       }
       switch(sig->byte_at(_end)) {
         case 'B':
         case 'C':
         case 'D':
         case 'F':
         case 'I':
         case 'J':
         case 'S':
         case 'Z':_end++; break;
         default: {
           while (sig->byte_at(_end++) != ';');
           break;
         }
       }
       break;
     }
     case ')': _end++; next(); _at_return_type = true; break;
     default : ShouldNotReachHere();
   }
 }


 bool SignatureStream::is_object() const {
   return _type == T_OBJECT
       || _type == T_ARRAY;
 }

 bool SignatureStream::is_array() const {
   return _type == T_ARRAY;
 }

 Symbol* SignatureStream::as_symbol(TRAPS) {
   // Create a symbol from for string _begin _end
   int begin = _begin;
   int end   = _end;

   if (   _signature->byte_at(_begin) == 'L'
       && _signature->byte_at(_end-1) == ';') {
     begin++;
     end--;
   }

   // Save names for cleaning up reference count at the end of
   // SignatureStream scope.
   Symbol* name = SymbolTable::new_symbol(_signature, begin, end, CHECK_NULL);
   _names->push(name);  // save new symbol for decrementing later
   return name;
 }

 Klass* SignatureStream::as_klass(Handle class_loader, Handle protection_domain,
                                    FailureMode failure_mode, TRAPS) {
   if (!is_object())  return NULL;
   Symbol* name = as_symbol(CHECK_NULL);
   if (failure_mode == ReturnNull) {
     return SystemDictionary::resolve_or_null(name, class_loader, protection_domain, THREAD);
   } else {
     bool throw_error = (failure_mode == NCDFError);
     return SystemDictionary::resolve_or_fail(name, class_loader, protection_domain, throw_error, THREAD);
   }
 }

 oop SignatureStream::as_java_mirror(Handle class_loader, Handle protection_domain,
                                     FailureMode failure_mode, TRAPS) {
   if (!is_object())
     return Universe::java_mirror(type());
   Klass* klass = as_klass(class_loader, protection_domain, failure_mode, CHECK_NULL);
   if (klass == NULL)  return NULL;
   return klass->java_mirror();
 }

 Symbol* SignatureStream::as_symbol_or_null() {
   // Create a symbol from for string _begin _end
   ResourceMark rm;

   int begin = _begin;
   int end   = _end;

   if (   _signature->byte_at(_begin) == 'L'
       && _signature->byte_at(_end-1) == ';') {
     begin++;
     end--;
   }

   char* buffer = NEW_RESOURCE_ARRAY(char, end - begin);
   for (int index = begin; index < end; index++) {
     buffer[index - begin] = _signature->byte_at(index);
   }
   Symbol* result = SymbolTable::probe(buffer, end - begin);
   return result;
 }

 int SignatureStream::reference_parameter_count() {
   int args_count = 0;
   for ( ; !at_return_type(); next()) {
     if (is_object()) {
       args_count++;
     }
   }
   return args_count;
 }

 bool SignatureVerifier::is_valid_signature(Symbol* sig) {
   const char* signature = (const char*)sig->bytes();
   ssize_t len = sig->utf8_length();
   if (signature == NULL || signature[0] == '\0' || len < 1) {
     return false;
   } else if (signature[0] == '(') {
     return is_valid_method_signature(sig);
   } else {
     return is_valid_type_signature(sig);
   }
 }

 bool SignatureVerifier::is_valid_method_signature(Symbol* sig) {
   const char* method_sig = (const char*)sig->bytes();
   ssize_t len = sig->utf8_length();
   ssize_t index = 0;
   if (method_sig != NULL && len > 1 && method_sig[index] == '(') {
     ++index;
     while (index < len && method_sig[index] != ')') {
       ssize_t res = is_valid_type(&method_sig[index], len - index);
       if (res == -1) {
         return false;
       } else {
         index += res;
       }
     }
     if (index < len && method_sig[index] == ')') {
       // check the return type
       ++index;
       return (is_valid_type(&method_sig[index], len - index) == (len - index));
     }
   }
   return false;
 }

 bool SignatureVerifier::is_valid_type_signature(Symbol* sig) {
   const char* type_sig = (const char*)sig->bytes();
   ssize_t len = sig->utf8_length();
   return (type_sig != NULL && len >= 1 &&
           (is_valid_type(type_sig, len) == len));
 }

 // Checks to see if the type (not to go beyond 'limit') refers to a valid type.
 // Returns -1 if it is not, or the index of the next character that is not part
 // of the type.  The type encoding may end before 'limit' and that's ok.
 ssize_t SignatureVerifier::is_valid_type(const char* type, ssize_t limit) {
   ssize_t index = 0;

   // Iterate over any number of array dimensions
   while (index < limit && type[index] == '[') ++index;
   if (index >= limit) {
     return -1;
   }
   switch (type[index]) {
     case 'B': case 'C': case 'D': case 'F': case 'I':
     case 'J': case 'S': case 'Z': case 'V':
       return index + 1;
     case 'L':
       for (index = index + 1; index < limit; ++index) {
         char c = type[index];
         if (c == ';') {
           return index + 1;
         }
         if (invalid_name_char(c)) {
           return -1;
         }
       }
       // fall through
     default: ; // fall through
   }
   return -1;
 }

 bool SignatureVerifier::invalid_name_char(char c) {
   switch (c) {
     case '\0': case '.': case ';': case '[':
       return true;
     default:
       return false;
   }
 }
	/*
	* Copyright (c) 1997, 2014, 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/symbolTable.hpp"
	#include "classfile/systemDictionary.hpp"
	#include "memory/oopFactory.hpp"
	#include "oops/instanceKlass.hpp"
	#include "oops/oop.inline.hpp"
	#include "oops/symbol.hpp"
	#include "oops/typeArrayKlass.hpp"
	#include "runtime/signature.hpp"

	PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC

	// Implementation of SignatureIterator

	// Signature syntax:
	//
	// Signature = "(" {Parameter} ")" ReturnType.
	// Parameter = FieldType.
	// ReturnType = FieldType \| "V".
	// FieldType = "B" \| "C" \| "D" \| "F" \| "I" \| "J" \| "S" \| "Z" \| "L" ClassName ";" \| "[" FieldType.
	// ClassName = string.


	SignatureIterator::SignatureIterator(Symbol* signature) {
	_signature = signature;
	_parameter_index = 0;
	}

	void SignatureIterator::expect(char c) {
	if (_signature->byte_at(_index) != c) fatal(err_msg("expecting %c", c));
	_index++;
	}


	void SignatureIterator::skip_optional_size() {
	Symbol* sig = _signature;
	char c = sig->byte_at(_index);
	while ('0' <= c && c <= '9') c = sig->byte_at(++_index);
	}


	int SignatureIterator::parse_type() {
	// Note: This function could be simplified by using "return T_XXX_size;"
	// instead of the assignment and the break statements. However, it
	// seems that the product build for win32_i486 with MS VC++ 6.0 doesn't
	// work (stack underflow for some tests) - this seems to be a VC++ 6.0
	// compiler bug (was problem - gri 4/27/2000).
	int size = -1;
	switch(_signature->byte_at(_index)) {
	case 'B': do_byte (); if (_parameter_index < 0 ) _return_type = T_BYTE;
	_index++; size = T_BYTE_size ; break;
	case 'C': do_char (); if (_parameter_index < 0 ) _return_type = T_CHAR;
	_index++; size = T_CHAR_size ; break;
	case 'D': do_double(); if (_parameter_index < 0 ) _return_type = T_DOUBLE;
	_index++; size = T_DOUBLE_size ; break;
	case 'F': do_float (); if (_parameter_index < 0 ) _return_type = T_FLOAT;
	_index++; size = T_FLOAT_size ; break;
	case 'I': do_int (); if (_parameter_index < 0 ) _return_type = T_INT;
	_index++; size = T_INT_size ; break;
	case 'J': do_long (); if (_parameter_index < 0 ) _return_type = T_LONG;
	_index++; size = T_LONG_size ; break;
	case 'S': do_short (); if (_parameter_index < 0 ) _return_type = T_SHORT;
	_index++; size = T_SHORT_size ; break;
	case 'Z': do_bool (); if (_parameter_index < 0 ) _return_type = T_BOOLEAN;
	_index++; size = T_BOOLEAN_size; break;
	case 'V': do_void (); if (_parameter_index < 0 ) _return_type = T_VOID;
	_index++; size = T_VOID_size; ; break;
	case 'L':
	{ int begin = ++_index;
	Symbol* sig = _signature;
	while (sig->byte_at(_index++) != ';') ;
	do_object(begin, _index);
	}
	if (_parameter_index < 0 ) _return_type = T_OBJECT;
	size = T_OBJECT_size;
	break;
	case '[':
	{ int begin = ++_index;
	skip_optional_size();
	Symbol* sig = _signature;
	while (sig->byte_at(_index) == '[') {
	_index++;
	skip_optional_size();
	}
	if (sig->byte_at(_index) == 'L') {
	while (sig->byte_at(_index++) != ';') ;
	} else {
	_index++;
	}
	do_array(begin, _index);
	if (_parameter_index < 0 ) _return_type = T_ARRAY;
	}
	size = T_ARRAY_size;
	break;
	default:
	ShouldNotReachHere();
	break;
	}
	assert(size >= 0, "size must be set");
	return size;
	}


	void SignatureIterator::check_signature_end() {
	if (_index < _signature->utf8_length()) {
	tty->print_cr("too many chars in signature");
	_signature->print_value_on(tty);
	tty->print_cr(" @ %d", _index);
	}
	}


	void SignatureIterator::dispatch_field() {
	// no '(', just one (field) type
	_index = 0;
	_parameter_index = 0;
	parse_type();
	check_signature_end();
	}


	void SignatureIterator::iterate_parameters() {
	// Parse parameters
	_index = 0;
	_parameter_index = 0;
	expect('(');
	while (_signature->byte_at(_index) != ')') _parameter_index += parse_type();
	expect(')');
	_parameter_index = 0;
	}

	// Optimized version of iterat_parameters when fingerprint is known
	void SignatureIterator::iterate_parameters( uint64_t fingerprint ) {
	uint64_t saved_fingerprint = fingerprint;

	// Check for too many arguments
	if ( fingerprint == UCONST64(-1) ) {
	SignatureIterator::iterate_parameters();
	return;
	}

	assert(fingerprint, "Fingerprint should not be 0");

	_parameter_index = 0;
	fingerprint = fingerprint >> (static_feature_size + result_feature_size);
	while ( 1 ) {
	switch ( fingerprint & parameter_feature_mask ) {
	case bool_parm:
	do_bool();
	_parameter_index += T_BOOLEAN_size;
	break;
	case byte_parm:
	do_byte();
	_parameter_index += T_BYTE_size;
	break;
	case char_parm:
	do_char();
	_parameter_index += T_CHAR_size;
	break;
	case short_parm:
	do_short();
	_parameter_index += T_SHORT_size;
	break;
	case int_parm:
	do_int();
	_parameter_index += T_INT_size;
	break;
	case obj_parm:
	do_object(0, 0);
	_parameter_index += T_OBJECT_size;
	break;
	case long_parm:
	do_long();
	_parameter_index += T_LONG_size;
	break;
	case float_parm:
	do_float();
	_parameter_index += T_FLOAT_size;
	break;
	case double_parm:
	do_double();
	_parameter_index += T_DOUBLE_size;
	break;
	case done_parm:
	return;
	break;
	default:
	tty->print_cr("*** parameter is %d", fingerprint & parameter_feature_mask);
	tty->print_cr("*** fingerprint is " PTR64_FORMAT, saved_fingerprint);
	ShouldNotReachHere();
	break;
	}
	fingerprint >>= parameter_feature_size;
	}
	_parameter_index = 0;
	}


	void SignatureIterator::iterate_returntype() {
	// Ignore parameters
	_index = 0;
	expect('(');
	Symbol* sig = _signature;
	// Need to skip over each type in the signature's argument list until a
	// closing ')' is found., then get the return type. We cannot just scan
	// for the first ')' because ')' is a legal character in a type name.
	while (sig->byte_at(_index) != ')') {
	switch(sig->byte_at(_index)) {
	case 'B':
	case 'C':
	case 'D':
	case 'F':
	case 'I':
	case 'J':
	case 'S':
	case 'Z':
	case 'V':
	{
	_index++;
	}
	break;
	case 'L':
	{
	while (sig->byte_at(_index++) != ';') ;
	}
	break;
	case '[':
	{
	int begin = ++_index;
	skip_optional_size();
	while (sig->byte_at(_index) == '[') {
	_index++;
	skip_optional_size();
	}
	if (sig->byte_at(_index) == 'L') {
	while (sig->byte_at(_index++) != ';') ;
	} else {
	_index++;
	}
	}
	break;
	default:
	ShouldNotReachHere();
	break;
	}
	}
	expect(')');
	// Parse return type
	_parameter_index = -1;
	parse_type();
	check_signature_end();
	_parameter_index = 0;
	}


	void SignatureIterator::iterate() {
	// Parse parameters
	_parameter_index = 0;
	_index = 0;
	expect('(');
	while (_signature->byte_at(_index) != ')') _parameter_index += parse_type();
	expect(')');
	// Parse return type
	_parameter_index = -1;
	parse_type();
	check_signature_end();
	_parameter_index = 0;
	}


	// Implementation of SignatureStream
	SignatureStream::SignatureStream(Symbol* signature, bool is_method) :
	_signature(signature), _at_return_type(false) {
	_begin = _end = (is_method ? 1 : 0); // skip first '(' in method signatures
	_names = new GrowableArray<Symbol*>(10);
	next();
	}

	SignatureStream::~SignatureStream() {
	// decrement refcount for names created during signature parsing
	for (int i = 0; i < _names->length(); i++) {
	_names->at(i)->decrement_refcount();
	}
	}

	bool SignatureStream::is_done() const {
	return _end > _signature->utf8_length();
	}


	void SignatureStream::next_non_primitive(int t) {
	switch (t) {
	case 'L': {
	_type = T_OBJECT;
	Symbol* sig = _signature;
	while (sig->byte_at(_end++) != ';');
	break;
	}
	case '[': {
	_type = T_ARRAY;
	Symbol* sig = _signature;
	char c = sig->byte_at(_end);
	while ('0' <= c && c <= '9') c = sig->byte_at(_end++);
	while (sig->byte_at(_end) == '[') {
	_end++;
	c = sig->byte_at(_end);
	while ('0' <= c && c <= '9') c = sig->byte_at(_end++);
	}
	switch(sig->byte_at(_end)) {
	case 'B':
	case 'C':
	case 'D':
	case 'F':
	case 'I':
	case 'J':
	case 'S':
	case 'Z':_end++; break;
	default: {
	while (sig->byte_at(_end++) != ';');
	break;
	}
	}
	break;
	}
	case ')': _end++; next(); _at_return_type = true; break;
	default : ShouldNotReachHere();
	}
	}


	bool SignatureStream::is_object() const {
	return _type == T_OBJECT
	\|\| _type == T_ARRAY;
	}

	bool SignatureStream::is_array() const {
	return _type == T_ARRAY;
	}

	Symbol* SignatureStream::as_symbol(TRAPS) {
	// Create a symbol from for string _begin _end
	int begin = _begin;
	int end = _end;

	if ( _signature->byte_at(_begin) == 'L'
	&& _signature->byte_at(_end-1) == ';') {
	begin++;
	end--;
	}

	// Save names for cleaning up reference count at the end of
	// SignatureStream scope.
	Symbol* name = SymbolTable::new_symbol(_signature, begin, end, CHECK_NULL);
	_names->push(name); // save new symbol for decrementing later
	return name;
	}

	Klass* SignatureStream::as_klass(Handle class_loader, Handle protection_domain,
	FailureMode failure_mode, TRAPS) {
	if (!is_object()) return NULL;
	Symbol* name = as_symbol(CHECK_NULL);
	if (failure_mode == ReturnNull) {
	return SystemDictionary::resolve_or_null(name, class_loader, protection_domain, THREAD);
	} else {
	bool throw_error = (failure_mode == NCDFError);
	return SystemDictionary::resolve_or_fail(name, class_loader, protection_domain, throw_error, THREAD);
	}
	}

	oop SignatureStream::as_java_mirror(Handle class_loader, Handle protection_domain,
	FailureMode failure_mode, TRAPS) {
	if (!is_object())
	return Universe::java_mirror(type());
	Klass* klass = as_klass(class_loader, protection_domain, failure_mode, CHECK_NULL);
	if (klass == NULL) return NULL;
	return klass->java_mirror();
	}

	Symbol* SignatureStream::as_symbol_or_null() {
	// Create a symbol from for string _begin _end
	ResourceMark rm;

	int begin = _begin;
	int end = _end;

	if ( _signature->byte_at(_begin) == 'L'
	&& _signature->byte_at(_end-1) == ';') {
	begin++;
	end--;
	}

	char* buffer = NEW_RESOURCE_ARRAY(char, end - begin);
	for (int index = begin; index < end; index++) {
	buffer[index - begin] = _signature->byte_at(index);
	}
	Symbol* result = SymbolTable::probe(buffer, end - begin);
	return result;
	}

	int SignatureStream::reference_parameter_count() {
	int args_count = 0;
	for ( ; !at_return_type(); next()) {
	if (is_object()) {
	args_count++;
	}
	}
	return args_count;
	}

	bool SignatureVerifier::is_valid_signature(Symbol* sig) {
	const char* signature = (const char*)sig->bytes();
	ssize_t len = sig->utf8_length();
	if (signature == NULL \|\| signature[0] == '\0' \|\| len < 1) {
	return false;
	} else if (signature[0] == '(') {
	return is_valid_method_signature(sig);
	} else {
	return is_valid_type_signature(sig);
	}
	}

	bool SignatureVerifier::is_valid_method_signature(Symbol* sig) {
	const char* method_sig = (const char*)sig->bytes();
	ssize_t len = sig->utf8_length();
	ssize_t index = 0;
	if (method_sig != NULL && len > 1 && method_sig[index] == '(') {
	++index;
	while (index < len && method_sig[index] != ')') {
	ssize_t res = is_valid_type(&method_sig[index], len - index);
	if (res == -1) {
	return false;
	} else {
	index += res;
	}
	}
	if (index < len && method_sig[index] == ')') {
	// check the return type
	++index;
	return (is_valid_type(&method_sig[index], len - index) == (len - index));
	}
	}
	return false;
	}

	bool SignatureVerifier::is_valid_type_signature(Symbol* sig) {
	const char* type_sig = (const char*)sig->bytes();
	ssize_t len = sig->utf8_length();
	return (type_sig != NULL && len >= 1 &&
	(is_valid_type(type_sig, len) == len));
	}

	// Checks to see if the type (not to go beyond 'limit') refers to a valid type.
	// Returns -1 if it is not, or the index of the next character that is not part
	// of the type. The type encoding may end before 'limit' and that's ok.
	ssize_t SignatureVerifier::is_valid_type(const char* type, ssize_t limit) {
	ssize_t index = 0;

	// Iterate over any number of array dimensions
	while (index < limit && type[index] == '[') ++index;
	if (index >= limit) {
	return -1;
	}
	switch (type[index]) {
	case 'B': case 'C': case 'D': case 'F': case 'I':
	case 'J': case 'S': case 'Z': case 'V':
	return index + 1;
	case 'L':
	for (index = index + 1; index < limit; ++index) {
	char c = type[index];
	if (c == ';') {
	return index + 1;
	}
	if (invalid_name_char(c)) {
	return -1;
	}
	}
	// fall through
	default: ; // fall through
	}
	return -1;
	}

	bool SignatureVerifier::invalid_name_char(char c) {
	switch (c) {
	case '\0': case '.': case ';': case '[':
	return true;
	default:
	return false;
	}
	}