static PyObject *UnaryPredicate1D___call__(BPy_UnaryPredicate1D *self, PyObject *args, PyObject *kwds)
{
	static const char *kwlist[] = {"inter", NULL};
	PyObject *py_if1D;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &Interface1D_Type, &py_if1D))
		return NULL;

	Interface1D *if1D = ((BPy_Interface1D *)py_if1D)->if1D;

	if (!if1D) {
		string class_name(Py_TYPE(self)->tp_name);
		PyErr_SetString(PyExc_RuntimeError, (class_name + " has no Interface1D").c_str());
		return NULL;
	}
	if (typeid(*(self->up1D)) == typeid(UnaryPredicate1D)) {
		PyErr_SetString(PyExc_TypeError, "__call__ method not properly overridden");
		return NULL;
	}
	if (self->up1D->operator()(*if1D) < 0) {
		if (!PyErr_Occurred()) {
			string class_name(Py_TYPE(self)->tp_name);
			PyErr_SetString(PyExc_RuntimeError, (class_name + " __call__ method failed").c_str());
		}
		return NULL;
	}
	return PyBool_from_bool(self->up1D->result);
}

void
Halftone_TX::activate_layer_textures()
{
   GLSLShader_Layer_Base::activate_layer_textures();

   for (vector<layer_base_t*>::size_type i=0; i<_layers.size(); i++) {
      //main tone correction map
      halftone_layer_t* layer = get_layer(i);
      if (layer->_use_tone_correction) {
         
         if (!activate_texture(
                tone_correction_maps[layer->_tone_correction_tex_stage])
            )
            cerr << class_name()
                 << ": can't activate tone correction texture at stage: "
                 << layer->_tone_correction_tex_stage << endl;
      }

      // forward R function
      if (layer->_use_lod_only) {
         if (!activate_texture(r_function_maps[layer->_r_function_tex_stage]))
            cerr << class_name()
                 << ": can't activate R function texture at stage: "
                 << layer->_r_function_tex_loc << endl;
      }
   }
}

fsm_env::fsm_env(xcs_config_mgr2& xcs_config)
{
	if (!fsm_env::init)
	{
		if (!xcs_config.exist(tag_name()))
		{
			xcs_utility::error(class_name(), "constructor", "section <" + tag_name() + "> not found", 1);	
		}
		
		try {
			state_bits    = (long) xcs_config.Value(tag_name(), "number of bits");
			states_number = (long) xcs_config.Value(tag_name(), "number of states");
		} catch (const char *attribute) {
			string msg = "attribute \'" + string(attribute) + "\' not found in <" + tag_name() + ">";
			xcs_utility::error(class_name(), "constructor", msg, 1);
		}

		//! look for the init section in the configuration file
		string input_configuration;
		
		if ((states_number%2) == 0)			
			xcs_utility::error(class_name(),"class constructor", "Number of states must be even", 1);
		
		current_state = 0;
		final_state = (states_number-1)/2;
	
		set_state();
	}
	fsm_env::init = true;
}

static void gf_stat( obj gf )
{
  int i;
  obj p, k;

  fprintf( foo, "%s status: ",
	   symbol_text( gvec_ref( gf, SLOT(3) ) ) );
  for (i=0; i<4; i++)
    {
      k = gvec_ref( gf, SLOT(i*2) + GF_CACHE_0_K );
      if (truish(k))
	fprintf( foo, " %s", symbol_text(class_name(k)) );
      else
	fprintf( foo, " #f" );
    }
  fprintf( foo, " |" );
  k = gvec_ref( gf, GF_VICTIM_K );
  if (truish(k))
    fprintf( foo, " %s", symbol_text(class_name(k)) );
  else
    fprintf( foo, " #f" );

  fprintf( foo, " |" );
  for (p=gvec_ref(gf,GF_CACHE_OVERFLOW);truish(p);p=gvec_ref(p,0))
    {
      k = gvec_ref(p,SLOT(1));
      fprintf( foo, " %s", symbol_text(class_name(k)) );
    }
  fprintf( foo, "\n" );
}

fbstring exception_wrapper::what() const {
  if (item_) {
    return exceptionStr(*item_);
  } else if (eptr_ && eobj_) {
    return class_name() + ": " + eobj_->what();
  } else if (eptr_ && etype_) {
    return class_name();
  } else {
    return class_name();
  }
}

/*!
Constructor

\param name
name used for error reporting
*/
atomic_base( const std::string&  name) :
index_( class_object().size() )     ,
sparsity_( set_sparsity_enum )
{	CPPAD_ASSERT_KNOWN(
		! thread_alloc::in_parallel() ,
		"atomic_base: constructor cannot be called in parallel mode."
	);
	class_object().push_back(this);
	class_name().push_back(name);
	CPPAD_ASSERT_UNKNOWN( class_object().size() == class_name().size() );
}

