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

inline void adms_expression_free(p_expression myexpression)
{
  if(!myexpression)
    return;
  adms_enumeration_free(myexpression->_math._dependency);
  free(myexpression->_math._value);
  adms_slist_free(myexpression->_function);
  adms_slist_free(myexpression->_probe);
  adms_slist_free(myexpression->_variable);
  if(myexpression->_tree)
    if(adms_adms(myexpression->_tree)->_datatypename==adms_adms_enumeration_datatypename_quark)
      adms_quark_free(adms_quark(myexpression->_tree));
  adms_quark_free(myexpression->_hasspecialnumber);
  adms_enumeration_free(myexpression->_hasVoltageDependentFunction);
  adms_enumeration_free(myexpression->_TemperatureDependent);
  adms_enumeration_free(myexpression->_value);
  adms_global_increment_nbexpressiondestroy();
  free(myexpression);
}
int adms_expression_cmp (p_expression myexpression,p_expression refexpression)
{
  int status;
  status =
  (
    (adms_expression_valueof_module (myexpression) != adms_expression_valueof_module (refexpression))
    ||
    (adms_expression_valueof_tree (myexpression) != adms_expression_valueof_tree (refexpression))
  );
  return status;
}
p_expression adms_expression_new(p_module mymodule,p_adms mytree)
{
  p_expression mynewexpression=(p_expression) calloc(1,(size_t)sizeof(t_expression));
  adms_global_increment_nbexpressionnew();
  mynewexpression->_math._adms._datatypename=adms_adms_enumeration_datatypename_expression;
  mynewexpression->_math._adms._seen=adms_adms_enumeration_seen_no;
  (mynewexpression->_math)._value=adms_real_new(adms_NAN);
  (mynewexpression->_math)._static=adms_enumeration_new(adms_math_enumeration_static_no,adms_math_fromstring_static_impl,adms_math_tostring_static_impl);
  (mynewexpression->_math)._dynamic=adms_enumeration_new(adms_math_enumeration_dynamic_no,adms_math_fromstring_dynamic_impl,adms_math_tostring_dynamic_impl);
  (mynewexpression->_math)._dependency=adms_enumeration_new(adms_math_enumeration_dependency_constant,adms_math_fromstring_dependency_impl,adms_math_tostring_dependency_impl);
  mynewexpression->_module_isdefault=-1;
  adms_expression_valueto_module (mynewexpression,mymodule);
  mynewexpression->_module_isdefault=1;
  mynewexpression->_tree_isdefault=-1;
  adms_expression_valueto_tree (mynewexpression,mytree);
  mynewexpression->_tree_isdefault=1;
  mynewexpression->_hasspecialnumber_isdefault=-1;
  mynewexpression->_hasVoltageDependentFunction_isdefault=-1;
  adms_expression_valueto_hasVoltageDependentFunction(mynewexpression,adms_enumeration_new(adms_expression_enumeration_hasVoltageDependentFunction_no,adms_expression_fromstring_hasVoltageDependentFunction_impl,adms_expression_tostring_hasVoltageDependentFunction_impl));
  mynewexpression->_hasVoltageDependentFunction_isdefault=1;
  mynewexpression->_TemperatureDependent_isdefault=-1;
  adms_expression_valueto_TemperatureDependent(mynewexpression,adms_enumeration_new(adms_expression_enumeration_TemperatureDependent_no,adms_expression_fromstring_TemperatureDependent_impl,adms_expression_tostring_TemperatureDependent_impl));
  mynewexpression->_TemperatureDependent_isdefault=1;
  mynewexpression->_value_isdefault=-1;
  adms_expression_valueto_value(mynewexpression,adms_enumeration_new(adms_expression_enumeration_value_is_any,adms_expression_fromstring_value_impl,adms_expression_tostring_value_impl));
  mynewexpression->_value_isdefault=1;
  mynewexpression->_function_isdefault=-1;
  mynewexpression->_probe_isdefault=-1;
  mynewexpression->_variable_isdefault=-1;
  return mynewexpression;
}
p_adms adms_expression_new_impl (p_adms arguments[])
{
  p_expression mynewexpression;
  p_module mymodule=(p_module)arguments[0];
  p_adms mytree=(p_adms)arguments[1];
  mynewexpression=adms_expression_new(mymodule,mytree);
  return adms_adms(mynewexpression);
}
/*($2)*/
char*adms_expression_uid (p_expression mynewexpression)
{
  char*myuid=NULL;
  char*myuid0=adms_admsxml_uid(mynewexpression->_tree);
  adms_strconcat2(&myuid,"(");
  adms_strconcat(&myuid,myuid0);
  adms_strconcat2(&myuid,")");
  return myuid;
}

