/* ------- code automatically created by ../scripts/adms_build_object.pl -------------- */
#include <admsObject/objectVariable.h>
#include <admsObject/objectAdmsmain.h>

inline void adms_variable_free(p_variable myvariable)
{
  if(!myvariable)
    return;
  adms_enumeration_free(myvariable->_subexpression._math._dependency);
  free(myvariable->_subexpression._math._value);
  {p_slist l=myvariable->_alias;for(;l;l=l->next) adms_quark_free(adms_quark(l->data));}
  adms_slist_free(myvariable->_alias);
  adms_slist_free(myvariable->_range);
  {p_slist l=myvariable->_attribute;for(;l;l=l->next) adms_attribute_free(adms_attribute(l->data));}
  adms_slist_free(myvariable->_attribute);
  adms_slist_free(myvariable->_assignment);
  adms_slist_free(myvariable->_probe);
  adms_slist_free(myvariable->_ddxprobe);
  adms_slist_free(myvariable->_variable);
  adms_quark_free(myvariable->_name);
  if(myvariable->_block)
    if(adms_adms(myvariable->_block)->_datatypename==adms_adms_enumeration_datatypename_quark)
      adms_quark_free(adms_quark(myvariable->_block));
  adms_enumeration_free(myvariable->_parametertype);
  adms_enumeration_free(myvariable->_type);
  adms_enumeration_free(myvariable->_sizetype);
  adms_enumeration_free(myvariable->_input);
  adms_enumeration_free(myvariable->_output);
  adms_enumeration_free(myvariable->_scope);
  adms_enumeration_free(myvariable->_derivate);
  adms_enumeration_free(myvariable->_isstate);
  adms_enumeration_free(myvariable->_usedinmodel);
  adms_enumeration_free(myvariable->_usedininstance);
  adms_enumeration_free(myvariable->_usedininitial_step);
  adms_enumeration_free(myvariable->_usedinevaluate);
  adms_enumeration_free(myvariable->_usedinnoise);
  adms_enumeration_free(myvariable->_usedinfinal);
  adms_enumeration_free(myvariable->_setinmodel);
  adms_enumeration_free(myvariable->_setininstance);
  adms_enumeration_free(myvariable->_setininitial_step);
  adms_enumeration_free(myvariable->_setinevaluate);
  adms_enumeration_free(myvariable->_setinnoise);
  adms_enumeration_free(myvariable->_setinfinal);
  adms_enumeration_free(myvariable->_setingetprev);
  adms_enumeration_free(myvariable->_TemperatureDependent);
  adms_enumeration_free(myvariable->_OPdependent);
  adms_enumeration_free(myvariable->_insource);
  adms_global_increment_nbvariabledestroy();
  free(myvariable);
}
int adms_variable_cmp (p_variable myvariable,p_variable refvariable)
{
  int status;
  status =
  (
    (adms_variable_valueof_module (myvariable) != adms_variable_valueof_module (refvariable))
    ||
    !!strcmp(adms_variable_valueof_name (myvariable)->_value,adms_variable_valueof_name (refvariable)->_value)
    ||
    (adms_variable_valueof_block (myvariable) != adms_variable_valueof_block (refvariable))
  );
  return status;
}
p_variable adms_variable_new(p_module mymodule,p_quark myname,p_adms myblock)
{
  p_variable mynewvariable=(p_variable) calloc(1,(size_t)sizeof(t_variable));
  adms_global_increment_nbvariablenew();
  mynewvariable->_subexpression._math._adms._datatypename=adms_adms_enumeration_datatypename_variable;
  mynewvariable->_subexpression._math._adms._seen=adms_adms_enumeration_seen_no;
  (mynewvariable->_subexpression._math)._value=adms_real_new(adms_NAN);
  (mynewvariable->_subexpression._math)._static=adms_enumeration_new(adms_math_enumeration_static_no,adms_math_fromstring_static_impl,adms_math_tostring_static_impl);
  (mynewvariable->_subexpression._math)._dynamic=adms_enumeration_new(adms_math_enumeration_dynamic_no,adms_math_fromstring_dynamic_impl,adms_math_tostring_dynamic_impl);
  (mynewvariable->_subexpression._math)._dependency=adms_enumeration_new(adms_math_enumeration_dependency_constant,adms_math_fromstring_dependency_impl,adms_math_tostring_dependency_impl);
  mynewvariable->_module_isdefault=-1;
  adms_variable_valueto_module (mynewvariable,mymodule);
  mynewvariable->_module_isdefault=1;
  mynewvariable->_name_isdefault=-1;
  adms_variable_valueto_name (mynewvariable,myname);
  mynewvariable->_name_isdefault=1;
  mynewvariable->_block_isdefault=-1;
  adms_variable_valueto_block (mynewvariable,myblock);
  mynewvariable->_block_isdefault=1;
  mynewvariable->_parametertype_isdefault=-1;
  adms_variable_valueto_parametertype(mynewvariable,adms_enumeration_new(adms_variable_enumeration_parametertype_model,adms_variable_fromstring_parametertype_impl,adms_variable_tostring_parametertype_impl));
  mynewvariable->_parametertype_isdefault=1;
  mynewvariable->_type_isdefault=-1;
  adms_variable_valueto_type(mynewvariable,adms_enumeration_new(adms_variable_enumeration_type_real,adms_variable_fromstring_type_impl,adms_variable_tostring_type_impl));
  mynewvariable->_type_isdefault=1;
  mynewvariable->_sizetype_isdefault=-1;
  adms_variable_valueto_sizetype(mynewvariable,adms_enumeration_new(adms_variable_enumeration_sizetype_scalar,adms_variable_fromstring_sizetype_impl,adms_variable_tostring_sizetype_impl));
  mynewvariable->_sizetype_isdefault=1;
  mynewvariable->_maxsize_isdefault=-1;
  mynewvariable->_minsize_isdefault=-1;
  mynewvariable->_input_isdefault=-1;
  adms_variable_valueto_input(mynewvariable,adms_enumeration_new(adms_variable_enumeration_input_no,adms_variable_fromstring_input_impl,adms_variable_tostring_input_impl));
  mynewvariable->_input_isdefault=1;
  mynewvariable->_output_isdefault=-1;
  adms_variable_valueto_output(mynewvariable,adms_enumeration_new(adms_variable_enumeration_output_no,adms_variable_fromstring_output_impl,adms_variable_tostring_output_impl));
  mynewvariable->_output_isdefault=1;
  mynewvariable->_scope_isdefault=-1;
  adms_variable_valueto_scope(mynewvariable,adms_enumeration_new(adms_variable_enumeration_scope_local,adms_variable_fromstring_scope_impl,adms_variable_tostring_scope_impl));
  mynewvariable->_scope_isdefault=1;
  mynewvariable->_default_isdefault=-1;
  mynewvariable->_derivate_isdefault=-1;
  adms_variable_valueto_derivate(mynewvariable,adms_enumeration_new(adms_variable_enumeration_derivate_no,adms_variable_fromstring_derivate_impl,adms_variable_tostring_derivate_impl));
  mynewvariable->_derivate_isdefault=1;
  mynewvariable->_isstate_isdefault=-1;
  adms_variable_valueto_isstate(mynewvariable,adms_enumeration_new(adms_variable_enumeration_isstate_no,adms_variable_fromstring_isstate_impl,adms_variable_tostring_isstate_impl));
  mynewvariable->_isstate_isdefault=1;
  mynewvariable->_usedinmodel_isdefault=-1;
  adms_variable_valueto_usedinmodel(mynewvariable,adms_enumeration_new(adms_variable_enumeration_usedinmodel_no,adms_variable_fromstring_usedinmodel_impl,adms_variable_tostring_usedinmodel_impl));
  mynewvariable->_usedinmodel_isdefault=1;
  mynewvariable->_usedininstance_isdefault=-1;
  adms_variable_valueto_usedininstance(mynewvariable,adms_enumeration_new(adms_variable_enumeration_usedininstance_no,adms_variable_fromstring_usedininstance_impl,adms_variable_tostring_usedininstance_impl));
  mynewvariable->_usedininstance_isdefault=1;
  mynewvariable->_usedininitial_step_isdefault=-1;
  adms_variable_valueto_usedininitial_step(mynewvariable,adms_enumeration_new(adms_variable_enumeration_usedininitial_step_no,adms_variable_fromstring_usedininitial_step_impl,adms_variable_tostring_usedininitial_step_impl));
  mynewvariable->_usedininitial_step_isdefault=1;
  mynewvariable->_usedinevaluate_isdefault=-1;
  adms_variable_valueto_usedinevaluate(mynewvariable,adms_enumeration_new(adms_variable_enumeration_usedinevaluate_no,adms_variable_fromstring_usedinevaluate_impl,adms_variable_tostring_usedinevaluate_impl));
  mynewvariable->_usedinevaluate_isdefault=1;
  mynewvariable->_usedinnoise_isdefault=-1;
  adms_variable_valueto_usedinnoise(mynewvariable,adms_enumeration_new(adms_variable_enumeration_usedinnoise_no,adms_variable_fromstring_usedinnoise_impl,adms_variable_tostring_usedinnoise_impl));
  mynewvariable->_usedinnoise_isdefault=1;
  mynewvariable->_usedinfinal_isdefault=-1;
  adms_variable_valueto_usedinfinal(mynewvariable,adms_enumeration_new(adms_variable_enumeration_usedinfinal_no,adms_variable_fromstring_usedinfinal_impl,adms_variable_tostring_usedinfinal_impl));
  mynewvariable->_usedinfinal_isdefault=1;
  mynewvariable->_setinmodel_isdefault=-1;
  adms_variable_valueto_setinmodel(mynewvariable,adms_enumeration_new(adms_variable_enumeration_setinmodel_no,adms_variable_fromstring_setinmodel_impl,adms_variable_tostring_setinmodel_impl));
  mynewvariable->_setinmodel_isdefault=1;
  mynewvariable->_setininstance_isdefault=-1;
  adms_variable_valueto_setininstance(mynewvariable,adms_enumeration_new(adms_variable_enumeration_setininstance_no,adms_variable_fromstring_setininstance_impl,adms_variable_tostring_setininstance_impl));
  mynewvariable->_setininstance_isdefault=1;
  mynewvariable->_setininitial_step_isdefault=-1;
  adms_variable_valueto_setininitial_step(mynewvariable,adms_enumeration_new(adms_variable_enumeration_setininitial_step_no,adms_variable_fromstring_setininitial_step_impl,adms_variable_tostring_setininitial_step_impl));
  mynewvariable->_setininitial_step_isdefault=1;
  mynewvariable->_setinevaluate_isdefault=-1;
  adms_variable_valueto_setinevaluate(mynewvariable,adms_enumeration_new(adms_variable_enumeration_setinevaluate_no,adms_variable_fromstring_setinevaluate_impl,adms_variable_tostring_setinevaluate_impl));
  mynewvariable->_setinevaluate_isdefault=1;
  mynewvariable->_setinnoise_isdefault=-1;
  adms_variable_valueto_setinnoise(mynewvariable,adms_enumeration_new(adms_variable_enumeration_setinnoise_no,adms_variable_fromstring_setinnoise_impl,adms_variable_tostring_setinnoise_impl));
  mynewvariable->_setinnoise_isdefault=1;
  mynewvariable->_setinfinal_isdefault=-1;
  adms_variable_valueto_setinfinal(mynewvariable,adms_enumeration_new(adms_variable_enumeration_setinfinal_no,adms_variable_fromstring_setinfinal_impl,adms_variable_tostring_setinfinal_impl));
  mynewvariable->_setinfinal_isdefault=1;
  mynewvariable->_setingetprev_isdefault=-1;
  adms_variable_valueto_setingetprev(mynewvariable,adms_enumeration_new(adms_variable_enumeration_setingetprev_no,adms_variable_fromstring_setingetprev_impl,adms_variable_tostring_setingetprev_impl));
  mynewvariable->_setingetprev_isdefault=1;
  mynewvariable->_TemperatureDependent_isdefault=-1;
  adms_variable_valueto_TemperatureDependent(mynewvariable,adms_enumeration_new(adms_variable_enumeration_TemperatureDependent_no,adms_variable_fromstring_TemperatureDependent_impl,adms_variable_tostring_TemperatureDependent_impl));
  mynewvariable->_TemperatureDependent_isdefault=1;
  mynewvariable->_OPdependent_isdefault=-1;
  adms_variable_valueto_OPdependent(mynewvariable,adms_enumeration_new(adms_variable_enumeration_OPdependent_no,adms_variable_fromstring_OPdependent_impl,adms_variable_tostring_OPdependent_impl));
  mynewvariable->_OPdependent_isdefault=1;
  mynewvariable->_insource_isdefault=-1;
  adms_variable_valueto_insource(mynewvariable,adms_enumeration_new(adms_variable_enumeration_insource_no,adms_variable_fromstring_insource_impl,adms_variable_tostring_insource_impl));
  mynewvariable->_insource_isdefault=1;
  mynewvariable->_vcount_isdefault=-1;
  adms_variable_valueto_vcount(mynewvariable,adms_integer_new(0));
  mynewvariable->_vcount_isdefault=1;
  mynewvariable->_vlast_isdefault=-1;
  mynewvariable->_alias_isdefault=-1;
  mynewvariable->_range_isdefault=-1;
  mynewvariable->_attribute_isdefault=-1;
  mynewvariable->_assignment_isdefault=-1;
  mynewvariable->_probe_isdefault=-1;
  mynewvariable->_ddxprobe_isdefault=-1;
  mynewvariable->_variable_isdefault=-1;
  return mynewvariable;
}
p_adms adms_variable_new_impl (p_adms arguments[])
{
  p_variable mynewvariable;
  p_module mymodule=(p_module)arguments[0];
  p_quark myname=adms_quark_new((char*)arguments[1]);
  p_adms myblock=(p_adms)arguments[2];
  mynewvariable=adms_variable_new(mymodule,myname,myblock);
  return adms_adms(mynewvariable);
}
/*$2*/
char*adms_variable_uid (p_variable mynewvariable)
{
  char*myuid=NULL;
  char*myuid0=adms_quark_uid(mynewvariable->_name);
  adms_strconcat(&myuid,myuid0);
  return myuid;
}