jboolean ClassMatchModifier::class_match(DebuggerEvent *d_event)
{
  UsingFastOops fast_oops;

  JavaClass::Fast clazz = JavaDebugger::get_object_by_id(d_event->clazz_id());
  TypeSymbol::Fast class_name = clazz().name();
  Symbol::Fast mod_name =  class_match_name(); 

  if (mod_name.is_null() || class_name.is_null())
    return true;

  if (clazz().is_obj_array_class()) {
    juint klass_index = class_name().decode_ushort_at(0);
    JavaClass::Raw klass = Universe::class_from_id(klass_index);
    ObjArrayClass::Raw oac = klass.obj();
    klass = oac().element_class();
    class_name = klass().name();
  } else  if (clazz().is_type_array_class()) {
      // just a basic type array, no match here.
      return false;
  }
  // class names in the VM are not necessarily stored with the current OS
  // file separator character, Win32 can use either type of slash

  if (mod_name().byte_at(0) == '*' ||
      mod_name().byte_at(mod_name().length()-1) == '*') {
    // We have a wildcard match.
    int complen = mod_name().length() - 1;
    int req_start = class_name().length() - complen;
    int mod_start = 0;

    if (req_start < 0) {
      return false;
    } else { 
      if (mod_name().byte_at(0) == '*') {
        // suffix match
        // just compare the end of classname
        mod_start = 1;    // point to just past the '*'
      } else {
        req_start = 0;    // prefix match
      }
      return  (jvm_memcmp(mod_name().utf8_data() + mod_start,
                          class_name().utf8_data() + req_start, complen) == 0);
    }
  } else {
    // not a suffix/prefix match so just compare the two.
    return  mod_name().matches(&class_name());
  }
}

static PyObject *UnaryFunction1DVectorViewShape___call__(BPy_UnaryFunction1DVectorViewShape *self,
                                                         PyObject *args,
                                                         PyObject *kwds)
{
  static const char *kwlist[] = {"inter", NULL};
  PyObject *obj = 0;

  if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", (char **)kwlist, &Interface1D_Type, &obj))
    return NULL;

  if (typeid(*(self->uf1D_vectorviewshape)) == typeid(UnaryFunction1D<std::vector<ViewShape *>>)) {
    PyErr_SetString(PyExc_TypeError, "__call__ method not properly overridden");
    return NULL;
  }
  if (self->uf1D_vectorviewshape->operator()(*(((BPy_Interface1D *)obj)->if1D)) < 0) {
    if (!PyErr_Occurred()) {
      string class_name(Py_TYPE(self)->tp_name);
      PyErr_SetString(PyExc_RuntimeError, (class_name + " __call__ method failed").c_str());
    }
    return NULL;
  }

  const unsigned int list_len = self->uf1D_vectorviewshape->result.size();
  PyObject *list = PyList_New(list_len);
  for (unsigned int i = 0; i < list_len; i++) {
    ViewShape *v = self->uf1D_vectorviewshape->result[i];
    PyList_SET_ITEM(list, i, v ? BPy_ViewShape_from_ViewShape(*v) : (Py_INCREF(Py_None), Py_None));
  }

  return list;
}

void shade::shaders::VertexToFragmentCopy<T>::init_vertex_inline(formatter::Generator& generator) const
{
  std::string class_name(VertexToFragmentCopy::get_class_name());

  generator.handle_statement_begin();
  generator.handle_function_call_begin();
  generator.handle_function_call_name_begin();
  generator.handle_identifier(class_name+"_set_copy");
  generator.handle_function_call_name_end();
  generator.handle_function_call_parameter_list_begin();
  generator.handle_function_call_parameter_begin();
  generator.handle_identifier("self");
  generator.handle_function_call_parameter_end();
  generator.handle_function_call_parameter_begin();
  {
    generator.handle_function_call_begin();
    generator.handle_function_call_name_begin();
    generator.handle_identifier("Gettable_"+T<Type>().get_uniq_id()+"_get");
    generator.handle_function_call_name_end();
    generator.handle_function_call_parameter_list_begin();
    generator.handle_function_call_parameter_begin();
    generator.handle_identifier("value");
    generator.handle_function_call_parameter_end();
    generator.handle_function_call_parameter_list_end();
    generator.handle_function_call_end();
  }
  generator.handle_function_call_parameter_end();
  generator.handle_function_call_parameter_list_end();
  generator.handle_function_call_end();
  generator.handle_statement_end();
}