inline void
adms_expression_valueto_module (p_expression myexpression,p_module _module)
{
  myexpression->_module=_module;
  myexpression->_module_isdefault=0;
}

inline void
adms_expression_valueto_tree (p_expression myexpression,p_adms _tree)
{
  myexpression->_tree=_tree;
  myexpression->_tree_isdefault=0;
}

inline void
adms_expression_valueto_hasspecialnumber (p_expression myexpression,p_quark _hasspecialnumber)
{
  if(myexpression->_hasspecialnumber_isdefault!=-1)
    adms_quark_free(myexpression->_hasspecialnumber);
  myexpression->_hasspecialnumber=_hasspecialnumber;
  myexpression->_hasspecialnumber_isdefault=0;
}

inline void
adms_expression_valueto_hasVoltageDependentFunction (p_expression myexpression,p_enumeration _hasVoltageDependentFunction)
{
  myexpression->_hasVoltageDependentFunction=_hasVoltageDependentFunction;
  myexpression->_hasVoltageDependentFunction_isdefault=0;
}

inline void
adms_expression_valueto_TemperatureDependent (p_expression myexpression,p_enumeration _TemperatureDependent)
{
  myexpression->_TemperatureDependent=_TemperatureDependent;
  myexpression->_TemperatureDependent_isdefault=0;
}

inline void
adms_expression_valueto_value (p_expression myexpression,p_enumeration _value)
{
  myexpression->_value=_value;
  myexpression->_value_isdefault=0;
}

inline void
adms_expression_valueto_function (p_expression myexpression,p_slist _function)
{
  myexpression->_function=_function;
  myexpression->_function_isdefault=0;
}
p_function
adms_expression_list_function_lookup_by_id (p_expression mymyexpression,p_quark myname,p_integer myunique_id)
{
  p_slist list=adms_expression_valueof_function(mymyexpression);
  while(list) {
    p_function reffunction=adms_function(list->data);
    if(!strcmp(adms_function_valueof_name(reffunction)->_value,myname->_value)&&
       (adms_function_valueof_unique_id(reffunction)==myunique_id))
      return reffunction;
    list=list->next;
  }
  return NULL;
}
p_function
adms_expression_list_function_prepend_by_id (p_expression mymyexpression,p_quark myname,p_integer myunique_id)
{
  p_function reffunction=adms_function_new(myname,myunique_id);
  adms_slist_push(&adms_expression_valueof_function(mymyexpression),adms_adms(reffunction));
  return reffunction;
}
p_function
adms_expression_list_function_prepend_by_id_once_or_ignore (p_expression mymyexpression,p_quark myname,p_integer myunique_id)
{
  p_function reffunction=adms_function_new(myname,myunique_id);
  adms_slist_push(&adms_expression_valueof_function(mymyexpression),adms_adms(reffunction));
  return reffunction;
}
void
adms_expression_list_function_prepend (p_expression mymyexpression,p_function myfunction)
{
  adms_slist_push(&adms_expression_valueof_function(mymyexpression),adms_adms(myfunction));
}

inline void
adms_expression_valueto_probe (p_expression myexpression,p_slist _probe)
{
  myexpression->_probe=_probe;
  myexpression->_probe_isdefault=0;
}
p_probe
adms_expression_list_probe_lookup_by_id (p_expression mymyexpression,p_module mymodule,p_branch mybranch,p_nature mynature)
{
  p_slist list=adms_expression_valueof_probe(mymyexpression);
  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_expression_list_probe_prepend_by_id (p_expression mymyexpression,p_module mymodule,p_branch mybranch,p_nature mynature)
{
  p_probe refprobe=adms_probe_new(mymodule,mybranch,mynature);
  adms_slist_push(&adms_expression_valueof_probe(mymyexpression),adms_adms(refprobe));
  return refprobe;
}
p_probe
adms_expression_list_probe_prepend_by_id_once_or_ignore (p_expression mymyexpression,p_module mymodule,p_branch mybranch,p_nature mynature)
{
  p_slist list=adms_expression_valueof_probe(mymyexpression);
  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_expression_valueof_probe(mymyexpression),adms_adms(refprobe));
  return refprobe;
}
void
adms_expression_list_probe_prepend_once_or_ignore (p_expression mymyexpression,p_probe myprobe)
{
  p_slist list=adms_expression_valueof_probe(mymyexpression);
  while(list)
  {
    if(!adms_probe_cmp(adms_probe(list->data),myprobe))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_expression_valueof_probe(mymyexpression),adms_adms(myprobe));
}