inline void
adms_variable_valueto_module (p_variable myvariable,p_module _module)
{
  myvariable->_module=_module;
  myvariable->_module_isdefault=0;
}

inline void
adms_variable_valueto_name (p_variable myvariable,p_quark _name)
{
  if(myvariable->_name_isdefault!=-1)
    adms_quark_free(myvariable->_name);
  myvariable->_name=_name;
  myvariable->_name_isdefault=0;
}

inline void
adms_variable_valueto_block (p_variable myvariable,p_adms _block)
{
  myvariable->_block=_block;
  myvariable->_block_isdefault=0;
}

inline void
adms_variable_valueto_parametertype (p_variable myvariable,p_enumeration _parametertype)
{
  myvariable->_parametertype=_parametertype;
  myvariable->_parametertype_isdefault=0;
}

inline void
adms_variable_valueto_type (p_variable myvariable,p_enumeration _type)
{
  myvariable->_type=_type;
  myvariable->_type_isdefault=0;
}

inline void
adms_variable_valueto_sizetype (p_variable myvariable,p_enumeration _sizetype)
{
  myvariable->_sizetype=_sizetype;
  myvariable->_sizetype_isdefault=0;
}

inline void
adms_variable_valueto_maxsize (p_variable myvariable,int _maxsize)
{
  myvariable->_maxsize=_maxsize;
  myvariable->_maxsize_isdefault=0;
}

