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

inline void adms_admsmain_free(p_admsmain myadmsmain)
{
  if(!myadmsmain)
    return;
  adms_slist_free(myadmsmain->_module);
  adms_slist_free(myadmsmain->_discipline);
  adms_slist_free(myadmsmain->_nature);
  adms_slist_free(myadmsmain->_variable);
  {p_slist l=myadmsmain->_argv;for(;l;l=l->next) adms_quark_free(adms_quark(l->data));}
  adms_slist_free(myadmsmain->_argv);
  {p_slist l=myadmsmain->_admstfile;for(;l;l=l->next) adms_quark_free(adms_quark(l->data));}
  adms_slist_free(myadmsmain->_admstfile);
  adms_slist_free(myadmsmain->_admsttransform);
  adms_slist_free(myadmsmain->_template);
  adms_slist_free(myadmsmain->_instanceofadmsttransform);
  adms_slist_free(myadmsmain->_instanceofadmsttransforminsideapplytemplate);
  adms_slist_free(myadmsmain->_valueof);
  adms_slist_free(myadmsmain->_alladmstnew);
  adms_slist_free(myadmsmain->_alladmstdestroy);
  adms_quark_free(myadmsmain->_name);
  adms_quark_free(myadmsmain->_filename);
  adms_simulator_free(myadmsmain->_simulator);
  adms_enumeration_free(myadmsmain->_info);
  adms_enumeration_free(myadmsmain->_usage);
  adms_enumeration_free(myadmsmain->_verbose);
  adms_enumeration_free(myadmsmain->_hint);
  adms_enumeration_free(myadmsmain->_warning);
  adms_enumeration_free(myadmsmain->_obsolete);
  adms_enumeration_free(myadmsmain->_debug);
  adms_enumeration_free(myadmsmain->_dbg_vla);
  adms_enumeration_free(myadmsmain->_dbg_xml);
  adms_enumeration_free(myadmsmain->_error);
  adms_enumeration_free(myadmsmain->_fatal);
  adms_enumeration_free(myadmsmain->_dbg_mem);
  free(myadmsmain);
}
int adms_admsmain_cmp (p_admsmain myadmsmain,p_admsmain refadmsmain)
{
  int status;
  status =
  (
    !!strcmp(adms_admsmain_valueof_name (myadmsmain)->_value,adms_admsmain_valueof_name (refadmsmain)->_value)
  );
  return status;
}
p_admsmain adms_admsmain_new(p_quark myname)
{
  p_admsmain mynewadmsmain=(p_admsmain) calloc(1,(size_t)sizeof(t_admsmain));
  mynewadmsmain->_adms._datatypename=adms_adms_enumeration_datatypename_admsmain;
  mynewadmsmain->_adms._seen=adms_adms_enumeration_seen_no;
  mynewadmsmain->_name_isdefault=-1;
  adms_admsmain_valueto_name (mynewadmsmain,myname);
  mynewadmsmain->_name_isdefault=1;
  mynewadmsmain->_argc_isdefault=-1;
  mynewadmsmain->_filename_isdefault=-1;
  mynewadmsmain->_curline_isdefault=-1;
  mynewadmsmain->_fpos_isdefault=-1;
  mynewadmsmain->_simulator_isdefault=-1;
  mynewadmsmain->_info_isdefault=-1;
  adms_admsmain_valueto_info(mynewadmsmain,adms_enumeration_new(adms_admsmain_enumeration_info_yes,adms_admsmain_fromstring_info_impl,adms_admsmain_tostring_info_impl));
  mynewadmsmain->_info_isdefault=1;
  mynewadmsmain->_usage_isdefault=-1;
  adms_admsmain_valueto_usage(mynewadmsmain,adms_enumeration_new(adms_admsmain_enumeration_usage_yes,adms_admsmain_fromstring_usage_impl,adms_admsmain_tostring_usage_impl));
  mynewadmsmain->_usage_isdefault=1;
  mynewadmsmain->_verbose_isdefault=-1;
  adms_admsmain_valueto_verbose(mynewadmsmain,adms_enumeration_new(adms_admsmain_enumeration_verbose_no,adms_admsmain_fromstring_verbose_impl,adms_admsmain_tostring_verbose_impl));
  mynewadmsmain->_verbose_isdefault=1;
  mynewadmsmain->_hint_isdefault=-1;
  adms_admsmain_valueto_hint(mynewadmsmain,adms_enumeration_new(adms_admsmain_enumeration_hint_no,adms_admsmain_fromstring_hint_impl,adms_admsmain_tostring_hint_impl));
  mynewadmsmain->_hint_isdefault=1;
  mynewadmsmain->_warning_isdefault=-1;
  adms_admsmain_valueto_warning(mynewadmsmain,adms_enumeration_new(adms_admsmain_enumeration_warning_yes,adms_admsmain_fromstring_warning_impl,adms_admsmain_tostring_warning_impl));
  mynewadmsmain->_warning_isdefault=1;
  mynewadmsmain->_obsolete_isdefault=-1;
  adms_admsmain_valueto_obsolete(mynewadmsmain,adms_enumeration_new(adms_admsmain_enumeration_obsolete_yes,adms_admsmain_fromstring_obsolete_impl,adms_admsmain_tostring_obsolete_impl));
  mynewadmsmain->_obsolete_isdefault=1;
  mynewadmsmain->_debug_isdefault=-1;
  adms_admsmain_valueto_debug(mynewadmsmain,adms_enumeration_new(adms_admsmain_enumeration_debug_no,adms_admsmain_fromstring_debug_impl,adms_admsmain_tostring_debug_impl));
  mynewadmsmain->_debug_isdefault=1;
  mynewadmsmain->_dbg_vla_isdefault=-1;
  adms_admsmain_valueto_dbg_vla(mynewadmsmain,adms_enumeration_new(adms_admsmain_enumeration_dbg_vla_no,adms_admsmain_fromstring_dbg_vla_impl,adms_admsmain_tostring_dbg_vla_impl));
  mynewadmsmain->_dbg_vla_isdefault=1;
  mynewadmsmain->_dbg_xml_isdefault=-1;
  adms_admsmain_valueto_dbg_xml(mynewadmsmain,adms_enumeration_new(adms_admsmain_enumeration_dbg_xml_no,adms_admsmain_fromstring_dbg_xml_impl,adms_admsmain_tostring_dbg_xml_impl));
  mynewadmsmain->_dbg_xml_isdefault=1;
  mynewadmsmain->_error_isdefault=-1;
  adms_admsmain_valueto_error(mynewadmsmain,adms_enumeration_new(adms_admsmain_enumeration_error_yes,adms_admsmain_fromstring_error_impl,adms_admsmain_tostring_error_impl));
  mynewadmsmain->_error_isdefault=1;
  mynewadmsmain->_fatal_isdefault=-1;
  adms_admsmain_valueto_fatal(mynewadmsmain,adms_enumeration_new(adms_admsmain_enumeration_fatal_yes,adms_admsmain_fromstring_fatal_impl,adms_admsmain_tostring_fatal_impl));
  mynewadmsmain->_fatal_isdefault=1;
  mynewadmsmain->_dbg_mem_isdefault=-1;
  adms_admsmain_valueto_dbg_mem(mynewadmsmain,adms_enumeration_new(adms_admsmain_enumeration_dbg_mem_no,adms_admsmain_fromstring_dbg_mem_impl,adms_admsmain_tostring_dbg_mem_impl));
  mynewadmsmain->_dbg_mem_isdefault=1;
  mynewadmsmain->_module_isdefault=-1;
  mynewadmsmain->_discipline_isdefault=-1;
  mynewadmsmain->_nature_isdefault=-1;
  mynewadmsmain->_variable_isdefault=-1;
  mynewadmsmain->_argv_isdefault=-1;
  mynewadmsmain->_admstfile_isdefault=-1;
  mynewadmsmain->_admsttransform_isdefault=-1;
  mynewadmsmain->_template_isdefault=-1;
  mynewadmsmain->_instanceofadmsttransform_isdefault=-1;
  mynewadmsmain->_instanceofadmsttransforminsideapplytemplate_isdefault=-1;
  mynewadmsmain->_valueof_isdefault=-1;
  mynewadmsmain->_alladmstnew_isdefault=-1;
  mynewadmsmain->_alladmstdestroy_isdefault=-1;
  return mynewadmsmain;
}
p_adms adms_admsmain_new_impl (p_adms arguments[])
{
  p_admsmain mynewadmsmain;
  p_quark myname=adms_quark_new((char*)arguments[0]);
  mynewadmsmain=adms_admsmain_new(myname);
  return adms_adms(mynewadmsmain);
}
/*$1*/
char*adms_admsmain_uid (p_admsmain mynewadmsmain)
{
  char*myuid=NULL;
  char*myuid0=adms_quark_uid(mynewadmsmain->_name);
  adms_strconcat(&myuid,myuid0);
  return myuid;
}