void PlotCellTree( TString fin = "weights/TMVAClassification_PDEFoam.weights_foams.root",
		   TString cv_long, bool useTMVAStyle=kTRUE )
{
   // Draw the PDEFoam cell tree

   cout << "read file: " << fin << endl;
   TFile *file = TFile::Open(fin);

   if (useTMVAStyle)  TMVAGlob::SetTMVAStyle();

   // find foams
   TListIter foamIter(gDirectory->GetListOfKeys());
   TKey *foam_key = NULL; // the foam key
   TCanvas *canv = NULL;  // the canvas
   while (foam_key = (TKey*) foamIter()) {
      TString name(foam_key->GetName());
      TString class_name(foam_key->GetClassName());
      if (!class_name.Contains("PDEFoam"))
	 continue;
      cout << "PDEFoam found: " << class_name << " " << name << endl;

      // read the foam
      TMVA::PDEFoam *foam = (TMVA::PDEFoam*) foam_key->ReadObj();
      canv = new TCanvas(Form("canvas_%s",name.Data()),
			 Form("%s of %s",cv_long.Data(),name.Data()), 640, 480);

      // get cell tree depth
      const UInt_t   depth = foam->GetRootCell()->GetTreeDepth();
      const Double_t ystep = 1.0 / depth;
      DrawCell(foam->GetRootCell(), foam, 0.5, 1.-0.5*ystep, 0.25, ystep);
   }

   file->Close();
}

char const * Standard_Low_Level_Exception::plain_what() const
{
    m_buffer=class_name();
    m_buffer+=": ";
    m_buffer+=m_plain_what;
    return m_buffer.c_str();
}

void PluginChoooserWidget::loadImpl()
{
	clear();
	Config group = Config().group("plugins/list");
	QStandardItem *parent_item = m_model->invisibleRootItem();

    QList<QWeakPointer<Plugin> > plugins = pluginsList();
	QStringList helper;
    for (int i = 0; i < plugins.size(); i++) {
        const PluginInfo &info = plugins.at(i).data()->info();
        QLatin1String class_name(plugins.at(i).data()->metaObject()->className());
        if (!m_plugin_items.contains(info.name())) {
			QIcon icon = info.icon();
			if (icon.isNull() || !icon.availableSizes().count())
				icon = Icon("applications-system");
			QString name = info.name();
			int index = qLowerBound(helper, name) - helper.constBegin();
			helper.insert(index, name);
			ServiceItem *item = new ServiceItem(icon, name);
			item->setToolTip(html(info));
			item->setCheckable(true);
			item->setData(true,ServiceItem::ExclusiveRole);
			item->setData(info.description().toString(), DescriptionRole);
			item->setCheckState((group.value(class_name, true) ? Qt::Checked : Qt::Unchecked));
			parent_item->insertRow(index, item);
			m_plugin_items.insert(class_name, item);
            m_plugins.insert(class_name, plugins.at(i).data());
		}
	}
}

CubitString CubitCoordinateSystem::entity_name() const
{
  CubitString name = class_name();
  name += " ";
  name += CubitString( this->id() );
  return name;
}

int main(int arg_count, char *args[])
{
  generator gen;
  int first_non_flag_index = process_options(gen, arg_count, args);
  int num_non_flag_args = arg_count - first_non_flag_index;

  if(num_non_flag_args != 1 && num_non_flag_args != 2)
  {
    std::cerr << "Usage: cppclassgen --<flags> <class_name> <module_name(optional)>" << std::endl;
    std::exit(-1);
  }

  std::string class_name(args[first_non_flag_index]);
  gen.m_tokens.push_back(std::make_pair("%CLASS_NAME%", class_name));
  auto class_name_upper = toupper(class_name);
  gen.m_tokens.push_back(std::make_pair("%CLASS_NAME_UPPER%", class_name_upper));

  if(num_non_flag_args == 2)
  {
    std::string module_name(args[first_non_flag_index + 1]);
    gen.m_tokens.push_back(std::make_pair("%MODULE_NAME%", module_name));
    toupper(module_name);
    auto module_name_upper = toupper(module_name);
    gen.m_tokens.push_back(std::make_pair("%MODULE_NAME_UPPER%", module_name_upper));
  }

  read_tokens_from_config_file(gen);
  create_new_file_from_template(gen, class_name, ".h");
  create_new_file_from_template(gen, class_name, ".cpp");

  return 0;
}

//fix:  We can't we just tell the head to print?  Are nodes not connected
//between chains?  If not, why not?
void ArpIndexedList::Print()
{
	//printf("Printing ArpIndexedList..\n");
	
	if (chain == 0) {
		printf("ArpIndexedList::Print() chain was NULL\n");
		return;
	}

	for(long i=0; i<count; i++) {
		printf("Chain %d", (int)i);
		if (chain[i] == NULL) {
			printf("\tNULL\n");
		} else {
			printf("\n");
			chain[i]->PrintListUntil(NextChainHeadFrom(i+1));
		}
	}		
	if (tailNode == 0) {
		printf("No tail node\n");
	} else {
		const char	*cn = class_name(tailNode);
		if (cn == 0) { printf("Tail node class: No class name\n");
		} else { printf("Tail node class: %s\n", cn); }
		fflush(stdout);

		tailNode->PrintContents();
	}
}