inline void
adms_variable_valueto_minsize (p_variable myvariable,int _minsize)
{
  myvariable->_minsize=_minsize;
  myvariable->_minsize_isdefault=0;
}

inline void
adms_variable_valueto_input (p_variable myvariable,p_enumeration _input)
{
  myvariable->_input=_input;
  myvariable->_input_isdefault=0;
}

inline void
adms_variable_valueto_output (p_variable myvariable,p_enumeration _output)
{
  myvariable->_output=_output;
  myvariable->_output_isdefault=0;
}

inline void
adms_variable_valueto_scope (p_variable myvariable,p_enumeration _scope)
{
  myvariable->_scope=_scope;
  myvariable->_scope_isdefault=0;
}

inline void
adms_variable_valueto_default (p_variable myvariable,p_expression _default)
{
  myvariable->_default=_default;
  myvariable->_default_isdefault=0;
}

inline void
adms_variable_valueto_derivate (p_variable myvariable,p_enumeration _derivate)
{
  myvariable->_derivate=_derivate;
  myvariable->_derivate_isdefault=0;
}

inline void
adms_variable_valueto_isstate (p_variable myvariable,p_enumeration _isstate)
{
  myvariable->_isstate=_isstate;
  myvariable->_isstate_isdefault=0;
}

inline void
adms_variable_valueto_usedinmodel (p_variable myvariable,p_enumeration _usedinmodel)
{
  myvariable->_usedinmodel=_usedinmodel;
  myvariable->_usedinmodel_isdefault=0;
}

inline void
adms_variable_valueto_usedininstance (p_variable myvariable,p_enumeration _usedininstance)
{
  myvariable->_usedininstance=_usedininstance;
  myvariable->_usedininstance_isdefault=0;
}

inline void
adms_variable_valueto_usedininitial_step (p_variable myvariable,p_enumeration _usedininitial_step)
{
  myvariable->_usedininitial_step=_usedininitial_step;
  myvariable->_usedininitial_step_isdefault=0;
}