inline void
adms_admsmain_valueto_name (p_admsmain myadmsmain,p_quark _name)
{
  if(myadmsmain->_name_isdefault!=-1)
    adms_quark_free(myadmsmain->_name);
  myadmsmain->_name=_name;
  myadmsmain->_name_isdefault=0;
}

inline void
adms_admsmain_valueto_argc (p_admsmain myadmsmain,int _argc)
{
  myadmsmain->_argc=_argc;
  myadmsmain->_argc_isdefault=0;
}

inline void
adms_admsmain_valueto_filename (p_admsmain myadmsmain,p_quark _filename)
{
  if(myadmsmain->_filename_isdefault!=-1)
    adms_quark_free(myadmsmain->_filename);
  myadmsmain->_filename=_filename;
  myadmsmain->_filename_isdefault=0;
}

inline void
adms_admsmain_valueto_curline (p_admsmain myadmsmain,int _curline)
{
  myadmsmain->_curline=_curline;
  myadmsmain->_curline_isdefault=0;
}

inline void
adms_admsmain_valueto_fpos (p_admsmain myadmsmain,int _fpos)
{
  myadmsmain->_fpos=_fpos;
  myadmsmain->_fpos_isdefault=0;
}

inline void
adms_admsmain_valueto_simulator (p_admsmain myadmsmain,p_simulator _simulator)
{
  myadmsmain->_simulator=_simulator;
  myadmsmain->_simulator_isdefault=0;
}

inline void
adms_admsmain_valueto_info (p_admsmain myadmsmain,p_enumeration _info)
{
  myadmsmain->_info=_info;
  myadmsmain->_info_isdefault=0;
}

inline void
adms_admsmain_valueto_usage (p_admsmain myadmsmain,p_enumeration _usage)
{
  myadmsmain->_usage=_usage;
  myadmsmain->_usage_isdefault=0;
}

inline void
adms_admsmain_valueto_verbose (p_admsmain myadmsmain,p_enumeration _verbose)
{
  myadmsmain->_verbose=_verbose;
  myadmsmain->_verbose_isdefault=0;
}

inline void
adms_admsmain_valueto_hint (p_admsmain myadmsmain,p_enumeration _hint)
{
  myadmsmain->_hint=_hint;
  myadmsmain->_hint_isdefault=0;
}

inline void
adms_admsmain_valueto_warning (p_admsmain myadmsmain,p_enumeration _warning)
{
  myadmsmain->_warning=_warning;
  myadmsmain->_warning_isdefault=0;
}

inline void
adms_admsmain_valueto_obsolete (p_admsmain myadmsmain,p_enumeration _obsolete)
{
  myadmsmain->_obsolete=_obsolete;
  myadmsmain->_obsolete_isdefault=0;
}

inline void
adms_admsmain_valueto_debug (p_admsmain myadmsmain,p_enumeration _debug)
{
  myadmsmain->_debug=_debug;
  myadmsmain->_debug_isdefault=0;
}

inline void
adms_admsmain_valueto_dbg_vla (p_admsmain myadmsmain,p_enumeration _dbg_vla)
{
  myadmsmain->_dbg_vla=_dbg_vla;
  myadmsmain->_dbg_vla_isdefault=0;
}

inline void
adms_admsmain_valueto_dbg_xml (p_admsmain myadmsmain,p_enumeration _dbg_xml)
{
  myadmsmain->_dbg_xml=_dbg_xml;
  myadmsmain->_dbg_xml_isdefault=0;
}

inline void
adms_admsmain_valueto_error (p_admsmain myadmsmain,p_enumeration _error)
{
  myadmsmain->_error=_error;
  myadmsmain->_error_isdefault=0;
}

