drlvm/modules/vm/src/main/native/jitrino/shared/shared/methodtable.cpp - harmony - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 /**
  * @author Intel, Mikhail Y. Fursov
  *
  */

 //
 // Decides whether or not to "accept" a method based on an environment
 // variable and an optional file.
 //
 // Assume FOO is the environment variable that gives the information.
 //
 // FOO=file:range_list
 //
 // "file" is the name of the file that contains the list of all
 // methods.
 //
 // If "range_list" is empty, no methods are jitted, and the list of
 // methods is printed to "file".
 //
 // "range_list" contains a list of methods and ranges, separated by
 // commas.  A single number denotes a one-based index into the method
 // list.  A range (start-end) denotes a range of indices into the
 // method list.
 // The string "class::method" denotes a specific method.
 // "class::" matches all methods of the given class.
 // "method" (not containing a colon) matches that method of
 // any class.
 // A "-" preceding a list element means to exclude that method(s) from
 // the list of methods to jit.
 //
 // FOO=c:\tmp\mlist:  (jit nothing, create a method list file)
 // FOO=mlist:  (jit nothing, create a file in the current directory)
 // FOO=list:1-1000 (jit the first 1000 methods from file "list")
 // FOO=java/lang/Object::<init>  (jit just a single method)
 // FOO=-<init>,-<clinit> (jit all but initializers)
 // FOO=list:1-100,-50-60 (jit methods 1-49 and 61-100)
 // FOO=(I)  (jit only methods with a single int in the signature)
 // FOO=(Ljava/lang/Object;)
 // FOO=(L;)  (jit only methods with a single class ptr in signature)

 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include "VMInterface.h"
 #include "Type.h"
 #include "methodtable.h"

 namespace Jitrino {

 #define CLASS_METHOD_SEPARATOR_CHAR ':'
 #define DESCRIPTOR_START_CHAR '('
 #define DESCRIPTOR_END_CHAR ')'
 #define REF_START_CHAR 'L'
 #define REF_END_CHAR ';'
 #define FILE_CHAR ':'


 char* strdup(MemoryManager& mm , const char* str) {
     size_t len  = strlen(str);
     char* newstr = new (mm) char[len+1];
     strncpy(newstr, str, len);
     newstr[len]='\0';
     return newstr;
 }

 void Method_Table::make_filename(char *str, int len)
 {
     _method_file = new (_mm) char[1+len];
     strncpy(_method_file, str, len);
     _method_file[len] = '\0';
 }

 // Decides whether two signatures match.  The strictest test is
 // strcmp(), but we are more lenient by allowing "L;" instead of,
 // e.g., "Ljava/lang/Object;".  Anything following the ')' (i.e.,
 // the return value) of either string is ignored.
 static bool matching_signature(const char *lenient, const char *exact)
 {
     int i, j;
     int len1 = (int) strlen(lenient);
     int len2 = (int) strlen(exact);
     for (i=j=0; i<len1 && j<len2; i++,j++)
     {
         if (lenient[i] != exact[j])
             return false;
         if (lenient[i] == DESCRIPTOR_END_CHAR)
             return true;
         if (lenient[i] == REF_START_CHAR)
         {
             i++; j++;
             if (lenient[i] == REF_END_CHAR) // accept any classname
             {
                 while (j < len2 && exact[j] != REF_END_CHAR)
                     j ++;
             }
             else
             {
                 while (i < len1 && j < len2 && lenient[i] != REF_END_CHAR)
                 {
                     if (lenient[i] != exact[j])
                         return false;
                     i++; j++;
                 }
             }
         }
     }
     return (i == len1 && j == len2);
 }

 // [class::][method][(signature)]
 static void parse_method_string(MemoryManager& _mm, char *str, Method_Table::method_record *rec)
 {
     int i;
     int len = (int) strlen(str);

     rec->class_name = rec->method_name = rec->signature = NULL;
     if (len == 0)
         return;

     bool is_at_class_method_separator = false;
     // Search forward for CLASS_METHOD_SEPARATOR_CHAR or DESCRIPTOR_START_CHAR
     for (i=0; i<len; i++)
     {
         is_at_class_method_separator =
             (str[i] == CLASS_METHOD_SEPARATOR_CHAR && str[i+1] == CLASS_METHOD_SEPARATOR_CHAR);
         if (is_at_class_method_separator)
         {
             i ++; // make i point to the last character of the separator
             break;
         }
         if (str[i] == DESCRIPTOR_START_CHAR)
             break;
     }
     if (i >= len) // no class or descriptor
     {
         if (str[0] != '\0')
             rec->method_name = strdup(_mm, str);
         return;
     }
     if (is_at_class_method_separator)
     {
         // extract the class
         rec->class_name = new (_mm) char[i-1 + 1];
         strncpy(rec->class_name, str, i-1);
         rec->class_name[i-1] = '\0';
         // skip ahead to the descriptor
         str += (i+1);
         len -= (i+1);
         for (i=0; i<len; i++)
         {
             if (str[i] == DESCRIPTOR_START_CHAR)
                 break;
         }
         if (i >= len) // no descriptor
         {
             if (str[0] != '\0')
                 rec->method_name = strdup(_mm, str);
             return;
         }
     }
     // we're at the start of the signature, with the method name preceding
     if (i > 0)
     {
         rec->method_name = new (_mm) char[i+1];
         strncpy(rec->method_name, str, i);
         rec->method_name[i] = '\0';
     }
     rec->signature = strdup(_mm, &str[i]);
 }

 // Returns true on success, false on failure
 bool Method_Table::read_method_table()
 {
     const size_t max_size = 1000;
     char buf[max_size];
     FILE *file = fopen(_method_file, "r");
     if (file == NULL)
     {
         fprintf(stderr, "Couldn't open method table file %s\n", _method_file);
         return false;
     }
     while (fgets(buf, max_size, file) != NULL)
     {
         // strip out any newline at the end
         int buflen = (int) strlen(buf);
         if (buf[buflen-1] == '\n')
             buf[buflen-1] = '\0';
         if (buf[buflen-2] == '\r') // file generated on NT and used on Linux,
             buf[buflen-2] = '\0';    // this case happens
         method_record* rec = new (_mm) method_record();
         parse_method_string(_mm, buf, rec);
         _method_table.push_back(rec);
     }
     fclose(file);
     return true;
 }

 static bool matches(Method_Table::method_record *test_entry,
                     const char *class_name, const char *method_name, const char *signature)
 {
     if (test_entry->class_name != NULL && strcmp(test_entry->class_name, class_name) != 0)
         return false;
     if (test_entry->method_name != NULL && strcmp(test_entry->method_name, method_name) != 0)
         return false;
     if (test_entry->signature != NULL && !matching_signature(test_entry->signature, signature))
         return false;
     return true;
 }

 void Method_Table::init(const char *default_envvar, const char *envvarname)
 {
     if (default_envvar == NULL || default_envvar[0] == '\0')
     {
         return;
     }

     char *rangestr;
     char *envvar = strdup(_mm, default_envvar);

    // strip away double-quote characters
     if (envvar[0] == '"') {
         envvar ++;
     }
     int evlen = (int) strlen(envvar);
     if (evlen > 0 && envvar[evlen-1] == '"') {
         envvar[--evlen] = '\0';
     }
     if (evlen == 0) {
         return;
     }
     int i;
     for (i=evlen-1; i>=0; i--)
     {
         if (FILE_CHAR == CLASS_METHOD_SEPARATOR_CHAR)
         {
             // If we are looking at FILE_CHAR and the character to the left is not FILE_CHAR,
             // then this is a legitimate FILE_CHAR.
             if (envvar[i] == FILE_CHAR && (i == 0 || envvar[i-1] != FILE_CHAR))
                 break;
             // If we are looking at FILE_CHAR and the character to the left is also FILE_CHAR,
             // then we are actually looking at a double CLASS_METHOD_SEPARATOR_CHAR, which
             // we should skip over.
             if (envvar[i] == FILE_CHAR && i != 0 && envvar[i-1] == FILE_CHAR)
                 i --;
         } else {
             if (envvar[i] == FILE_CHAR)
                 break;
         }
     }
     if (i == 0) // no legitimate filename given
     {
         return;
     }
     else if (i == evlen-1) // filename only, no ranges
     {
         make_filename(envvar, evlen-1);
         _dump_to_file = true;
         FILE *file = fopen(_method_file, "w");
         if (file == NULL)
         {
             fprintf(stderr, "Couldn't truncate method table file %s\n",
                 _method_file);
             _dump_to_file = false;
         }
         else
             fclose(file);
         return;
     }
     else if (i >= 0) // filename plus ranges
     {
         make_filename(envvar, i);
         rangestr = &envvar[i+1];
         read_method_table();
     }
     else // no filename, only ranges
     {
         rangestr = envvar;
     }
     // parse the ranges in rangestr
     for (rangestr=strtok(rangestr, ","); rangestr!=NULL; rangestr=strtok(NULL, ","))
     {
         int opposite = 0;
         int start, end;
         if (rangestr[0] == '-')
         {
             opposite = 1;
             rangestr ++;
         }
         else
         {
             _default_decision = mt_rejected;
         }
         if (rangestr[0] >= '0' && rangestr[0] <= '9') {
             // look for a range of numbers
             sscanf(rangestr, "%d", &start);
             end = start;
             while (rangestr[0] != '\0' && rangestr[0] != '-') {
                 rangestr ++;
             }
             if (rangestr[0] == '-') {
                 sscanf(rangestr+1, "%d", &end);
             }
             start --;
             if (start < 0) {
                 start = 0;
             }
             end --;
             for (i=start; i<=end && i<(int)_method_table.size(); i++) {
                 _method_table[i]->decision = (opposite ? mt_rejected : mt_accepted);
             }
         } else {
             method_record* rec = new (_mm) method_record();
             parse_method_string(_mm, rangestr, rec);
             rec->decision = (opposite ? mt_rejected : mt_accepted);
             _decision_table.push_back(rec);
         }
     }

     // change all "undecided" to default decision
     for (i=0; i<(int)_method_table.size(); i++) {
         if (_method_table[i]->decision == mt_undecided) {
             _method_table[i]->decision = _default_decision;
         }
     }

 }

 Method_Table::Method_Table(MemoryManager& memManager,
                            const char *default_envvar,
                            const char *envvarname,
                            bool accept_by_default):
   _mm(memManager),
   _method_table     (_mm),
   _decision_table   (_mm),
   _dump_to_file     (false),
   _method_file      (NULL)
 {
     _default_decision = accept_by_default ? mt_accepted : mt_rejected;
     init(default_envvar, envvarname);
 }

 bool Method_Table::accept_this_method(MethodDesc &md) {
     const char* classname = md.getParentType()->getName();
     const char *methodname = md.getName();
     const char *signature = md.getSignatureString();

     return accept_this_method(classname, methodname, signature);
 }

 bool Method_Table::accept_this_method(const char* classname, const char *methodname, const char *signature)
 {
     int i;


     if (_dump_to_file)
     {
         FILE *file = fopen(_method_file, "a");
         if (file != NULL)
         {
             fprintf(file, "%s%c%c%s%s\n", classname, CLASS_METHOD_SEPARATOR_CHAR, CLASS_METHOD_SEPARATOR_CHAR, methodname, signature);
             fclose(file);
         }
         return false;
     }

     // First look through the decision_table strings.
     for (i=0; i<(int)_decision_table.size(); i++)
     {
         if (matches(_decision_table[i], classname, methodname, signature)) {
             return (_decision_table[i]->decision == mt_accepted);
         }
     }

     // Then look through the method table.
     for (i=0; i<(int)_method_table.size(); i++) {
         if ((_method_table[i]->class_name==NULL || !strcmp(_method_table[i]->class_name, classname)) &&
             (_method_table[i]->method_name==NULL || !strcmp(_method_table[i]->method_name, methodname)) &&
             (_method_table[i]->signature==NULL || matching_signature(_method_table[i]->signature, signature)))
         {
             return (_method_table[i]->decision == mt_accepted);
         }
     }
     return (_default_decision == mt_rejected ? false : true);
 }

 bool Method_Table::is_in_list_generation_mode() {
     return _dump_to_file;
 }

 void Method_Table::add_method_record(const char* className, const char* methodName, const char* signature, Method_Table::Decision decision, bool copyVals) {
     method_record* rec = new (_mm) method_record();
     if (copyVals) {
         size_t len = strlen(className)+1; //+1 == '\0' char
         rec->class_name = new (_mm) char[len];
         strncpy(rec->class_name, className, len);

         len = strlen(methodName)+1; //+1 == '\0' char
         rec->method_name= new (_mm) char[len];
         strncpy(rec->method_name, methodName, len);

         len = strlen(signature)+1; //+1 == '\0' char
         rec->signature= new (_mm) char[len];
         strncpy(rec->signature, signature, len);
     } else {
         rec->class_name = (char*)className;
         rec->method_name = (char*)methodName;
         rec->signature = (char*)signature;
     }
     rec->decision = decision;
     _method_table.push_back(rec);
 }

 } //namespace Jitrino
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/**
	* @author Intel, Mikhail Y. Fursov
	*
	*/

	//
	// Decides whether or not to "accept" a method based on an environment
	// variable and an optional file.
	//
	// Assume FOO is the environment variable that gives the information.
	//
	// FOO=file:range_list
	//
	// "file" is the name of the file that contains the list of all
	// methods.
	//
	// If "range_list" is empty, no methods are jitted, and the list of
	// methods is printed to "file".
	//
	// "range_list" contains a list of methods and ranges, separated by
	// commas. A single number denotes a one-based index into the method
	// list. A range (start-end) denotes a range of indices into the
	// method list.
	// The string "class::method" denotes a specific method.
	// "class::" matches all methods of the given class.
	// "method" (not containing a colon) matches that method of
	// any class.
	// A "-" preceding a list element means to exclude that method(s) from
	// the list of methods to jit.
	//
	// FOO=c:\tmp\mlist: (jit nothing, create a method list file)
	// FOO=mlist: (jit nothing, create a file in the current directory)
	// FOO=list:1-1000 (jit the first 1000 methods from file "list")
	// FOO=java/lang/Object::<init> (jit just a single method)
	// FOO=-<init>,-<clinit> (jit all but initializers)
	// FOO=list:1-100,-50-60 (jit methods 1-49 and 61-100)
	// FOO=(I) (jit only methods with a single int in the signature)
	// FOO=(Ljava/lang/Object;)
	// FOO=(L;) (jit only methods with a single class ptr in signature)

	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>
	#include "VMInterface.h"
	#include "Type.h"
	#include "methodtable.h"

	namespace Jitrino {

	#define CLASS_METHOD_SEPARATOR_CHAR ':'
	#define DESCRIPTOR_START_CHAR '('
	#define DESCRIPTOR_END_CHAR ')'
	#define REF_START_CHAR 'L'
	#define REF_END_CHAR ';'
	#define FILE_CHAR ':'


	char* strdup(MemoryManager& mm , const char* str) {
	size_t len = strlen(str);
	char* newstr = new (mm) char[len+1];
	strncpy(newstr, str, len);
	newstr[len]='\0';
	return newstr;
	}

	void Method_Table::make_filename(char *str, int len)
	{
	_method_file = new (_mm) char[1+len];
	strncpy(_method_file, str, len);
	_method_file[len] = '\0';
	}

	// Decides whether two signatures match. The strictest test is
	// strcmp(), but we are more lenient by allowing "L;" instead of,
	// e.g., "Ljava/lang/Object;". Anything following the ')' (i.e.,
	// the return value) of either string is ignored.
	static bool matching_signature(const char lenient, const char exact)
	{
	int i, j;
	int len1 = (int) strlen(lenient);
	int len2 = (int) strlen(exact);
	for (i=j=0; i<len1 && j<len2; i++,j++)
	{
	if (lenient[i] != exact[j])
	return false;
	if (lenient[i] == DESCRIPTOR_END_CHAR)
	return true;
	if (lenient[i] == REF_START_CHAR)
	{
	i++; j++;
	if (lenient[i] == REF_END_CHAR) // accept any classname
	{
	while (j < len2 && exact[j] != REF_END_CHAR)
	j ++;
	}
	else
	{
	while (i < len1 && j < len2 && lenient[i] != REF_END_CHAR)
	{
	if (lenient[i] != exact[j])
	return false;
	i++; j++;
	}
	}
	}
	}
	return (i == len1 && j == len2);
	}

	// [class::][method][(signature)]
	static void parse_method_string(MemoryManager& _mm, char str, Method_Table::method_record rec)
	{
	int i;
	int len = (int) strlen(str);

	rec->class_name = rec->method_name = rec->signature = NULL;
	if (len == 0)
	return;

	bool is_at_class_method_separator = false;
	// Search forward for CLASS_METHOD_SEPARATOR_CHAR or DESCRIPTOR_START_CHAR
	for (i=0; i<len; i++)
	{
	is_at_class_method_separator =
	(str[i] == CLASS_METHOD_SEPARATOR_CHAR && str[i+1] == CLASS_METHOD_SEPARATOR_CHAR);
	if (is_at_class_method_separator)
	{
	i ++; // make i point to the last character of the separator
	break;
	}
	if (str[i] == DESCRIPTOR_START_CHAR)
	break;
	}
	if (i >= len) // no class or descriptor
	{
	if (str[0] != '\0')
	rec->method_name = strdup(_mm, str);
	return;
	}
	if (is_at_class_method_separator)
	{
	// extract the class
	rec->class_name = new (_mm) char[i-1 + 1];
	strncpy(rec->class_name, str, i-1);
	rec->class_name[i-1] = '\0';
	// skip ahead to the descriptor
	str += (i+1);
	len -= (i+1);
	for (i=0; i<len; i++)
	{
	if (str[i] == DESCRIPTOR_START_CHAR)
	break;
	}
	if (i >= len) // no descriptor
	{
	if (str[0] != '\0')
	rec->method_name = strdup(_mm, str);
	return;
	}
	}
	// we're at the start of the signature, with the method name preceding
	if (i > 0)
	{
	rec->method_name = new (_mm) char[i+1];
	strncpy(rec->method_name, str, i);
	rec->method_name[i] = '\0';
	}
	rec->signature = strdup(_mm, &str[i]);
	}

	// Returns true on success, false on failure
	bool Method_Table::read_method_table()
	{
	const size_t max_size = 1000;
	char buf[max_size];
	FILE *file = fopen(_method_file, "r");
	if (file == NULL)
	{
	fprintf(stderr, "Couldn't open method table file %s\n", _method_file);
	return false;
	}
	while (fgets(buf, max_size, file) != NULL)
	{
	// strip out any newline at the end
	int buflen = (int) strlen(buf);
	if (buf[buflen-1] == '\n')
	buf[buflen-1] = '\0';
	if (buf[buflen-2] == '\r') // file generated on NT and used on Linux,
	buf[buflen-2] = '\0'; // this case happens
	method_record* rec = new (_mm) method_record();
	parse_method_string(_mm, buf, rec);
	_method_table.push_back(rec);
	}
	fclose(file);
	return true;
	}

	static bool matches(Method_Table::method_record *test_entry,
	const char class_name, const char method_name, const char *signature)
	{
	if (test_entry->class_name != NULL && strcmp(test_entry->class_name, class_name) != 0)
	return false;
	if (test_entry->method_name != NULL && strcmp(test_entry->method_name, method_name) != 0)
	return false;
	if (test_entry->signature != NULL && !matching_signature(test_entry->signature, signature))
	return false;
	return true;
	}

	void Method_Table::init(const char default_envvar, const char envvarname)
	{
	if (default_envvar == NULL \|\| default_envvar[0] == '\0')
	{
	return;
	}

	char *rangestr;
	char *envvar = strdup(_mm, default_envvar);

	// strip away double-quote characters
	if (envvar[0] == '"') {
	envvar ++;
	}
	int evlen = (int) strlen(envvar);
	if (evlen > 0 && envvar[evlen-1] == '"') {
	envvar[--evlen] = '\0';
	}
	if (evlen == 0) {
	return;
	}
	int i;
	for (i=evlen-1; i>=0; i--)
	{
	if (FILE_CHAR == CLASS_METHOD_SEPARATOR_CHAR)
	{
	// If we are looking at FILE_CHAR and the character to the left is not FILE_CHAR,
	// then this is a legitimate FILE_CHAR.
	if (envvar[i] == FILE_CHAR && (i == 0 \|\| envvar[i-1] != FILE_CHAR))
	break;
	// If we are looking at FILE_CHAR and the character to the left is also FILE_CHAR,
	// then we are actually looking at a double CLASS_METHOD_SEPARATOR_CHAR, which
	// we should skip over.
	if (envvar[i] == FILE_CHAR && i != 0 && envvar[i-1] == FILE_CHAR)
	i --;
	} else {
	if (envvar[i] == FILE_CHAR)
	break;
	}
	}
	if (i == 0) // no legitimate filename given
	{
	return;
	}
	else if (i == evlen-1) // filename only, no ranges
	{
	make_filename(envvar, evlen-1);
	_dump_to_file = true;
	FILE *file = fopen(_method_file, "w");
	if (file == NULL)
	{
	fprintf(stderr, "Couldn't truncate method table file %s\n",
	_method_file);
	_dump_to_file = false;
	}
	else
	fclose(file);
	return;
	}
	else if (i >= 0) // filename plus ranges
	{
	make_filename(envvar, i);
	rangestr = &envvar[i+1];
	read_method_table();
	}
	else // no filename, only ranges
	{
	rangestr = envvar;
	}
	// parse the ranges in rangestr
	for (rangestr=strtok(rangestr, ","); rangestr!=NULL; rangestr=strtok(NULL, ","))
	{
	int opposite = 0;
	int start, end;
	if (rangestr[0] == '-')
	{
	opposite = 1;
	rangestr ++;
	}
	else
	{
	_default_decision = mt_rejected;
	}
	if (rangestr[0] >= '0' && rangestr[0] <= '9') {
	// look for a range of numbers
	sscanf(rangestr, "%d", &start);
	end = start;
	while (rangestr[0] != '\0' && rangestr[0] != '-') {
	rangestr ++;
	}
	if (rangestr[0] == '-') {
	sscanf(rangestr+1, "%d", &end);
	}
	start --;
	if (start < 0) {
	start = 0;
	}
	end --;
	for (i=start; i<=end && i<(int)_method_table.size(); i++) {
	_method_table[i]->decision = (opposite ? mt_rejected : mt_accepted);
	}
	} else {
	method_record* rec = new (_mm) method_record();
	parse_method_string(_mm, rangestr, rec);
	rec->decision = (opposite ? mt_rejected : mt_accepted);
	_decision_table.push_back(rec);
	}
	}

	// change all "undecided" to default decision
	for (i=0; i<(int)_method_table.size(); i++) {
	if (_method_table[i]->decision == mt_undecided) {
	_method_table[i]->decision = _default_decision;
	}
	}

	}

	Method_Table::Method_Table(MemoryManager& memManager,
	const char *default_envvar,
	const char *envvarname,
	bool accept_by_default):
	_mm(memManager),
	_method_table (_mm),
	_decision_table (_mm),
	_dump_to_file (false),
	_method_file (NULL)
	{
	_default_decision = accept_by_default ? mt_accepted : mt_rejected;
	init(default_envvar, envvarname);
	}

	bool Method_Table::accept_this_method(MethodDesc &md) {
	const char* classname = md.getParentType()->getName();
	const char *methodname = md.getName();
	const char *signature = md.getSignatureString();

	return accept_this_method(classname, methodname, signature);
	}

	bool Method_Table::accept_this_method(const char* classname, const char methodname, const char signature)
	{
	int i;


	if (_dump_to_file)
	{
	FILE *file = fopen(_method_file, "a");
	if (file != NULL)
	{
	fprintf(file, "%s%c%c%s%s\n", classname, CLASS_METHOD_SEPARATOR_CHAR, CLASS_METHOD_SEPARATOR_CHAR, methodname, signature);
	fclose(file);
	}
	return false;
	}

	// First look through the decision_table strings.
	for (i=0; i<(int)_decision_table.size(); i++)
	{
	if (matches(_decision_table[i], classname, methodname, signature)) {
	return (_decision_table[i]->decision == mt_accepted);
	}
	}

	// Then look through the method table.
	for (i=0; i<(int)_method_table.size(); i++) {
	if ((_method_table[i]->class_name==NULL \|\| !strcmp(_method_table[i]->class_name, classname)) &&
	(_method_table[i]->method_name==NULL \|\| !strcmp(_method_table[i]->method_name, methodname)) &&
	(_method_table[i]->signature==NULL \|\| matching_signature(_method_table[i]->signature, signature)))
	{
	return (_method_table[i]->decision == mt_accepted);
	}
	}
	return (_default_decision == mt_rejected ? false : true);
	}

	bool Method_Table::is_in_list_generation_mode() {
	return _dump_to_file;
	}

	void Method_Table::add_method_record(const char* className, const char* methodName, const char* signature, Method_Table::Decision decision, bool copyVals) {
	method_record* rec = new (_mm) method_record();
	if (copyVals) {
	size_t len = strlen(className)+1; //+1 == '\0' char
	rec->class_name = new (_mm) char[len];
	strncpy(rec->class_name, className, len);

	len = strlen(methodName)+1; //+1 == '\0' char
	rec->method_name= new (_mm) char[len];
	strncpy(rec->method_name, methodName, len);

	len = strlen(signature)+1; //+1 == '\0' char
	rec->signature= new (_mm) char[len];
	strncpy(rec->signature, signature, len);
	} else {
	rec->class_name = (char*)className;
	rec->method_name = (char*)methodName;
	rec->signature = (char*)signature;
	}
	rec->decision = decision;
	_method_table.push_back(rec);
	}

	} //namespace Jitrino