inline void
adms_variable_valueto_usedinevaluate (p_variable myvariable,p_enumeration _usedinevaluate)
{
  myvariable->_usedinevaluate=_usedinevaluate;
  myvariable->_usedinevaluate_isdefault=0;
}

inline void
adms_variable_valueto_usedinnoise (p_variable myvariable,p_enumeration _usedinnoise)
{
  myvariable->_usedinnoise=_usedinnoise;
  myvariable->_usedinnoise_isdefault=0;
}

inline void
adms_variable_valueto_usedinfinal (p_variable myvariable,p_enumeration _usedinfinal)
{
  myvariable->_usedinfinal=_usedinfinal;
  myvariable->_usedinfinal_isdefault=0;
}

inline void
adms_variable_valueto_setinmodel (p_variable myvariable,p_enumeration _setinmodel)
{
  myvariable->_setinmodel=_setinmodel;
  myvariable->_setinmodel_isdefault=0;
}

inline void
adms_variable_valueto_setininstance (p_variable myvariable,p_enumeration _setininstance)
{
  myvariable->_setininstance=_setininstance;
  myvariable->_setininstance_isdefault=0;
}

inline void
adms_variable_valueto_setininitial_step (p_variable myvariable,p_enumeration _setininitial_step)
{
  myvariable->_setininitial_step=_setininitial_step;
  myvariable->_setininitial_step_isdefault=0;
}

inline void
adms_variable_valueto_setinevaluate (p_variable myvariable,p_enumeration _setinevaluate)
{
  myvariable->_setinevaluate=_setinevaluate;
  myvariable->_setinevaluate_isdefault=0;
}

inline void
adms_variable_valueto_setinnoise (p_variable myvariable,p_enumeration _setinnoise)
{
  myvariable->_setinnoise=_setinnoise;
  myvariable->_setinnoise_isdefault=0;
}

inline void
adms_variable_valueto_setinfinal (p_variable myvariable,p_enumeration _setinfinal)
{
  myvariable->_setinfinal=_setinfinal;
  myvariable->_setinfinal_isdefault=0;
}

inline void
adms_variable_valueto_setingetprev (p_variable myvariable,p_enumeration _setingetprev)
{
  myvariable->_setingetprev=_setingetprev;
  myvariable->_setingetprev_isdefault=0;
}

inline void
adms_variable_valueto_TemperatureDependent (p_variable myvariable,p_enumeration _TemperatureDependent)
{
  myvariable->_TemperatureDependent=_TemperatureDependent;
  myvariable->_TemperatureDependent_isdefault=0;
}

inline void
adms_variable_valueto_OPdependent (p_variable myvariable,p_enumeration _OPdependent)
{
  myvariable->_OPdependent=_OPdependent;
  myvariable->_OPdependent_isdefault=0;
}

inline void
adms_variable_valueto_insource (p_variable myvariable,p_enumeration _insource)
{
  myvariable->_insource=_insource;
  myvariable->_insource_isdefault=0;
}

inline void
adms_variable_valueto_vcount (p_variable myvariable,p_integer _vcount)
{
  myvariable->_vcount=_vcount;
  myvariable->_vcount_isdefault=0;
}

inline void
adms_variable_valueto_vlast (p_variable myvariable,p_assignment _vlast)
{
  myvariable->_vlast=_vlast;
  myvariable->_vlast_isdefault=0;
}

inline void
adms_variable_valueto_alias (p_variable myvariable,p_slist _alias)
{
  myvariable->_alias=_alias;
  myvariable->_alias_isdefault=0;
}
p_quark
adms_variable_list_alias_lookup_by_id (p_variable mymyvariable,const char* myvalue)
{
  p_slist list=adms_variable_valueof_alias(mymyvariable);
  while(list) {
    p_quark refquark=adms_quark(list->data);
    if(!strcmp(adms_quark_valueof_value(refquark),myvalue))
      return refquark;
    list=list->next;
  }
  return NULL;
}
p_quark
adms_variable_list_alias_prepend_by_id (p_variable mymyvariable,const char* myvalue)
{
  p_quark refalias=adms_quark_new(myvalue);
  adms_slist_push(&adms_variable_valueof_alias(mymyvariable),adms_adms(refalias));
  return refalias;
}
p_quark
adms_variable_list_alias_prepend_by_id_once_or_abort (p_variable mymyvariable,const char* myvalue)
{
  p_slist list=adms_variable_valueof_alias(mymyvariable);
  p_quark refalias=adms_quark_new(myvalue);
  while(list)
  {
    if(!adms_quark_cmp(adms_quark(list->data),refalias))
    {
      adms_message_fatal(("variable=[%s] alias=[%s] already defined\n",
        adms_variable_uid(mymyvariable),adms_quark_uid(refalias)))
      adms_quark_free (refalias);
    }
    list=list->next;
  }
  adms_slist_push(&adms_variable_valueof_alias(mymyvariable),adms_adms(refalias));
  return refalias;
}
void
adms_variable_list_alias_prepend_once_or_abort (p_variable mymyvariable,p_quark myalias)
{
  p_slist list=adms_variable_valueof_alias(mymyvariable);
  while(list)
  {
    if(!adms_quark_cmp(adms_quark(list->data),myalias))
    {
      adms_message_fatal(("variable=[%s] alias=[%s] already defined\n",
        adms_variable_uid(mymyvariable),adms_quark_uid(myalias)))
      return;
    }
    list=list->next;
  }
  adms_slist_push(&adms_variable_valueof_alias(mymyvariable),adms_adms(myalias));
}