status_t TRotationEffect::TRotationState::Archive(BMessage* data, bool deep) const
{
	status_t err;
	err = data->AddString("class", class_name(this));
	if (err == B_OK)
		err = data->AddFloat(kRotationLabel, m_rotation);
	return err;
}

void engine::fill_class_data					(
		cs::lua_debugger::backend& backend,
		cs::lua_debugger::value_to_expand& value_to_expand,
		lua_State* const state
	)
{
	luabind::detail::object_rep		*object = static_cast<luabind::detail::object_rep*>(lua_touserdata(state,-2));
	luabind::detail::class_rep		*_class = static_cast<luabind::detail::class_rep*>(lua_touserdata(state,-1));
	R_ASSERT2						(_class, "invalid class userdata");

	{
		string4096					type;
		typedef luabind::detail::class_rep::base_info	base_info;
		vector_class<base_info>::const_iterator	i = _class->bases().begin();
		vector_class<base_info>::const_iterator	e = _class->bases().end();
		for ( ; i != e; ++i)
			value_to_expand.add_value	(
				(*i).base->name(),
				class_name(type, sizeof(type), *(*i).base),
				"{...}",
				cs::lua_debugger::icon_type_class_base
			);
	}

	if (!object)
		return;

	typedef luabind::detail::class_rep::property_map	property_map;
	property_map::const_iterator	i = _class->properties().begin();
	property_map::const_iterator	e = _class->properties().end();
	for ( ; i != e; ++i) {
		lua_pushstring			(state,(*i).first);
		lua_insert				(state,1);
		lua_pushlightuserdata	(state,object);
		lua_insert				(state,1);
		(*i).second.func		(state, (*i).second.pointer_offset);

		bool					use_in_description;
		
		string4096				type;
		backend.type_to_string	(type, sizeof(type), state, -1, use_in_description);
		
		cs::lua_debugger::icon_type	icon_type;
		string4096				value;
		backend.value_to_string	(value, sizeof(value), state, -1, icon_type, true);

		lua_pop_value			(state,1);
		lua_remove				(state,1);
		lua_remove				(state,1);

		value_to_expand.add_value	(
			(*i).first,
			type,
			value,
			icon_type
		);
	}
}

bool engine::type_convert_instance					(char *buffer, unsigned int const size, lua_State *state, int index)
{
	if (!is_luabind_class(state, index))
		return				(false);

	class_name				(buffer, size, *static_cast<luabind::detail::class_rep*>(lua_touserdata(state, index)));

	return					(true);
}

inline void register_value_type(TPythonClass &pyClass){ 
    typedef details::pair_exposer_t< TValueType, TValueCallPolicies > exposer_type;
    
    object class_name(pyClass.attr("__name__"));
    extract<std::string> class_name_extractor(class_name);
    std::string pair_name = class_name_extractor() + "_entry";
    
    exposer_type expose( pair_name );
}

void engine::expand_class_instance				(
		cs::lua_debugger::backend& backend,
		cs::lua_debugger::value_to_expand& value_to_expand,
		lua_State* const state
	)
{
	typedef luabind::detail::object_rep	object_rep;
	object_rep					*object = luabind::detail::is_class_object(state,-1);
	VERIFY2						(object, "invalid object userdata");

	if (object->crep()) {
		luabind::detail::class_rep	*class_rep = object->crep();
		
		string4096					type;
		class_name					(type, sizeof(type), *class_rep);

		cs::lua_debugger::icon_type	icon_type;
		string4096					value;
		backend.value_to_string		(value, sizeof(value), state, -1, icon_type, true);
		value_to_expand.add_value	(
			class_rep->name(),
			type,
			value,
			cs::lua_debugger::icon_type_class
		);
	}

	typedef luabind::detail::lua_reference	lua_reference;
	lua_reference const			&tbl = object->get_lua_table();
	if (!tbl.is_valid())
		return;

	tbl.get						(state);
	int							i;
	lua_pushnil					(state);
	for (i=0; lua_next(state,-2); ++i) {
		cs::lua_debugger::icon_type	icon_type;
		bool					use_in_description;
		pcstr					name = lua_to_string(state,-2);

		string4096				type;
		backend.type_to_string	(type, sizeof(type), state, -1, use_in_description);

		string4096				value;
		backend.value_to_string	(value, sizeof(value), state, -1, icon_type, true);
		value_to_expand.add_value	(
			name,
			type,
			value,
			icon_type
		);

		lua_pop_value			(state, 1);
	}

	lua_pop_value				(state, 1);
}