inline void
adms_admsmain_valueto_fatal (p_admsmain myadmsmain,p_enumeration _fatal)
{
  myadmsmain->_fatal=_fatal;
  myadmsmain->_fatal_isdefault=0;
}

inline void
adms_admsmain_valueto_dbg_mem (p_admsmain myadmsmain,p_enumeration _dbg_mem)
{
  myadmsmain->_dbg_mem=_dbg_mem;
  myadmsmain->_dbg_mem_isdefault=0;
}

inline void
adms_admsmain_valueto_module (p_admsmain myadmsmain,p_slist _module)
{
  myadmsmain->_module=_module;
  myadmsmain->_module_isdefault=0;
}
p_module
adms_admsmain_list_module_lookup_by_id (p_admsmain mymyadmsmain,p_quark myname)
{
  p_slist list=adms_admsmain_valueof_module(mymyadmsmain);
  while(list) {
    p_module refmodule=adms_module(list->data);
    if(!strcmp(adms_module_valueof_name(refmodule)->_value,myname->_value))
      return refmodule;
    list=list->next;
  }
  return NULL;
}
p_module
adms_admsmain_list_module_prepend_by_id (p_admsmain mymyadmsmain,p_quark myname)
{
  p_module refmodule=adms_module_new(myname);
  adms_slist_push(&adms_admsmain_valueof_module(mymyadmsmain),adms_adms(refmodule));
  return refmodule;
}
p_module
adms_admsmain_list_module_prepend_by_id_once_or_abort (p_admsmain mymyadmsmain,p_quark myname)
{
  p_slist list=adms_admsmain_valueof_module(mymyadmsmain);
  p_module refmodule=adms_module_new(myname);
  while(list)
  {
    if(!adms_module_cmp(adms_module(list->data),refmodule))
    {
      adms_message_fatal(("admsmain=[%s] module=[%s] already defined\n",
        adms_admsmain_uid(mymyadmsmain),adms_module_uid(refmodule)))
      adms_module_free (refmodule);
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_module(mymyadmsmain),adms_adms(refmodule));
  return refmodule;
}
void
adms_admsmain_list_module_prepend_once_or_abort (p_admsmain mymyadmsmain,p_module mymodule)
{
  p_slist list=adms_admsmain_valueof_module(mymyadmsmain);
  while(list)
  {
    if(!adms_module_cmp(adms_module(list->data),mymodule))
    {
      adms_message_fatal(("admsmain=[%s] module=[%s] already defined\n",
        adms_admsmain_uid(mymyadmsmain),adms_module_uid(mymodule)))
      return;
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_module(mymyadmsmain),adms_adms(mymodule));
}

inline void
adms_admsmain_valueto_discipline (p_admsmain myadmsmain,p_slist _discipline)
{
  myadmsmain->_discipline=_discipline;
  myadmsmain->_discipline_isdefault=0;
}
p_discipline
adms_admsmain_list_discipline_lookup_by_id (p_admsmain mymyadmsmain,p_quark myname)
{
  p_slist list=adms_admsmain_valueof_discipline(mymyadmsmain);
  while(list) {
    p_discipline refdiscipline=adms_discipline(list->data);
    if(!strcmp(adms_discipline_valueof_name(refdiscipline)->_value,myname->_value))
      return refdiscipline;
    list=list->next;
  }
  return NULL;
}
p_discipline
adms_admsmain_list_discipline_prepend_by_id (p_admsmain mymyadmsmain,p_quark myname)
{
  p_discipline refdiscipline=adms_discipline_new(myname);
  adms_slist_push(&adms_admsmain_valueof_discipline(mymyadmsmain),adms_adms(refdiscipline));
  return refdiscipline;
}
p_discipline
adms_admsmain_list_discipline_prepend_by_id_once_or_abort (p_admsmain mymyadmsmain,p_quark myname)
{
  p_slist list=adms_admsmain_valueof_discipline(mymyadmsmain);
  p_discipline refdiscipline=adms_discipline_new(myname);
  while(list)
  {
    if(!adms_discipline_cmp(adms_discipline(list->data),refdiscipline))
    {
      adms_message_fatal(("admsmain=[%s] discipline=[%s] already defined\n",
        adms_admsmain_uid(mymyadmsmain),adms_discipline_uid(refdiscipline)))
      adms_discipline_free (refdiscipline);
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_discipline(mymyadmsmain),adms_adms(refdiscipline));
  return refdiscipline;
}
void
adms_admsmain_list_discipline_prepend_once_or_abort (p_admsmain mymyadmsmain,p_discipline mydiscipline)
{
  p_slist list=adms_admsmain_valueof_discipline(mymyadmsmain);
  while(list)
  {
    if(!adms_discipline_cmp(adms_discipline(list->data),mydiscipline))
    {
      adms_message_fatal(("admsmain=[%s] discipline=[%s] already defined\n",
        adms_admsmain_uid(mymyadmsmain),adms_discipline_uid(mydiscipline)))
      return;
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_discipline(mymyadmsmain),adms_adms(mydiscipline));
}

inline void
adms_admsmain_valueto_nature (p_admsmain myadmsmain,p_slist _nature)
{
  myadmsmain->_nature=_nature;
  myadmsmain->_nature_isdefault=0;
}
p_nature
adms_admsmain_list_nature_lookup_by_id (p_admsmain mymyadmsmain,p_quark myaccess)
{
  p_slist list=adms_admsmain_valueof_nature(mymyadmsmain);
  while(list) {
    p_nature refnature=adms_nature(list->data);
    if(!strcmp(adms_nature_valueof_access(refnature)->_value,myaccess->_value))
      return refnature;
    list=list->next;
  }
  return NULL;
}
p_nature
adms_admsmain_list_nature_prepend_by_id (p_admsmain mymyadmsmain,p_quark myaccess)
{
  p_nature refnature=adms_nature_new(myaccess);
  adms_slist_push(&adms_admsmain_valueof_nature(mymyadmsmain),adms_adms(refnature));
  return refnature;
}
p_nature
adms_admsmain_list_nature_prepend_by_id_once_or_abort (p_admsmain mymyadmsmain,p_quark myaccess)
{
  p_slist list=adms_admsmain_valueof_nature(mymyadmsmain);
  p_nature refnature=adms_nature_new(myaccess);
  while(list)
  {
    if(!adms_nature_cmp(adms_nature(list->data),refnature))
    {
      adms_message_fatal(("admsmain=[%s] nature=[%s] already defined\n",
        adms_admsmain_uid(mymyadmsmain),adms_nature_uid(refnature)))
      adms_nature_free (refnature);
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_nature(mymyadmsmain),adms_adms(refnature));
  return refnature;
}
void
adms_admsmain_list_nature_prepend_once_or_abort (p_admsmain mymyadmsmain,p_nature mynature)
{
  p_slist list=adms_admsmain_valueof_nature(mymyadmsmain);
  while(list)
  {
    if(!adms_nature_cmp(adms_nature(list->data),mynature))
    {
      adms_message_fatal(("admsmain=[%s] nature=[%s] already defined\n",
        adms_admsmain_uid(mymyadmsmain),adms_nature_uid(mynature)))
      return;
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_nature(mymyadmsmain),adms_adms(mynature));
}

inline void
adms_admsmain_valueto_variable (p_admsmain myadmsmain,p_slist _variable)
{
  myadmsmain->_variable=_variable;
  myadmsmain->_variable_isdefault=0;
}
p_admstvariable
adms_admsmain_list_variable_lookup_by_id (p_admsmain mymyadmsmain,p_quark myname)
{
  p_slist list=adms_admsmain_valueof_variable(mymyadmsmain);
  while(list) {
    p_admstvariable refadmstvariable=adms_admstvariable(list->data);
    if(!strcmp(adms_admstvariable_valueof_name(refadmstvariable)->_value,myname->_value))
      return refadmstvariable;
    list=list->next;
  }
  return NULL;
}
p_admstvariable
adms_admsmain_list_variable_prepend_by_id (p_admsmain mymyadmsmain,p_quark myname)
{
  p_admstvariable refvariable=adms_admstvariable_new(myname);
  adms_slist_push(&adms_admsmain_valueof_variable(mymyadmsmain),adms_adms(refvariable));
  return refvariable;
}
p_admstvariable
adms_admsmain_list_variable_prepend_by_id_once_or_abort (p_admsmain mymyadmsmain,p_quark myname)
{
  p_slist list=adms_admsmain_valueof_variable(mymyadmsmain);
  p_admstvariable refvariable=adms_admstvariable_new(myname);
  while(list)
  {
    if(!adms_admstvariable_cmp(adms_admstvariable(list->data),refvariable))
    {
      adms_message_fatal(("admsmain=[%s] variable=[%s] already defined\n",
        adms_admsmain_uid(mymyadmsmain),adms_admstvariable_uid(refvariable)))
      adms_admstvariable_free (refvariable);
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_variable(mymyadmsmain),adms_adms(refvariable));
  return refvariable;
}
void
adms_admsmain_list_variable_prepend_once_or_abort (p_admsmain mymyadmsmain,p_admstvariable myvariable)
{
  p_slist list=adms_admsmain_valueof_variable(mymyadmsmain);
  while(list)
  {
    if(!adms_admstvariable_cmp(adms_admstvariable(list->data),myvariable))
    {
      adms_message_fatal(("admsmain=[%s] variable=[%s] already defined\n",
        adms_admsmain_uid(mymyadmsmain),adms_admstvariable_uid(myvariable)))
      return;
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_variable(mymyadmsmain),adms_adms(myvariable));
}

inline void
adms_admsmain_valueto_argv (p_admsmain myadmsmain,p_slist _argv)
{
  myadmsmain->_argv=_argv;
  myadmsmain->_argv_isdefault=0;
}
p_quark
adms_admsmain_list_argv_lookup_by_id (p_admsmain mymyadmsmain,const char* myvalue)
{
  p_slist list=adms_admsmain_valueof_argv(mymyadmsmain);
  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_admsmain_list_argv_prepend_by_id (p_admsmain mymyadmsmain,const char* myvalue)
{
  p_quark refargv=adms_quark_new(myvalue);
  adms_slist_push(&adms_admsmain_valueof_argv(mymyadmsmain),adms_adms(refargv));
  return refargv;
}
p_quark
adms_admsmain_list_argv_prepend_by_id_once_or_ignore (p_admsmain mymyadmsmain,const char* myvalue)
{
  p_slist list=adms_admsmain_valueof_argv(mymyadmsmain);
  p_quark refargv=adms_quark_new(myvalue);
  while(list)
  {
    if(!adms_quark_cmp(adms_quark(list->data),refargv))
    {
      adms_quark_free (refargv);
      return adms_quark(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_argv(mymyadmsmain),adms_adms(refargv));
  return refargv;
}
void
adms_admsmain_list_argv_prepend_once_or_ignore (p_admsmain mymyadmsmain,p_quark myargv)
{
  p_slist list=adms_admsmain_valueof_argv(mymyadmsmain);
  while(list)
  {
    if(!adms_quark_cmp(adms_quark(list->data),myargv))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_argv(mymyadmsmain),adms_adms(myargv));
}

inline void
adms_admsmain_valueto_admstfile (p_admsmain myadmsmain,p_slist _admstfile)
{
  myadmsmain->_admstfile=_admstfile;
  myadmsmain->_admstfile_isdefault=0;
}
p_quark
adms_admsmain_list_admstfile_lookup_by_id (p_admsmain mymyadmsmain,const char* myvalue)
{
  p_slist list=adms_admsmain_valueof_admstfile(mymyadmsmain);
  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_admsmain_list_admstfile_prepend_by_id (p_admsmain mymyadmsmain,const char* myvalue)
{
  p_quark refadmstfile=adms_quark_new(myvalue);
  adms_slist_push(&adms_admsmain_valueof_admstfile(mymyadmsmain),adms_adms(refadmstfile));
  return refadmstfile;
}
p_quark
adms_admsmain_list_admstfile_prepend_by_id_once_or_ignore (p_admsmain mymyadmsmain,const char* myvalue)
{
  p_slist list=adms_admsmain_valueof_admstfile(mymyadmsmain);
  p_quark refadmstfile=adms_quark_new(myvalue);
  while(list)
  {
    if(!adms_quark_cmp(adms_quark(list->data),refadmstfile))
    {
      adms_quark_free (refadmstfile);
      return adms_quark(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_admstfile(mymyadmsmain),adms_adms(refadmstfile));
  return refadmstfile;
}
void
adms_admsmain_list_admstfile_prepend_once_or_ignore (p_admsmain mymyadmsmain,p_quark myadmstfile)
{
  p_slist list=adms_admsmain_valueof_admstfile(mymyadmsmain);
  while(list)
  {
    if(!adms_quark_cmp(adms_quark(list->data),myadmstfile))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_admstfile(mymyadmsmain),adms_adms(myadmstfile));
}

inline void
adms_admsmain_valueto_admsttransform (p_admsmain myadmsmain,p_slist _admsttransform)
{
  myadmsmain->_admsttransform=_admsttransform;
  myadmsmain->_admsttransform_isdefault=0;
}
p_admsttransform
adms_admsmain_list_admsttransform_lookup_by_id (p_admsmain mymyadmsmain,p_quark myf,int myl,const char* myadmstname,p_admsttransform myparent)
{
  p_slist list=adms_admsmain_valueof_admsttransform(mymyadmsmain);
  while(list) {
    p_admsttransform refadmsttransform=adms_admsttransform(list->data);
    if(!strcmp(adms_admsttransform_valueof_f(refadmsttransform)->_value,myf->_value)&&
       (adms_admsttransform_valueof_l(refadmsttransform)==myl)&&
       !strcmp(adms_admsttransform_valueof_admstname(refadmsttransform),myadmstname)&&
       (adms_admsttransform_valueof_parent(refadmsttransform)==myparent))
      return refadmsttransform;
    list=list->next;
  }
  return NULL;
}
p_admsttransform
adms_admsmain_list_admsttransform_prepend_by_id (p_admsmain mymyadmsmain,p_quark myf,int myl,const char* myadmstname,p_admsttransform myparent)
{
  p_admsttransform refadmsttransform=adms_admsttransform_new(myf,myl,myadmstname,myparent);
  adms_slist_push(&adms_admsmain_valueof_admsttransform(mymyadmsmain),adms_adms(refadmsttransform));
  return refadmsttransform;
}
p_admsttransform
adms_admsmain_list_admsttransform_prepend_by_id_once_or_ignore (p_admsmain mymyadmsmain,p_quark myf,int myl,const char* myadmstname,p_admsttransform myparent)
{
  p_slist list=adms_admsmain_valueof_admsttransform(mymyadmsmain);
  p_admsttransform refadmsttransform=adms_admsttransform_new(myf,myl,myadmstname,myparent);
  while(list)
  {
    if(!adms_admsttransform_cmp(adms_admsttransform(list->data),refadmsttransform))
    {
      adms_admsttransform_free (refadmsttransform);
      return adms_admsttransform(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_admsttransform(mymyadmsmain),adms_adms(refadmsttransform));
  return refadmsttransform;
}
void
adms_admsmain_list_admsttransform_prepend_once_or_ignore (p_admsmain mymyadmsmain,p_admsttransform myadmsttransform)
{
  p_slist list=adms_admsmain_valueof_admsttransform(mymyadmsmain);
  while(list)
  {
    if(!adms_admsttransform_cmp(adms_admsttransform(list->data),myadmsttransform))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_admsttransform(mymyadmsmain),adms_adms(myadmsttransform));
}

inline void
adms_admsmain_valueto_template (p_admsmain myadmsmain,p_slist _template)
{
  myadmsmain->_template=_template;
  myadmsmain->_template_isdefault=0;
}
p_admsttransform
adms_admsmain_list_template_lookup_by_id (p_admsmain mymyadmsmain,p_quark myf,int myl,const char* myadmstname,p_admsttransform myparent)
{
  p_slist list=adms_admsmain_valueof_template(mymyadmsmain);
  while(list) {
    p_admsttransform refadmsttransform=adms_admsttransform(list->data);
    if(!strcmp(adms_admsttransform_valueof_f(refadmsttransform)->_value,myf->_value)&&
       (adms_admsttransform_valueof_l(refadmsttransform)==myl)&&
       !strcmp(adms_admsttransform_valueof_admstname(refadmsttransform),myadmstname)&&
       (adms_admsttransform_valueof_parent(refadmsttransform)==myparent))
      return refadmsttransform;
    list=list->next;
  }
  return NULL;
}
p_admsttransform
adms_admsmain_list_template_prepend_by_id (p_admsmain mymyadmsmain,p_quark myf,int myl,const char* myadmstname,p_admsttransform myparent)
{
  p_admsttransform reftemplate=adms_admsttransform_new(myf,myl,myadmstname,myparent);
  adms_slist_push(&adms_admsmain_valueof_template(mymyadmsmain),adms_adms(reftemplate));
  return reftemplate;
}
p_admsttransform
adms_admsmain_list_template_prepend_by_id_once_or_ignore (p_admsmain mymyadmsmain,p_quark myf,int myl,const char* myadmstname,p_admsttransform myparent)
{
  p_slist list=adms_admsmain_valueof_template(mymyadmsmain);
  p_admsttransform reftemplate=adms_admsttransform_new(myf,myl,myadmstname,myparent);
  while(list)
  {
    if(!adms_admsttransform_cmp(adms_admsttransform(list->data),reftemplate))
    {
      adms_admsttransform_free (reftemplate);
      return adms_admsttransform(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_template(mymyadmsmain),adms_adms(reftemplate));
  return reftemplate;
}
void
adms_admsmain_list_template_prepend_once_or_ignore (p_admsmain mymyadmsmain,p_admsttransform mytemplate)
{
  p_slist list=adms_admsmain_valueof_template(mymyadmsmain);
  while(list)
  {
    if(!adms_admsttransform_cmp(adms_admsttransform(list->data),mytemplate))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_template(mymyadmsmain),adms_adms(mytemplate));
}

inline void
adms_admsmain_valueto_instanceofadmsttransform (p_admsmain myadmsmain,p_slist _instanceofadmsttransform)
{
  myadmsmain->_instanceofadmsttransform=_instanceofadmsttransform;
  myadmsmain->_instanceofadmsttransform_isdefault=0;
}
p_instanceofadmsttransform
adms_admsmain_list_instanceofadmsttransform_lookup_by_id (p_admsmain mymyadmsmain,p_admsttransform myadmsttemplate)
{
  p_slist list=adms_admsmain_valueof_instanceofadmsttransform(mymyadmsmain);
  while(list) {
    p_instanceofadmsttransform refinstanceofadmsttransform=adms_instanceofadmsttransform(list->data);
    if((adms_instanceofadmsttransform_valueof_admsttemplate(refinstanceofadmsttransform)==myadmsttemplate))
      return refinstanceofadmsttransform;
    list=list->next;
  }
  return NULL;
}
p_instanceofadmsttransform
adms_admsmain_list_instanceofadmsttransform_prepend_by_id (p_admsmain mymyadmsmain,p_admsttransform myadmsttemplate)
{
  p_instanceofadmsttransform refinstanceofadmsttransform=adms_instanceofadmsttransform_new(myadmsttemplate);
  adms_slist_push(&adms_admsmain_valueof_instanceofadmsttransform(mymyadmsmain),adms_adms(refinstanceofadmsttransform));
  return refinstanceofadmsttransform;
}
p_instanceofadmsttransform
adms_admsmain_list_instanceofadmsttransform_prepend_by_id_once_or_ignore (p_admsmain mymyadmsmain,p_admsttransform myadmsttemplate)
{
  p_slist list=adms_admsmain_valueof_instanceofadmsttransform(mymyadmsmain);
  p_instanceofadmsttransform refinstanceofadmsttransform=adms_instanceofadmsttransform_new(myadmsttemplate);
  while(list)
  {
    if(!adms_instanceofadmsttransform_cmp(adms_instanceofadmsttransform(list->data),refinstanceofadmsttransform))
    {
      adms_instanceofadmsttransform_free (refinstanceofadmsttransform);
      return adms_instanceofadmsttransform(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_instanceofadmsttransform(mymyadmsmain),adms_adms(refinstanceofadmsttransform));
  return refinstanceofadmsttransform;
}
void
adms_admsmain_list_instanceofadmsttransform_prepend_once_or_ignore (p_admsmain mymyadmsmain,p_instanceofadmsttransform myinstanceofadmsttransform)
{
  p_slist list=adms_admsmain_valueof_instanceofadmsttransform(mymyadmsmain);
  while(list)
  {
    if(!adms_instanceofadmsttransform_cmp(adms_instanceofadmsttransform(list->data),myinstanceofadmsttransform))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_instanceofadmsttransform(mymyadmsmain),adms_adms(myinstanceofadmsttransform));
}

inline void
adms_admsmain_valueto_instanceofadmsttransforminsideapplytemplate (p_admsmain myadmsmain,p_slist _instanceofadmsttransforminsideapplytemplate)
{
  myadmsmain->_instanceofadmsttransforminsideapplytemplate=_instanceofadmsttransforminsideapplytemplate;
  myadmsmain->_instanceofadmsttransforminsideapplytemplate_isdefault=0;
}
p_instanceofadmsttransform
adms_admsmain_list_instanceofadmsttransforminsideapplytemplate_lookup_by_id (p_admsmain mymyadmsmain,p_admsttransform myadmsttemplate)
{
  p_slist list=adms_admsmain_valueof_instanceofadmsttransforminsideapplytemplate(mymyadmsmain);
  while(list) {
    p_instanceofadmsttransform refinstanceofadmsttransform=adms_instanceofadmsttransform(list->data);
    if((adms_instanceofadmsttransform_valueof_admsttemplate(refinstanceofadmsttransform)==myadmsttemplate))
      return refinstanceofadmsttransform;
    list=list->next;
  }
  return NULL;
}
p_instanceofadmsttransform
adms_admsmain_list_instanceofadmsttransforminsideapplytemplate_prepend_by_id (p_admsmain mymyadmsmain,p_admsttransform myadmsttemplate)
{
  p_instanceofadmsttransform refinstanceofadmsttransforminsideapplytemplate=adms_instanceofadmsttransform_new(myadmsttemplate);
  adms_slist_push(&adms_admsmain_valueof_instanceofadmsttransforminsideapplytemplate(mymyadmsmain),adms_adms(refinstanceofadmsttransforminsideapplytemplate));
  return refinstanceofadmsttransforminsideapplytemplate;
}
p_instanceofadmsttransform
adms_admsmain_list_instanceofadmsttransforminsideapplytemplate_prepend_by_id_once_or_ignore (p_admsmain mymyadmsmain,p_admsttransform myadmsttemplate)
{
  p_slist list=adms_admsmain_valueof_instanceofadmsttransforminsideapplytemplate(mymyadmsmain);
  p_instanceofadmsttransform refinstanceofadmsttransforminsideapplytemplate=adms_instanceofadmsttransform_new(myadmsttemplate);
  while(list)
  {
    if(!adms_instanceofadmsttransform_cmp(adms_instanceofadmsttransform(list->data),refinstanceofadmsttransforminsideapplytemplate))
    {
      adms_instanceofadmsttransform_free (refinstanceofadmsttransforminsideapplytemplate);
      return adms_instanceofadmsttransform(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_instanceofadmsttransforminsideapplytemplate(mymyadmsmain),adms_adms(refinstanceofadmsttransforminsideapplytemplate));
  return refinstanceofadmsttransforminsideapplytemplate;
}
void
adms_admsmain_list_instanceofadmsttransforminsideapplytemplate_prepend_once_or_ignore (p_admsmain mymyadmsmain,p_instanceofadmsttransform myinstanceofadmsttransforminsideapplytemplate)
{
  p_slist list=adms_admsmain_valueof_instanceofadmsttransforminsideapplytemplate(mymyadmsmain);
  while(list)
  {
    if(!adms_instanceofadmsttransform_cmp(adms_instanceofadmsttransform(list->data),myinstanceofadmsttransforminsideapplytemplate))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_instanceofadmsttransforminsideapplytemplate(mymyadmsmain),adms_adms(myinstanceofadmsttransforminsideapplytemplate));
}

inline void
adms_admsmain_valueto_valueof (p_admsmain myadmsmain,p_slist _valueof)
{
  myadmsmain->_valueof=_valueof;
  myadmsmain->_valueof_isdefault=0;
}
void
adms_admsmain_list_valueof_prepend (p_admsmain mymyadmsmain,p_adms myvalueof)
{
  adms_slist_push(&adms_admsmain_valueof_valueof(mymyadmsmain),adms_adms(myvalueof));
}

inline void
adms_admsmain_valueto_alladmstnew (p_admsmain myadmsmain,p_slist _alladmstnew)
{
  myadmsmain->_alladmstnew=_alladmstnew;
  myadmsmain->_alladmstnew_isdefault=0;
}
p_admst
adms_admsmain_list_alladmstnew_lookup_by_id (p_admsmain mymyadmsmain,p_admsttransform myadmsttransform,p_admst myprevious,const char* myattributename,e_admst_size mysize)
{
  p_slist list=adms_admsmain_valueof_alladmstnew(mymyadmsmain);
  while(list) {
    p_admst refadmst=adms_admst(list->data);
    if((adms_admst_valueof_admsttransform(refadmst)==myadmsttransform)&&
       (adms_admst_valueof_previous(refadmst)==myprevious)&&
       !strcmp(adms_admst_valueof_attributename(refadmst),myattributename)&&
       (adms_admst_valueof_size(refadmst)==mysize))
      return refadmst;
    list=list->next;
  }
  return NULL;
}
p_admst
adms_admsmain_list_alladmstnew_prepend_by_id (p_admsmain mymyadmsmain,p_admsttransform myadmsttransform,p_admst myprevious,const char* myattributename,e_admst_size mysize)
{
  p_admst refalladmstnew=adms_admst_new(myadmsttransform,myprevious,myattributename,mysize);
  adms_slist_push(&adms_admsmain_valueof_alladmstnew(mymyadmsmain),adms_adms(refalladmstnew));
  return refalladmstnew;
}
p_admst
adms_admsmain_list_alladmstnew_prepend_by_id_once_or_ignore (p_admsmain mymyadmsmain,p_admsttransform myadmsttransform,p_admst myprevious,const char* myattributename,e_admst_size mysize)
{
  p_slist list=adms_admsmain_valueof_alladmstnew(mymyadmsmain);
  p_admst refalladmstnew=adms_admst_new(myadmsttransform,myprevious,myattributename,mysize);
  while(list)
  {
    if(!adms_admst_cmp(adms_admst(list->data),refalladmstnew))
    {
      adms_admst_free (refalladmstnew);
      return adms_admst(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_alladmstnew(mymyadmsmain),adms_adms(refalladmstnew));
  return refalladmstnew;
}
void
adms_admsmain_list_alladmstnew_prepend_once_or_ignore (p_admsmain mymyadmsmain,p_admst myalladmstnew)
{
  p_slist list=adms_admsmain_valueof_alladmstnew(mymyadmsmain);
  while(list)
  {
    if(!adms_admst_cmp(adms_admst(list->data),myalladmstnew))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_alladmstnew(mymyadmsmain),adms_adms(myalladmstnew));
}

inline void
adms_admsmain_valueto_alladmstdestroy (p_admsmain myadmsmain,p_slist _alladmstdestroy)
{
  myadmsmain->_alladmstdestroy=_alladmstdestroy;
  myadmsmain->_alladmstdestroy_isdefault=0;
}
p_admst
adms_admsmain_list_alladmstdestroy_lookup_by_id (p_admsmain mymyadmsmain,p_admsttransform myadmsttransform,p_admst myprevious,const char* myattributename,e_admst_size mysize)
{
  p_slist list=adms_admsmain_valueof_alladmstdestroy(mymyadmsmain);
  while(list) {
    p_admst refadmst=adms_admst(list->data);
    if((adms_admst_valueof_admsttransform(refadmst)==myadmsttransform)&&
       (adms_admst_valueof_previous(refadmst)==myprevious)&&
       !strcmp(adms_admst_valueof_attributename(refadmst),myattributename)&&
       (adms_admst_valueof_size(refadmst)==mysize))
      return refadmst;
    list=list->next;
  }
  return NULL;
}
p_admst
adms_admsmain_list_alladmstdestroy_prepend_by_id (p_admsmain mymyadmsmain,p_admsttransform myadmsttransform,p_admst myprevious,const char* myattributename,e_admst_size mysize)
{
  p_admst refalladmstdestroy=adms_admst_new(myadmsttransform,myprevious,myattributename,mysize);
  adms_slist_push(&adms_admsmain_valueof_alladmstdestroy(mymyadmsmain),adms_adms(refalladmstdestroy));
  return refalladmstdestroy;
}
p_admst
adms_admsmain_list_alladmstdestroy_prepend_by_id_once_or_ignore (p_admsmain mymyadmsmain,p_admsttransform myadmsttransform,p_admst myprevious,const char* myattributename,e_admst_size mysize)
{
  p_slist list=adms_admsmain_valueof_alladmstdestroy(mymyadmsmain);
  p_admst refalladmstdestroy=adms_admst_new(myadmsttransform,myprevious,myattributename,mysize);
  while(list)
  {
    if(!adms_admst_cmp(adms_admst(list->data),refalladmstdestroy))
    {
      adms_admst_free (refalladmstdestroy);
      return adms_admst(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_alladmstdestroy(mymyadmsmain),adms_adms(refalladmstdestroy));
  return refalladmstdestroy;
}
void
adms_admsmain_list_alladmstdestroy_prepend_once_or_ignore (p_admsmain mymyadmsmain,p_admst myalladmstdestroy)
{
  p_slist list=adms_admsmain_valueof_alladmstdestroy(mymyadmsmain);
  while(list)
  {
    if(!adms_admst_cmp(adms_admst(list->data),myalladmstdestroy))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_admsmain_valueof_alladmstdestroy(mymyadmsmain),adms_adms(myalladmstdestroy));
}
e_admsmain_info
adms_admsmain_fromstring_info_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_admsmain_enumeration_info_no;
  if(!strcmp(token,"yes"))
    return adms_admsmain_enumeration_info_yes;
  adms_message_fatal_continue(("select='admsmain/info': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_admsmain_tostring_info_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_admsmain_info e=myenumeration->_value;
  if(e==adms_admsmain_enumeration_info_no)
    return "no";
  if(e==adms_admsmain_enumeration_info_yes)
    return "yes";
  adms_message_fatal_continue(("select='admsmain/info': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_admsmain_usage
adms_admsmain_fromstring_usage_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_admsmain_enumeration_usage_no;
  if(!strcmp(token,"yes"))
    return adms_admsmain_enumeration_usage_yes;
  adms_message_fatal_continue(("select='admsmain/usage': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_admsmain_tostring_usage_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_admsmain_usage e=myenumeration->_value;
  if(e==adms_admsmain_enumeration_usage_no)
    return "no";
  if(e==adms_admsmain_enumeration_usage_yes)
    return "yes";
  adms_message_fatal_continue(("select='admsmain/usage': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_admsmain_verbose
adms_admsmain_fromstring_verbose_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_admsmain_enumeration_verbose_no;
  if(!strcmp(token,"yes"))
    return adms_admsmain_enumeration_verbose_yes;
  adms_message_fatal_continue(("select='admsmain/verbose': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_admsmain_tostring_verbose_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_admsmain_verbose e=myenumeration->_value;
  if(e==adms_admsmain_enumeration_verbose_no)
    return "no";
  if(e==adms_admsmain_enumeration_verbose_yes)
    return "yes";
  adms_message_fatal_continue(("select='admsmain/verbose': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_admsmain_hint
adms_admsmain_fromstring_hint_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_admsmain_enumeration_hint_no;
  if(!strcmp(token,"yes"))
    return adms_admsmain_enumeration_hint_yes;
  adms_message_fatal_continue(("select='admsmain/hint': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_admsmain_tostring_hint_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_admsmain_hint e=myenumeration->_value;
  if(e==adms_admsmain_enumeration_hint_no)
    return "no";
  if(e==adms_admsmain_enumeration_hint_yes)
    return "yes";
  adms_message_fatal_continue(("select='admsmain/hint': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_admsmain_warning
adms_admsmain_fromstring_warning_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_admsmain_enumeration_warning_no;
  if(!strcmp(token,"yes"))
    return adms_admsmain_enumeration_warning_yes;
  adms_message_fatal_continue(("select='admsmain/warning': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_admsmain_tostring_warning_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_admsmain_warning e=myenumeration->_value;
  if(e==adms_admsmain_enumeration_warning_no)
    return "no";
  if(e==adms_admsmain_enumeration_warning_yes)
    return "yes";
  adms_message_fatal_continue(("select='admsmain/warning': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_admsmain_obsolete
adms_admsmain_fromstring_obsolete_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_admsmain_enumeration_obsolete_no;
  if(!strcmp(token,"yes"))
    return adms_admsmain_enumeration_obsolete_yes;
  adms_message_fatal_continue(("select='admsmain/obsolete': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_admsmain_tostring_obsolete_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_admsmain_obsolete e=myenumeration->_value;
  if(e==adms_admsmain_enumeration_obsolete_no)
    return "no";
  if(e==adms_admsmain_enumeration_obsolete_yes)
    return "yes";
  adms_message_fatal_continue(("select='admsmain/obsolete': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_admsmain_debug
adms_admsmain_fromstring_debug_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_admsmain_enumeration_debug_no;
  if(!strcmp(token,"yes"))
    return adms_admsmain_enumeration_debug_yes;
  adms_message_fatal_continue(("select='admsmain/debug': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_admsmain_tostring_debug_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_admsmain_debug e=myenumeration->_value;
  if(e==adms_admsmain_enumeration_debug_no)
    return "no";
  if(e==adms_admsmain_enumeration_debug_yes)
    return "yes";
  adms_message_fatal_continue(("select='admsmain/debug': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_admsmain_dbg_vla
adms_admsmain_fromstring_dbg_vla_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_admsmain_enumeration_dbg_vla_no;
  if(!strcmp(token,"yes"))
    return adms_admsmain_enumeration_dbg_vla_yes;
  adms_message_fatal_continue(("select='admsmain/dbg_vla': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_admsmain_tostring_dbg_vla_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_admsmain_dbg_vla e=myenumeration->_value;
  if(e==adms_admsmain_enumeration_dbg_vla_no)
    return "no";
  if(e==adms_admsmain_enumeration_dbg_vla_yes)
    return "yes";
  adms_message_fatal_continue(("select='admsmain/dbg_vla': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_admsmain_dbg_xml
adms_admsmain_fromstring_dbg_xml_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_admsmain_enumeration_dbg_xml_no;
  if(!strcmp(token,"yes"))
    return adms_admsmain_enumeration_dbg_xml_yes;
  adms_message_fatal_continue(("select='admsmain/dbg_xml': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_admsmain_tostring_dbg_xml_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_admsmain_dbg_xml e=myenumeration->_value;
  if(e==adms_admsmain_enumeration_dbg_xml_no)
    return "no";
  if(e==adms_admsmain_enumeration_dbg_xml_yes)
    return "yes";
  adms_message_fatal_continue(("select='admsmain/dbg_xml': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_admsmain_error
adms_admsmain_fromstring_error_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_admsmain_enumeration_error_no;
  if(!strcmp(token,"yes"))
    return adms_admsmain_enumeration_error_yes;
  adms_message_fatal_continue(("select='admsmain/error': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_admsmain_tostring_error_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_admsmain_error e=myenumeration->_value;
  if(e==adms_admsmain_enumeration_error_no)
    return "no";
  if(e==adms_admsmain_enumeration_error_yes)
    return "yes";
  adms_message_fatal_continue(("select='admsmain/error': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_admsmain_fatal
adms_admsmain_fromstring_fatal_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_admsmain_enumeration_fatal_no;
  if(!strcmp(token,"yes"))
    return adms_admsmain_enumeration_fatal_yes;
  adms_message_fatal_continue(("select='admsmain/fatal': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_admsmain_tostring_fatal_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_admsmain_fatal e=myenumeration->_value;
  if(e==adms_admsmain_enumeration_fatal_no)
    return "no";
  if(e==adms_admsmain_enumeration_fatal_yes)
    return "yes";
  adms_message_fatal_continue(("select='admsmain/fatal': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_admsmain_dbg_mem
adms_admsmain_fromstring_dbg_mem_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_admsmain_enumeration_dbg_mem_no;
  if(!strcmp(token,"yes"))
    return adms_admsmain_enumeration_dbg_mem_yes;
  adms_message_fatal_continue(("select='admsmain/dbg_mem': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_admsmain_tostring_dbg_mem_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_admsmain_dbg_mem e=myenumeration->_value;
  if(e==adms_admsmain_enumeration_dbg_mem_no)
    return "no";
  if(e==adms_admsmain_enumeration_dbg_mem_yes)
    return "yes";
  adms_message_fatal_continue(("select='admsmain/dbg_mem': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}