inline void
adms_variable_valueto_range (p_variable myvariable,p_slist _range)
{
  myvariable->_range=_range;
  myvariable->_range_isdefault=0;
}
p_range
adms_variable_list_range_lookup_by_id (p_variable mymyvariable,p_module mymodule,p_expression myinfexpr,p_expression mysupexpr)
{
  p_slist list=adms_variable_valueof_range(mymyvariable);
  while(list) {
    p_range refrange=adms_range(list->data);
    if((adms_range_valueof_module(refrange)==mymodule)&&
       (adms_range_valueof_infexpr(refrange)==myinfexpr)&&
       (adms_range_valueof_supexpr(refrange)==mysupexpr))
      return refrange;
    list=list->next;
  }
  return NULL;
}
p_range
adms_variable_list_range_prepend_by_id (p_variable mymyvariable,p_module mymodule,p_expression myinfexpr,p_expression mysupexpr)
{
  p_range refrange=adms_range_new(mymodule,myinfexpr,mysupexpr);
  adms_slist_push(&adms_variable_valueof_range(mymyvariable),adms_adms(refrange));
  return refrange;
}
p_range
adms_variable_list_range_prepend_by_id_once_or_abort (p_variable mymyvariable,p_module mymodule,p_expression myinfexpr,p_expression mysupexpr)
{
  p_slist list=adms_variable_valueof_range(mymyvariable);
  p_range refrange=adms_range_new(mymodule,myinfexpr,mysupexpr);
  while(list)
  {
    if(!adms_range_cmp(adms_range(list->data),refrange))
    {
      adms_message_fatal(("variable=[%s] range=[%s] already defined\n",
        adms_variable_uid(mymyvariable),adms_range_uid(refrange)))
      adms_range_free (refrange);
    }
    list=list->next;
  }
  adms_slist_push(&adms_variable_valueof_range(mymyvariable),adms_adms(refrange));
  return refrange;
}
void
adms_variable_list_range_prepend_once_or_abort (p_variable mymyvariable,p_range myrange)
{
  p_slist list=adms_variable_valueof_range(mymyvariable);
  while(list)
  {
    if(!adms_range_cmp(adms_range(list->data),myrange))
    {
      adms_message_fatal(("variable=[%s] range=[%s] already defined\n",
        adms_variable_uid(mymyvariable),adms_range_uid(myrange)))
      return;
    }
    list=list->next;
  }
  adms_slist_push(&adms_variable_valueof_range(mymyvariable),adms_adms(myrange));
}

inline void
adms_variable_valueto_attribute (p_variable myvariable,p_slist _attribute)
{
  myvariable->_attribute=_attribute;
  myvariable->_attribute_isdefault=0;
}
p_attribute
adms_variable_list_attribute_lookup_by_id (p_variable mymyvariable,p_quark myname)
{
  p_slist list=adms_variable_valueof_attribute(mymyvariable);
  while(list) {
    p_attribute refattribute=adms_attribute(list->data);
    if(!strcmp(adms_attribute_valueof_name(refattribute)->_value,myname->_value))
      return refattribute;
    list=list->next;
  }
  return NULL;
}
p_attribute
adms_variable_list_attribute_prepend_by_id (p_variable mymyvariable,p_quark myname)
{
  p_attribute refattribute=adms_attribute_new(myname);
  adms_slist_push(&adms_variable_valueof_attribute(mymyvariable),adms_adms(refattribute));
  return refattribute;
}
p_attribute
adms_variable_list_attribute_prepend_by_id_once_or_ignore (p_variable mymyvariable,p_quark myname)
{
  p_attribute refattribute=adms_attribute_new(myname);
  adms_slist_push(&adms_variable_valueof_attribute(mymyvariable),adms_adms(refattribute));
  return refattribute;
}
void
adms_variable_list_attribute_prepend (p_variable mymyvariable,p_attribute myattribute)
{
  adms_slist_push(&adms_variable_valueof_attribute(mymyvariable),adms_adms(myattribute));
}