inline void
adms_expression_valueto_variable (p_expression myexpression,p_slist _variable)
{
  myexpression->_variable=_variable;
  myexpression->_variable_isdefault=0;
}
p_variable
adms_expression_list_variable_lookup_by_id (p_expression mymyexpression,p_module mymodule,p_quark myname,p_adms myblock)
{
  p_slist list=adms_expression_valueof_variable(mymyexpression);
  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_expression_list_variable_prepend_by_id (p_expression mymyexpression,p_module mymodule,p_quark myname,p_adms myblock)
{
  p_variable refvariable=adms_variable_new(mymodule,myname,myblock);
  adms_slist_push(&adms_expression_valueof_variable(mymyexpression),adms_adms(refvariable));
  return refvariable;
}
p_variable
adms_expression_list_variable_prepend_by_id_once_or_ignore (p_expression mymyexpression,p_module mymodule,p_quark myname,p_adms myblock)
{
  p_slist list=adms_expression_valueof_variable(mymyexpression);
  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_expression_valueof_variable(mymyexpression),adms_adms(refvariable));
  return refvariable;
}
void
adms_expression_list_variable_prepend_once_or_ignore (p_expression mymyexpression,p_variable myvariable)
{
  p_slist list=adms_expression_valueof_variable(mymyexpression);
  while(list)
  {
    if(!adms_variable_cmp(adms_variable(list->data),myvariable))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_expression_valueof_variable(mymyexpression),adms_adms(myvariable));
}
e_expression_hasVoltageDependentFunction
adms_expression_fromstring_hasVoltageDependentFunction_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_expression_enumeration_hasVoltageDependentFunction_no;
  if(!strcmp(token,"yes"))
    return adms_expression_enumeration_hasVoltageDependentFunction_yes;
  adms_message_fatal_continue(("select='expression/hasVoltageDependentFunction': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_expression_tostring_hasVoltageDependentFunction_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_expression_hasVoltageDependentFunction e=myenumeration->_value;
  if(e==adms_expression_enumeration_hasVoltageDependentFunction_no)
    return "no";
  if(e==adms_expression_enumeration_hasVoltageDependentFunction_yes)
    return "yes";
  adms_message_fatal_continue(("select='expression/hasVoltageDependentFunction': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_expression_TemperatureDependent
adms_expression_fromstring_TemperatureDependent_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"no"))
    return adms_expression_enumeration_TemperatureDependent_no;
  if(!strcmp(token,"yes"))
    return adms_expression_enumeration_TemperatureDependent_yes;
  adms_message_fatal_continue(("select='expression/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_expression_tostring_TemperatureDependent_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_expression_TemperatureDependent e=myenumeration->_value;
  if(e==adms_expression_enumeration_TemperatureDependent_no)
    return "no";
  if(e==adms_expression_enumeration_TemperatureDependent_yes)
    return "yes";
  adms_message_fatal_continue(("select='expression/TemperatureDependent': possible values:\n"))
  adms_message_fatal_continue(("no|yes\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}

e_expression_value
adms_expression_fromstring_value_impl (p_admsttransform myadmsttransform,char*token)
{
  if(!strcmp(token,"is_any"))
    return adms_expression_enumeration_value_is_any;
  if(!strcmp(token,"is_neg_one"))
    return adms_expression_enumeration_value_is_neg_one;
  if(!strcmp(token,"is_one"))
    return adms_expression_enumeration_value_is_one;
  if(!strcmp(token,"is_zero"))
    return adms_expression_enumeration_value_is_zero;
  adms_message_fatal_continue(("select='expression/value': possible values:\n"))
  adms_message_fatal_continue(("is_any|is_neg_one|is_one|is_zero\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return 0;
}
char*
adms_expression_tostring_value_impl (p_admsttransform myadmsttransform,p_enumeration myenumeration)
{
  e_expression_value e=myenumeration->_value;
  if(e==adms_expression_enumeration_value_is_any)
    return "is_any";
  if(e==adms_expression_enumeration_value_is_neg_one)
    return "is_neg_one";
  if(e==adms_expression_enumeration_value_is_one)
    return "is_one";
  if(e==adms_expression_enumeration_value_is_zero)
    return "is_zero";
  adms_message_fatal_continue(("select='expression/value': possible values:\n"))
  adms_message_fatal_continue(("is_any|is_neg_one|is_one|is_zero\n"))
  adms_message_fatal(("see %s\n",adms_admsttransform_uid(myadmsttransform)))
  return NULL;
}