inline void
adms_variable_valueto_assignment (p_variable myvariable,p_slist _assignment)
{
  myvariable->_assignment=_assignment;
  myvariable->_assignment_isdefault=0;
}
p_assignment
adms_variable_list_assignment_lookup_by_id (p_variable mymyvariable,p_module mymodule,p_variable mylhs,p_expression myrhs)
{
  p_slist list=adms_variable_valueof_assignment(mymyvariable);
  while(list) {
    p_assignment refassignment=adms_assignment(list->data);
    if((adms_assignment_valueof_module(refassignment)==mymodule)&&
       (adms_assignment_valueof_lhs(refassignment)==mylhs)&&
       (adms_assignment_valueof_rhs(refassignment)==myrhs))
      return refassignment;
    list=list->next;
  }
  return NULL;
}
p_assignment
adms_variable_list_assignment_prepend_by_id (p_variable mymyvariable,p_module mymodule,p_variable mylhs,p_expression myrhs)
{
  p_assignment refassignment=adms_assignment_new(mymodule,mylhs,myrhs);
  adms_slist_push(&adms_variable_valueof_assignment(mymyvariable),adms_adms(refassignment));
  return refassignment;
}
p_assignment
adms_variable_list_assignment_prepend_by_id_once_or_ignore (p_variable mymyvariable,p_module mymodule,p_variable mylhs,p_expression myrhs)
{
  p_slist list=adms_variable_valueof_assignment(mymyvariable);
  p_assignment refassignment=adms_assignment_new(mymodule,mylhs,myrhs);
  while(list)
  {
    if(!adms_assignment_cmp(adms_assignment(list->data),refassignment))
    {
      adms_assignment_free (refassignment);
      return adms_assignment(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_variable_valueof_assignment(mymyvariable),adms_adms(refassignment));
  return refassignment;
}
void
adms_variable_list_assignment_prepend_once_or_ignore (p_variable mymyvariable,p_assignment myassignment)
{
  p_slist list=adms_variable_valueof_assignment(mymyvariable);
  while(list)
  {
    if(!adms_assignment_cmp(adms_assignment(list->data),myassignment))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_variable_valueof_assignment(mymyvariable),adms_adms(myassignment));
}

inline void
adms_variable_valueto_probe (p_variable myvariable,p_slist _probe)
{
  myvariable->_probe=_probe;
  myvariable->_probe_isdefault=0;
}
p_probe
adms_variable_list_probe_lookup_by_id (p_variable mymyvariable,p_module mymodule,p_branch mybranch,p_nature mynature)
{
  p_slist list=adms_variable_valueof_probe(mymyvariable);
  while(list) {
    p_probe refprobe=adms_probe(list->data);
    if((adms_probe_valueof_module(refprobe)==mymodule)&&
       (adms_probe_valueof_branch(refprobe)==mybranch)&&
       (adms_probe_valueof_nature(refprobe)==mynature))
      return refprobe;
    list=list->next;
  }
  return NULL;
}
p_probe
adms_variable_list_probe_prepend_by_id (p_variable mymyvariable,p_module mymodule,p_branch mybranch,p_nature mynature)
{
  p_probe refprobe=adms_probe_new(mymodule,mybranch,mynature);
  adms_slist_push(&adms_variable_valueof_probe(mymyvariable),adms_adms(refprobe));
  return refprobe;
}
p_probe
adms_variable_list_probe_prepend_by_id_once_or_ignore (p_variable mymyvariable,p_module mymodule,p_branch mybranch,p_nature mynature)
{
  p_slist list=adms_variable_valueof_probe(mymyvariable);
  p_probe refprobe=adms_probe_new(mymodule,mybranch,mynature);
  while(list)
  {
    if(!adms_probe_cmp(adms_probe(list->data),refprobe))
    {
      adms_probe_free (refprobe);
      return adms_probe(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_variable_valueof_probe(mymyvariable),adms_adms(refprobe));
  return refprobe;
}
void
adms_variable_list_probe_prepend_once_or_ignore (p_variable mymyvariable,p_probe myprobe)
{
  p_slist list=adms_variable_valueof_probe(mymyvariable);
  while(list)
  {
    if(!adms_probe_cmp(adms_probe(list->data),myprobe))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_variable_valueof_probe(mymyvariable),adms_adms(myprobe));
}

inline void
adms_variable_valueto_ddxprobe (p_variable myvariable,p_slist _ddxprobe)
{
  myvariable->_ddxprobe=_ddxprobe;
  myvariable->_ddxprobe_isdefault=0;
}
p_probe
adms_variable_list_ddxprobe_lookup_by_id (p_variable mymyvariable,p_module mymodule,p_branch mybranch,p_nature mynature)
{
  p_slist list=adms_variable_valueof_ddxprobe(mymyvariable);
  while(list) {
    p_probe refprobe=adms_probe(list->data);
    if((adms_probe_valueof_module(refprobe)==mymodule)&&
       (adms_probe_valueof_branch(refprobe)==mybranch)&&
       (adms_probe_valueof_nature(refprobe)==mynature))
      return refprobe;
    list=list->next;
  }
  return NULL;
}
p_probe
adms_variable_list_ddxprobe_prepend_by_id (p_variable mymyvariable,p_module mymodule,p_branch mybranch,p_nature mynature)
{
  p_probe refddxprobe=adms_probe_new(mymodule,mybranch,mynature);
  adms_slist_push(&adms_variable_valueof_ddxprobe(mymyvariable),adms_adms(refddxprobe));
  return refddxprobe;
}
p_probe
adms_variable_list_ddxprobe_prepend_by_id_once_or_ignore (p_variable mymyvariable,p_module mymodule,p_branch mybranch,p_nature mynature)
{
  p_slist list=adms_variable_valueof_ddxprobe(mymyvariable);
  p_probe refddxprobe=adms_probe_new(mymodule,mybranch,mynature);
  while(list)
  {
    if(!adms_probe_cmp(adms_probe(list->data),refddxprobe))
    {
      adms_probe_free (refddxprobe);
      return adms_probe(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_variable_valueof_ddxprobe(mymyvariable),adms_adms(refddxprobe));
  return refddxprobe;
}
void
adms_variable_list_ddxprobe_prepend_once_or_ignore (p_variable mymyvariable,p_probe myddxprobe)
{
  p_slist list=adms_variable_valueof_ddxprobe(mymyvariable);
  while(list)
  {
    if(!adms_probe_cmp(adms_probe(list->data),myddxprobe))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_variable_valueof_ddxprobe(mymyvariable),adms_adms(myddxprobe));
}

inline void
adms_variable_valueto_variable (p_variable myvariable,p_slist _variable)
{
  myvariable->_variable=_variable;
  myvariable->_variable_isdefault=0;
}
p_variable
adms_variable_list_variable_lookup_by_id (p_variable mymyvariable,p_module mymodule,p_quark myname,p_adms myblock)
{
  p_slist list=adms_variable_valueof_variable(mymyvariable);
  while(list) {
    p_variable refvariable=adms_variable(list->data);
    if((adms_variable_valueof_module(refvariable)==mymodule)&&
       !strcmp(adms_variable_valueof_name(refvariable)->_value,myname->_value)&&
       (adms_variable_valueof_block(refvariable)==myblock))
      return refvariable;
    list=list->next;
  }
  return NULL;
}
p_variable
adms_variable_list_variable_prepend_by_id (p_variable mymyvariable,p_module mymodule,p_quark myname,p_adms myblock)
{
  p_variable refvariable=adms_variable_new(mymodule,myname,myblock);
  adms_slist_push(&adms_variable_valueof_variable(mymyvariable),adms_adms(refvariable));
  return refvariable;
}
p_variable
adms_variable_list_variable_prepend_by_id_once_or_ignore (p_variable mymyvariable,p_module mymodule,p_quark myname,p_adms myblock)
{
  p_slist list=adms_variable_valueof_variable(mymyvariable);
  p_variable refvariable=adms_variable_new(mymodule,myname,myblock);
  while(list)
  {
    if(!adms_variable_cmp(adms_variable(list->data),refvariable))
    {
      adms_variable_free (refvariable);
      return adms_variable(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_variable_valueof_variable(mymyvariable),adms_adms(refvariable));
  return refvariable;
}
void
adms_variable_list_variable_prepend_once_or_ignore (p_variable mymyvariable,p_variable myvariable)
{
  p_slist list=adms_variable_valueof_variable(mymyvariable);
  while(list)
  {
    if(!adms_variable_cmp(adms_variable(list->data),myvariable))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_variable_valueof_variable(mymyvariable),adms_adms(myvariable));
}
e_variable_parametertype
adms_variable_fromstring_parametertype_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"analogfunction"))
    return adms_variable_enumeration_parametertype_analogfunction;
  if(!strcmp(token,"instance"))
    return adms_variable_enumeration_parametertype_instance;
  if(!strcmp(token,"model"))
    return adms_variable_enumeration_parametertype_model;
  adms_message_fatal_continue(("select='variable/parametertype': possible values:\n"))
  adms_message_fatal_continue(("analogfunction|instance|model\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_parametertype_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_parametertype e=myenumeration->_value;
  if(e==adms_variable_enumeration_parametertype_analogfunction)
    return "analogfunction";
  if(e==adms_variable_enumeration_parametertype_instance)
    return "instance";
  if(e==adms_variable_enumeration_parametertype_model)
    return "model";
  adms_message_fatal_continue(("select='variable/parametertype': possible values:\n"))
  adms_message_fatal_continue(("analogfunction|instance|model\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_type
adms_variable_fromstring_type_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"integer"))
    return adms_variable_enumeration_type_integer;
  if(!strcmp(token,"real"))
    return adms_variable_enumeration_type_real;
  if(!strcmp(token,"string"))
    return adms_variable_enumeration_type_string;
  adms_message_fatal_continue(("select='variable/type': possible values:\n"))
  adms_message_fatal_continue(("integer|real|string\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_type_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_type e=myenumeration->_value;
  if(e==adms_variable_enumeration_type_integer)
    return "integer";
  if(e==adms_variable_enumeration_type_real)
    return "real";
  if(e==adms_variable_enumeration_type_string)
    return "string";
  adms_message_fatal_continue(("select='variable/type': possible values:\n"))
  adms_message_fatal_continue(("integer|real|string\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_sizetype
adms_variable_fromstring_sizetype_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"array"))
    return adms_variable_enumeration_sizetype_array;
  if(!strcmp(token,"scalar"))
    return adms_variable_enumeration_sizetype_scalar;
  adms_message_fatal_continue(("select='variable/sizetype': possible values:\n"))
  adms_message_fatal_continue(("array|scalar\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_sizetype_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_sizetype e=myenumeration->_value;
  if(e==adms_variable_enumeration_sizetype_array)
    return "array";
  if(e==adms_variable_enumeration_sizetype_scalar)
    return "scalar";
  adms_message_fatal_continue(("select='variable/sizetype': possible values:\n"))
  adms_message_fatal_continue(("array|scalar\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_input
adms_variable_fromstring_input_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_input_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_input_yes;
  adms_message_fatal_continue(("select='variable/input': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_input_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_input e=myenumeration->_value;
  if(e==adms_variable_enumeration_input_no)
    return "no";
  if(e==adms_variable_enumeration_input_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/input': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_output
adms_variable_fromstring_output_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_output_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_output_yes;
  adms_message_fatal_continue(("select='variable/output': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_output_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_output e=myenumeration->_value;
  if(e==adms_variable_enumeration_output_no)
    return "no";
  if(e==adms_variable_enumeration_output_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/output': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_scope
adms_variable_fromstring_scope_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"global_final"))
    return adms_variable_enumeration_scope_global_final;
  if(!strcmp(token,"global_instance"))
    return adms_variable_enumeration_scope_global_instance;
  if(!strcmp(token,"global_model"))
    return adms_variable_enumeration_scope_global_model;
  if(!strcmp(token,"global_past"))
    return adms_variable_enumeration_scope_global_past;
  if(!strcmp(token,"local"))
    return adms_variable_enumeration_scope_local;
  adms_message_fatal_continue(("select='variable/scope': possible values:\n"))
  adms_message_fatal_continue(("global_final|global_instance|global_model|global_past|local\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_scope_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_scope e=myenumeration->_value;
  if(e==adms_variable_enumeration_scope_global_final)
    return "global_final";
  if(e==adms_variable_enumeration_scope_global_instance)
    return "global_instance";
  if(e==adms_variable_enumeration_scope_global_model)
    return "global_model";
  if(e==adms_variable_enumeration_scope_global_past)
    return "global_past";
  if(e==adms_variable_enumeration_scope_local)
    return "local";
  adms_message_fatal_continue(("select='variable/scope': possible values:\n"))
  adms_message_fatal_continue(("global_final|global_instance|global_model|global_past|local\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_derivate
adms_variable_fromstring_derivate_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_derivate_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_derivate_yes;
  adms_message_fatal_continue(("select='variable/derivate': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_derivate_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_derivate e=myenumeration->_value;
  if(e==adms_variable_enumeration_derivate_no)
    return "no";
  if(e==adms_variable_enumeration_derivate_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/derivate': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_isstate
adms_variable_fromstring_isstate_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_isstate_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_isstate_yes;
  adms_message_fatal_continue(("select='variable/isstate': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_isstate_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_isstate e=myenumeration->_value;
  if(e==adms_variable_enumeration_isstate_no)
    return "no";
  if(e==adms_variable_enumeration_isstate_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/isstate': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_usedinmodel
adms_variable_fromstring_usedinmodel_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_usedinmodel_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_usedinmodel_yes;
  adms_message_fatal_continue(("select='variable/usedinmodel': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_usedinmodel_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_usedinmodel e=myenumeration->_value;
  if(e==adms_variable_enumeration_usedinmodel_no)
    return "no";
  if(e==adms_variable_enumeration_usedinmodel_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/usedinmodel': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_usedininstance
adms_variable_fromstring_usedininstance_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_usedininstance_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_usedininstance_yes;
  adms_message_fatal_continue(("select='variable/usedininstance': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_usedininstance_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_usedininstance e=myenumeration->_value;
  if(e==adms_variable_enumeration_usedininstance_no)
    return "no";
  if(e==adms_variable_enumeration_usedininstance_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/usedininstance': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_usedininitial_step
adms_variable_fromstring_usedininitial_step_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_usedininitial_step_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_usedininitial_step_yes;
  adms_message_fatal_continue(("select='variable/usedininitial_step': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_usedininitial_step_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_usedininitial_step e=myenumeration->_value;
  if(e==adms_variable_enumeration_usedininitial_step_no)
    return "no";
  if(e==adms_variable_enumeration_usedininitial_step_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/usedininitial_step': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_usedinevaluate
adms_variable_fromstring_usedinevaluate_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_usedinevaluate_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_usedinevaluate_yes;
  adms_message_fatal_continue(("select='variable/usedinevaluate': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_usedinevaluate_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_usedinevaluate e=myenumeration->_value;
  if(e==adms_variable_enumeration_usedinevaluate_no)
    return "no";
  if(e==adms_variable_enumeration_usedinevaluate_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/usedinevaluate': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_usedinnoise
adms_variable_fromstring_usedinnoise_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_usedinnoise_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_usedinnoise_yes;
  adms_message_fatal_continue(("select='variable/usedinnoise': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_usedinnoise_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_usedinnoise e=myenumeration->_value;
  if(e==adms_variable_enumeration_usedinnoise_no)
    return "no";
  if(e==adms_variable_enumeration_usedinnoise_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/usedinnoise': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_usedinfinal
adms_variable_fromstring_usedinfinal_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_usedinfinal_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_usedinfinal_yes;
  adms_message_fatal_continue(("select='variable/usedinfinal': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_usedinfinal_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_usedinfinal e=myenumeration->_value;
  if(e==adms_variable_enumeration_usedinfinal_no)
    return "no";
  if(e==adms_variable_enumeration_usedinfinal_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/usedinfinal': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_setinmodel
adms_variable_fromstring_setinmodel_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_setinmodel_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_setinmodel_yes;
  adms_message_fatal_continue(("select='variable/setinmodel': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_setinmodel_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_setinmodel e=myenumeration->_value;
  if(e==adms_variable_enumeration_setinmodel_no)
    return "no";
  if(e==adms_variable_enumeration_setinmodel_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/setinmodel': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_setininstance
adms_variable_fromstring_setininstance_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_setininstance_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_setininstance_yes;
  adms_message_fatal_continue(("select='variable/setininstance': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_setininstance_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_setininstance e=myenumeration->_value;
  if(e==adms_variable_enumeration_setininstance_no)
    return "no";
  if(e==adms_variable_enumeration_setininstance_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/setininstance': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_setininitial_step
adms_variable_fromstring_setininitial_step_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_setininitial_step_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_setininitial_step_yes;
  adms_message_fatal_continue(("select='variable/setininitial_step': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_setininitial_step_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_setininitial_step e=myenumeration->_value;
  if(e==adms_variable_enumeration_setininitial_step_no)
    return "no";
  if(e==adms_variable_enumeration_setininitial_step_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/setininitial_step': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_setinevaluate
adms_variable_fromstring_setinevaluate_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_setinevaluate_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_setinevaluate_yes;
  adms_message_fatal_continue(("select='variable/setinevaluate': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_setinevaluate_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_setinevaluate e=myenumeration->_value;
  if(e==adms_variable_enumeration_setinevaluate_no)
    return "no";
  if(e==adms_variable_enumeration_setinevaluate_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/setinevaluate': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_setinnoise
adms_variable_fromstring_setinnoise_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_setinnoise_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_setinnoise_yes;
  adms_message_fatal_continue(("select='variable/setinnoise': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_setinnoise_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_setinnoise e=myenumeration->_value;
  if(e==adms_variable_enumeration_setinnoise_no)
    return "no";
  if(e==adms_variable_enumeration_setinnoise_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/setinnoise': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_setinfinal
adms_variable_fromstring_setinfinal_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_setinfinal_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_setinfinal_yes;
  adms_message_fatal_continue(("select='variable/setinfinal': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_setinfinal_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_setinfinal e=myenumeration->_value;
  if(e==adms_variable_enumeration_setinfinal_no)
    return "no";
  if(e==adms_variable_enumeration_setinfinal_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/setinfinal': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_setingetprev
adms_variable_fromstring_setingetprev_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_setingetprev_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_setingetprev_yes;
  adms_message_fatal_continue(("select='variable/setingetprev': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_setingetprev_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_setingetprev e=myenumeration->_value;
  if(e==adms_variable_enumeration_setingetprev_no)
    return "no";
  if(e==adms_variable_enumeration_setingetprev_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/setingetprev': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_TemperatureDependent
adms_variable_fromstring_TemperatureDependent_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_TemperatureDependent_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_TemperatureDependent_yes;
  adms_message_fatal_continue(("select='variable/TemperatureDependent': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_TemperatureDependent_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_TemperatureDependent e=myenumeration->_value;
  if(e==adms_variable_enumeration_TemperatureDependent_no)
    return "no";
  if(e==adms_variable_enumeration_TemperatureDependent_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/TemperatureDependent': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_OPdependent
adms_variable_fromstring_OPdependent_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_OPdependent_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_OPdependent_yes;
  adms_message_fatal_continue(("select='variable/OPdependent': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_OPdependent_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_OPdependent e=myenumeration->_value;
  if(e==adms_variable_enumeration_OPdependent_no)
    return "no";
  if(e==adms_variable_enumeration_OPdependent_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/OPdependent': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_variable_insource
adms_variable_fromstring_insource_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_variable_enumeration_insource_no;
  if(!strcmp(token,"yes"))
    return adms_variable_enumeration_insource_yes;
  adms_message_fatal_continue(("select='variable/insource': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_variable_tostring_insource_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_variable_insource e=myenumeration->_value;
  if(e==adms_variable_enumeration_insource_no)
    return "no";
  if(e==adms_variable_enumeration_insource_yes)
    return "yes";
  adms_message_fatal_continue(("select='variable/insource': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}