production.h File Reference

#include <map>
#include <set>

Go to the source code of this file.

Data Structures
struct	multi_attributes_struct
struct	production_struct

Macros
#define	DECLARED_I_SUPPORT   2
#define	DECLARED_O_SUPPORT   1
#define	IE_PRODS   1
#define	NO_SAVED_PRODS   -1
#define	PE_PRODS   0
#define	UNDECLARED_SUPPORT   0

Typedefs
typedef struct action_struct	action
typedef struct agent_struct	agent
typedef char	Bool
typedef unsigned char	byte
typedef struct condition_struct	condition
typedef struct cons_struct	cons
typedef cons	list
typedef struct multi_attributes_struct	multi_attribute
typedef struct production_struct	production
typedef char *	rhs_value
typedef std::map< Symbol *, Symbol * >	rl_symbol_map
typedef std::set< rl_symbol_map >	rl_symbol_map_set
typedef union symbol_union	Symbol
typedef uint64_t	tc_number
typedef char *	test

Functions
Bool	action_is_in_tc (action *a, tc_number tc)
void	add_action_to_tc (agent *thisAgent, action *a, tc_number tc,::list **id_list,::list **var_list)
void	add_all_variables_in_action (agent *thisAgent, action *a, tc_number tc,::list **var_list)
void	add_bound_variables_in_condition (agent *thisAgent, condition *c, tc_number tc,::list **var_list)
void	add_bound_variables_in_test (agent *thisAgent, test t, tc_number tc,::list **var_list)
void	add_cond_to_tc (agent *thisAgent, condition *c, tc_number tc,::list **id_list,::list **var_list)
void	add_new_test_to_test (agent *thisAgent, test *t, test add_me)
void	add_new_test_to_test_if_not_already_there (agent *thisAgent, test *t, test add_me, bool neg)
void	add_symbol_to_tc (agent *thisAgent, Symbol *sym, tc_number tc,::list **id_list,::list **var_list)
Bool	canonical_cond_greater (condition *c1, condition *c2)
Bool	cond_is_in_tc (agent *thisAgent, condition *cond, tc_number tc)
Bool	conditions_are_equal (condition *c1, condition *c2)
condition *	copy_condition (agent *thisAgent, condition *cond)
void	copy_condition_list (agent *thisAgent, condition *top_cond, condition **dest_top, condition **dest_bottom)
test	copy_of_equality_test_found_in_test (agent *thisAgent, test t)
rhs_value	copy_rhs_value (agent *thisAgent, rhs_value rv)
test	copy_test (agent *thisAgent, test t)
test	copy_test_removing_goal_impasse_tests (agent *thisAgent, test t, Bool *removed_goal, Bool *removed_impasse)
void	deallocate_action_list (agent *thisAgent, action *actions)
void	deallocate_condition_list (agent *thisAgent, condition *cond_list)
void	deallocate_list_of_nots (agent *thisAgent, not_struct *nots)
void	deallocate_production (agent *thisAgent, production *prod)
void	deallocate_rhs_value (agent *thisAgent, rhs_value rv)
void	deallocate_symbol_list_removing_references (agent *thisAgent,::list *sym_list)
void	deallocate_test (agent *thisAgent, test t)
void	excise_all_productions (agent *thisAgent, Bool print_sharp_sign)
void	excise_all_productions_of_type (agent *thisAgent, byte type, Bool print_sharp_sign)
void	excise_production (agent *thisAgent, production *prod, Bool print_sharp_sign)
char	first_letter_from_rhs_value (rhs_value rv)
char	first_letter_from_symbol (Symbol *sym)
char	first_letter_from_test (test t)
Symbol *	generate_new_variable (agent *thisAgent, const char *prefix)
tc_number	get_new_tc_number (agent *thisAgent)
uint32_t	hash_condition (agent *thisAgent, condition *cond)
uint32_t	hash_test (agent *thisAgent, test t)
void	init_production_utilities (agent *thisAgent)
production *	make_production (agent *thisAgent, byte type, Symbol *name, condition **lhs_top, condition **lhs_bottom, action **rhs_top, Bool reorder_nccs)
void	production_add_ref (production *p)
void	production_remove_ref (agent *thisAgent, production *p)
void	reset_variable_generator (agent *thisAgent, condition *conds_with_vars_to_avoid, action *actions_with_vars_to_avoid)
Bool	test_includes_equality_test_for_symbol (test t, Symbol *sym)
Bool	test_includes_goal_or_impasse_id_test (test t, Bool look_for_goal, Bool look_for_impasse)
Bool	tests_are_equal (test t1, test t2, bool neg)
void	unmark_variables_and_free_list (agent *thisAgent,::list *var_list)

Macro Definition Documentation

#define DECLARED_I_SUPPORT   2

Definition at line 68 of file production.h.

Referenced by calculate_support_for_instantiation_preferences(), create_instantiation(), fill_in_new_instantiation_stuff(), p_node_left_addition(), parse_production(), and print_production().

#define DECLARED_O_SUPPORT   1

Definition at line 67 of file production.h.

Referenced by calculate_support_for_instantiation_preferences(), create_instantiation(), fill_in_new_instantiation_stuff(), p_node_left_addition(), parse_production(), and print_production().

#define IE_PRODS   1

Definition at line 73 of file production.h.

Referenced by active_production_type_at_goal(), create_soar_agent(), determine_highest_active_production_level_in_stack_apply(), determine_highest_active_production_level_in_stack_propose(), do_one_top_level_phase(), do_preference_phase(), do_working_memory_phase(), minor_quiescence_at_goal(), p_node_left_addition(), print_phase(), and reinitialize_soar().

#define NO_SAVED_PRODS   -1

Definition at line 74 of file production.h.

Referenced by determine_highest_active_production_level_in_stack_apply(), determine_highest_active_production_level_in_stack_propose(), initialize_consistency_calculations_for_new_decision(), and make_new_identifier().

#define PE_PRODS   0

Definition at line 72 of file production.h.

Referenced by active_production_type_at_goal(), create_instantiation(), determine_highest_active_production_level_in_stack_apply(), determine_highest_active_production_level_in_stack_propose(), do_one_top_level_phase(), do_preference_phase(), do_working_memory_phase(), p_node_left_addition(), postpone_assertion(), print_phase(), and restore_postponed_assertions().

#define UNDECLARED_SUPPORT   0

Definition at line 66 of file production.h.

Referenced by calculate_support_for_instantiation_preferences(), make_production(), p_node_left_addition(), and parse_production().

Typedef Documentation

typedef struct action_struct action

Definition at line 85 of file production.h.

typedef struct agent_struct agent

Definition at line 88 of file production.h.

typedef char Bool

Definition at line 78 of file production.h.

typedef unsigned char byte

Definition at line 83 of file production.h.

typedef struct condition_struct condition

Definition at line 86 of file production.h.

typedef struct cons_struct cons

Definition at line 87 of file production.h.

typedef cons list

Definition at line 89 of file production.h.

typedef struct multi_attributes_struct multi_attribute

typedef struct production_struct production

typedef char* rhs_value

Definition at line 82 of file production.h.

typedef std::map< Symbol*, Symbol* > rl_symbol_map

Definition at line 95 of file production.h.

typedef std::set< rl_symbol_map > rl_symbol_map_set

Definition at line 96 of file production.h.

typedef union symbol_union Symbol

Definition at line 90 of file production.h.

typedef uint64_t tc_number

Definition at line 84 of file production.h.

typedef char* test

Definition at line 81 of file production.h.

Function Documentation

Bool action_is_in_tc	(	action *	a,
		tc_number	tc
	)

Definition at line 1465 of file production.cpp.

References FALSE, action_struct::id, MAKE_ACTION, rhs_value_to_symbol(), symbol_is_in_tc(), and action_struct::type.

Referenced by add_tc_through_lhs_and_rhs(), and calculate_compile_time_o_support().

                                               {
  if (a->type != MAKE_ACTION) return FALSE;
  return symbol_is_in_tc (rhs_value_to_symbol(a->id), tc);
}

void add_action_to_tc	(	agent *	thisAgent,
		action *	a,
		tc_number	tc,
		::list **	id_list,
		::list **	var_list
	)

void add_all_variables_in_action	(	agent *	thisAgent,
		action *	a,
		tc_number	tc,
		::list **	var_list
	)

void add_bound_variables_in_condition	(	agent *	thisAgent,
		condition *	c,
		tc_number	tc,
		::list **	var_list
	)

void add_bound_variables_in_test	(	agent *	thisAgent,
		test	t,
		tc_number	tc,
		::list **	var_list
	)

void add_cond_to_tc	(	agent *	thisAgent,
		condition *	c,
		tc_number	tc,
		::list **	id_list,
		::list **	var_list
	)

void add_new_test_to_test	(	agent *	thisAgent,
		test *	t,
		test	add_me
	)

Definition at line 340 of file production.cpp.

References allocate_cons(), complex_test_from_test(), agent_struct::complex_test_pool, complex_test_struct::test_info_union::conjunct_list, CONJUNCTIVE_TEST, complex_test_struct::data, FALSE, cons_struct::first, make_test_from_complex_test(), NIL, cons_struct::rest, test_is_blank_test(), test_is_complex_test(), TRUE, and complex_test_struct::type.

Referenced by add_gensymmed_equality_test(), add_goal_or_impasse_tests(), add_hash_info_to_id_test(), add_new_test_to_test_if_not_already_there(), add_rete_test_list_to_tests(), add_varnames_to_test(), copy_test_removing_goal_impasse_tests(), parse_attr_value_tests(), parse_head_of_conds_for_one_id(), parse_test(), parse_value_test_star(), rl_add_goal_or_impasse_tests_to_conds(), and variablize_nots_and_insert_into_conditions().

                               {
  complex_test *ct = 0;
  cons *c;
  Bool already_a_conjunctive_test;

  if (test_is_blank_test(add_me)) return;

  if (test_is_blank_test(*t)) {
    *t = add_me;
    return;
  }

  /* --- if *t isn't already a conjunctive test, make it into one --- */
  already_a_conjunctive_test = FALSE;
  if (test_is_complex_test(*t)) {
    ct = complex_test_from_test (*t);
    if (ct->type==CONJUNCTIVE_TEST) already_a_conjunctive_test = TRUE;
  }

  if (! already_a_conjunctive_test)  {
    allocate_with_pool (thisAgent, &thisAgent->complex_test_pool, &ct);
    ct->type = CONJUNCTIVE_TEST;
    allocate_cons (thisAgent, &c);
    ct->data.conjunct_list = c;
    c->first = *t;
    c->rest = NIL;
    *t = make_test_from_complex_test (ct);
  }
  /* --- at this point, ct points to the complex test structure for *t --- */
    
  /* --- now add add_me to the conjunct list --- */
  allocate_cons (thisAgent, &c);
  c->first = add_me;
  c->rest = ct->data.conjunct_list;
  ct->data.conjunct_list = c;
}

void add_new_test_to_test_if_not_already_there	(	agent *	thisAgent,
		test *	t,
		test	add_me,
		bool	neg
	)

Definition at line 383 of file production.cpp.

References add_new_test_to_test(), complex_test_from_test(), complex_test_struct::test_info_union::conjunct_list, CONJUNCTIVE_TEST, complex_test_struct::data, deallocate_test(), cons_struct::first, NIL, cons_struct::rest, test_is_complex_test(), tests_are_equal(), and complex_test_struct::type.

Referenced by restore_saved_tests_to_test().

                                                                                                  {
  complex_test *ct;
  cons *c;

  if (tests_are_equal (*t, add_me, neg)) {
    deallocate_test (thisAgent, add_me);
    return;
  }

  if (test_is_complex_test (*t)) {
    ct = complex_test_from_test (*t);
    if (ct->type == CONJUNCTIVE_TEST)
      for (c=ct->data.conjunct_list; c!=NIL; c=c->rest)
        if (tests_are_equal (static_cast<char *>(c->first), add_me, neg)) {
          deallocate_test (thisAgent, add_me);
          return;
        }
  }

  add_new_test_to_test (thisAgent, t, add_me);
}

void add_symbol_to_tc	(	agent *	thisAgent,
		Symbol *	sym,
		tc_number	tc,
		::list **	id_list,
		::list **	var_list
	)

Bool canonical_cond_greater	(	condition *	c1,
		condition *	c2
	)

Definition at line 584 of file production.cpp.

References three_field_tests_struct::attr_test, CANONICAL_TEST_ORDER, condition_struct::data, FALSE, condition_struct::condition_main_data_union::tests, TRUE, uint32_t(), and three_field_tests_struct::value_test.

Referenced by reorder_simplified_conditions().

{
  uint32_t test_order_1,test_order_2;

  if ((test_order_1 = CANONICAL_TEST_ORDER(c1->data.tests.attr_test)) <
      (test_order_2 = CANONICAL_TEST_ORDER(c2->data.tests.attr_test))) {
    return TRUE;
  } else if (test_order_1 == test_order_2 &&
           CANONICAL_TEST_ORDER(c1->data.tests.value_test) <
           CANONICAL_TEST_ORDER(c2->data.tests.value_test)) {
    return TRUE;
  }
  return FALSE;
}

Bool cond_is_in_tc	(	agent *	thisAgent,
		condition *	cond,
		tc_number	tc
	)

Definition at line 1427 of file production.cpp.

References add_cond_to_tc(), condition_struct::already_in_tc, cond_is_in_tc(), CONJUNCTIVE_NEGATION_CONDITION, condition_struct::data, FALSE, three_field_tests_struct::id_test, condition_struct::condition_main_data_union::ncc, condition_struct::next, NIL, test_is_in_tc(), condition_struct::condition_main_data_union::tests, ncc_info_struct::top, TRUE, condition_struct::type, unmark_identifiers_and_free_list(), and unmark_variables_and_free_list().

Referenced by add_tc_through_lhs_and_rhs(), build_chunk_conds_for_grounds_and_add_negateds(), cond_is_in_tc(), and trace_grounded_potentials().

                                                                     {
  condition *c;
  Bool anything_changed;
  Bool result;
  list *new_ids, *new_vars;

  if (cond->type != CONJUNCTIVE_NEGATION_CONDITION)
    return test_is_in_tc (cond->data.tests.id_test, tc);
  
  /* --- conjunctive negations:  keep trying to add stuff to the TC --- */
  new_ids = NIL;
  new_vars = NIL;
  for (c=cond->data.ncc.top; c!=NIL; c=c->next)
    c->already_in_tc = FALSE;
  while (TRUE) {
    anything_changed = FALSE;
    for (c=cond->data.ncc.top; c!=NIL; c=c->next)
      if (! c->already_in_tc)
        if (cond_is_in_tc (thisAgent, c, tc)) {
          add_cond_to_tc (thisAgent, c, tc, &new_ids, &new_vars);
          c->already_in_tc = TRUE;
          anything_changed = TRUE;
        }
    if (! anything_changed) break;
  }

  /* --- complete TC found, look for anything that didn't get hit --- */
  result = TRUE;
  for (c=cond->data.ncc.top; c!=NIL; c=c->next)
    if (! c->already_in_tc) result = FALSE;
  
  /* --- unmark identifiers and variables that we just marked --- */
  unmark_identifiers_and_free_list (thisAgent, new_ids);
  unmark_variables_and_free_list (thisAgent, new_vars);

  return result;
}

Bool conditions_are_equal	(	condition *	c1,
		condition *	c2
	)

Definition at line 847 of file production.cpp.

References three_field_tests_struct::attr_test, conditions_are_equal(), CONJUNCTIVE_NEGATION_CONDITION, condition_struct::data, FALSE, three_field_tests_struct::id_test, condition_struct::condition_main_data_union::ncc, NEGATIVE_CONDITION, condition_struct::next, NIL, POSITIVE_CONDITION, condition_struct::test_for_acceptable_preference, condition_struct::condition_main_data_union::tests, tests_are_equal(), ncc_info_struct::top, TRUE, condition_struct::type, and three_field_tests_struct::value_test.

Referenced by add_to_chunk_cond_set(), conditions_are_equal(), and explain_find_cond().

                                                         {
  if (c1->type != c2->type) return FALSE;
  bool neg = true;
  switch (c1->type) {
  case POSITIVE_CONDITION:
   neg = false;
  case NEGATIVE_CONDITION:
    if (! tests_are_equal (c1->data.tests.id_test,
                           c2->data.tests.id_test, neg))
      return FALSE;
    if (! tests_are_equal (c1->data.tests.attr_test,
                           c2->data.tests.attr_test, neg))
      return FALSE;
    if (! tests_are_equal (c1->data.tests.value_test,
                           c2->data.tests.value_test, neg))
      return FALSE;
    if (c1->test_for_acceptable_preference !=
        c2->test_for_acceptable_preference)
      return FALSE;
    return TRUE;
    
  case CONJUNCTIVE_NEGATION_CONDITION:
    for (c1=c1->data.ncc.top, c2=c2->data.ncc.top;
         ((c1!=NIL)&&(c2!=NIL));
         c1=c1->next, c2=c2->next)
      if (! conditions_are_equal (c1,c2)) return FALSE;
    if (c1==c2) return TRUE;  /* make sure they both hit end-of-list */
    return FALSE;
  }
  return FALSE; /* unreachable, but without it, gcc -Wall warns here */
}

condition* copy_condition	(	agent *	thisAgent,
		condition *	cond
	)

Definition at line 794 of file production.cpp.

References three_field_tests_struct::attr_test, ncc_info_struct::bottom, condition_struct::bt, agent_struct::condition_pool, CONJUNCTIVE_NEGATION_CONDITION, copy_condition_list(), copy_test(), condition_struct::data, three_field_tests_struct::id_test, condition_struct::condition_main_data_union::ncc, NEGATIVE_CONDITION, NIL, POSITIVE_CONDITION, condition_struct::test_for_acceptable_preference, condition_struct::condition_main_data_union::tests, ncc_info_struct::top, condition_struct::type, and three_field_tests_struct::value_test.

Referenced by build_chunk_conds_for_grounds_and_add_negateds(), copy_condition_list(), copy_conds_from_list(), and explain_add_temp_to_backtrace_list().

                          {
  condition *New;

  if (!cond) return NIL;
  allocate_with_pool (thisAgent, &thisAgent->condition_pool, &New);
  New->type = cond->type;
  
  switch (cond->type) {
  case POSITIVE_CONDITION:
    New->bt = cond->bt;
    /* ... and fall through to next case */
  case NEGATIVE_CONDITION:
    New->data.tests.id_test = copy_test (thisAgent, cond->data.tests.id_test);
    New->data.tests.attr_test = copy_test (thisAgent, cond->data.tests.attr_test);
    New->data.tests.value_test = copy_test (thisAgent, cond->data.tests.value_test);
    New->test_for_acceptable_preference = cond->test_for_acceptable_preference;
    break;
  case CONJUNCTIVE_NEGATION_CONDITION:
    copy_condition_list (thisAgent, cond->data.ncc.top, &(New->data.ncc.top),
                         &(New->data.ncc.bottom));
    break;
  }
  return New;
}

void copy_condition_list	(	agent *	thisAgent,
		condition *	top_cond,
		condition **	dest_top,
		condition **	dest_bottom
	)

Definition at line 825 of file production.cpp.

References copy_condition(), condition_struct::next, NIL, and condition_struct::prev.

Referenced by chunk_instantiation(), copy_cond_list(), copy_condition(), and rl_build_template_instantiation().

                                                   {
  condition *New, *prev;

  prev = NIL;
  while (top_cond) {
    New = copy_condition (thisAgent, top_cond);
    if (prev) prev->next = New; else *dest_top = New;
    New->prev = prev;
    prev = New;
    top_cond = top_cond->next;
  }
  if (prev) prev->next = NIL; else *dest_top = NIL;
  *dest_bottom = prev;
}

test copy_of_equality_test_found_in_test	(	agent *	thisAgent,
		test	t
	)

Definition at line 739 of file production.cpp.

References abort_with_fatal_error(), BUFFER_MSG_SIZE, complex_test_from_test(), complex_test_struct::test_info_union::conjunct_list, CONJUNCTIVE_TEST, copy_test(), complex_test_struct::data, cons_struct::first, NIL, cons_struct::rest, test_is_blank_or_equality_test(), test_is_blank_test(), and complex_test_struct::type.

Referenced by fill_in_attr_tests(), fill_in_id_tests(), parse_conds_for_one_id(), parse_head_of_conds_for_one_id(), print_condition_list(), and xml_condition_list().

                                                                    {
  complex_test *ct;
  cons *c;
  char msg[BUFFER_MSG_SIZE];

  if (test_is_blank_test(t)) {
    strncpy (msg, "Internal error: can't find equality test in test\n", BUFFER_MSG_SIZE);
    msg[BUFFER_MSG_SIZE - 1] = 0; /* ensure null termination */
    abort_with_fatal_error(thisAgent, msg);
  }
  if (test_is_blank_or_equality_test(t)) return copy_test (thisAgent, t);
  ct = complex_test_from_test(t);
  if (ct->type==CONJUNCTIVE_TEST) {
    for (c=ct->data.conjunct_list; c!=NIL; c=c->rest)
      if ( (! test_is_blank_test (static_cast<test>(c->first))) &&
           (test_is_blank_or_equality_test (static_cast<test>(c->first))) )
        return copy_test (thisAgent, static_cast<char *>(c->first));
  }
  strncpy (msg, "Internal error: can't find equality test in test\n",BUFFER_MSG_SIZE);
  abort_with_fatal_error(thisAgent, msg);
  return 0; /* unreachable, but without it, gcc -Wall warns here */
}

rhs_value copy_rhs_value	(	agent *	thisAgent,
		rhs_value	rv
	)

Definition at line 954 of file production.cpp.

References allocate_cons(), copy_rhs_value(), cons_struct::first, funcall_list_to_rhs_value(), NIL, cons_struct::rest, rhs_value_is_funcall(), rhs_value_is_reteloc(), rhs_value_is_unboundvar(), rhs_value_to_funcall_list(), rhs_value_to_symbol(), and symbol_add_ref().

Referenced by copy_rhs_value(), parse_preferences(), and parse_preferences_soar8_non_operator().

                                                          {
  cons *c, *new_c, *prev_new_c;
  list *fl, *new_fl;

  if (rhs_value_is_reteloc(rv)) return rv;
  if (rhs_value_is_unboundvar(rv)) return rv;
  if (rhs_value_is_funcall(rv)) {
    fl = rhs_value_to_funcall_list(rv);
    allocate_cons (thisAgent, &new_fl);
    new_fl->first = fl->first;
    prev_new_c = new_fl;
    for (c=fl->rest; c!=NIL; c=c->rest) {
      allocate_cons (thisAgent, &new_c);
      new_c->first = copy_rhs_value (thisAgent, static_cast<char *>(c->first));
      prev_new_c->rest = new_c;
      prev_new_c = new_c;
    }
    prev_new_c->rest = NIL;
    return funcall_list_to_rhs_value (new_fl);
  } else {
    symbol_add_ref (rhs_value_to_symbol(rv));
    return rv;
  }
}

test copy_test	(	agent *	thisAgent,
		test	t
	)

Definition at line 188 of file production.cpp.

References complex_test_from_test(), agent_struct::complex_test_pool, complex_test_struct::test_info_union::conjunct_list, CONJUNCTIVE_TEST, copy_symbol_list_adding_references(), copy_test_list(), complex_test_struct::data, complex_test_struct::test_info_union::disjunction_list, DISJUNCTION_TEST, GOAL_ID_TEST, IMPASSE_ID_TEST, make_blank_test(), make_equality_test(), make_test_from_complex_test(), complex_test_struct::test_info_union::referent, referent_of_equality_test(), symbol_add_ref(), test_is_blank_or_equality_test(), test_is_blank_test(), and complex_test_struct::type.

Referenced by copy_condition(), copy_of_equality_test_found_in_test(), copy_test_list(), copy_test_removing_goal_impasse_tests(), fill_in_attr_tests(), fill_in_id_tests(), and parse_attr_value_tests().

                                          {
  Symbol *referent;
  complex_test *ct, *new_ct;
  
  if (test_is_blank_test(t))
    return make_blank_test();

  if (test_is_blank_or_equality_test(t)) {
    referent = referent_of_equality_test(t);
    return make_equality_test(referent);
  }
  
  ct = complex_test_from_test(t);
  
  allocate_with_pool (thisAgent, &thisAgent->complex_test_pool, &new_ct);
  new_ct->type = ct->type;
  switch(ct->type) {
  case GOAL_ID_TEST:
  case IMPASSE_ID_TEST:
    break;
  case DISJUNCTION_TEST:
    new_ct->data.disjunction_list =
      copy_symbol_list_adding_references (thisAgent, ct->data.disjunction_list);
    break;
  case CONJUNCTIVE_TEST:
    new_ct->data.conjunct_list = copy_test_list (thisAgent, ct->data.conjunct_list);
    break;
  default:  /* relational tests other than equality */
    new_ct->data.referent = ct->data.referent;
    symbol_add_ref (ct->data.referent);
    break;
  }
  return make_test_from_complex_test(new_ct);
}

test copy_test_removing_goal_impasse_tests	(	agent *	thisAgent,
		test	t,
		Bool *	removed_goal,
		Bool *	removed_impasse
	)

Definition at line 230 of file production.cpp.

References add_new_test_to_test(), complex_test_from_test(), complex_test_struct::test_info_union::conjunct_list, CONJUNCTIVE_TEST, copy_test(), copy_test_removing_goal_impasse_tests(), complex_test_struct::data, destructively_reverse_list(), cons_struct::first, GOAL_ID_TEST, IMPASSE_ID_TEST, make_blank_test(), NIL, cons_struct::rest, test_is_blank_or_equality_test(), test_is_blank_test(), test_is_complex_test(), TRUE, and complex_test_struct::type.

Referenced by copy_test_removing_goal_impasse_tests(), print_condition_list(), remove_isa_state_tests_for_non_roots(), and xml_condition_list().

                                                                   {
  complex_test *ct, *new_ct;
  cons *c;
  test new_t, temp;
  
  if (test_is_blank_or_equality_test(t)) return copy_test (thisAgent, t);
  
  ct = complex_test_from_test(t);
  
  switch(ct->type) {
  case GOAL_ID_TEST:
    *removed_goal = TRUE;
    return make_blank_test();
  case IMPASSE_ID_TEST:
    *removed_impasse = TRUE;
    return make_blank_test();

  case CONJUNCTIVE_TEST:
    new_t = make_blank_test();
    for (c=ct->data.conjunct_list; c!=NIL; c=c->rest) {
      temp = copy_test_removing_goal_impasse_tests (thisAgent, static_cast<char *>(c->first),
                                                    removed_goal,
                                                    removed_impasse);
      if (! test_is_blank_test(temp))
        add_new_test_to_test (thisAgent, &new_t, temp);
    }
    if (test_is_complex_test(new_t)) {
      new_ct = complex_test_from_test(new_t);
      if (new_ct->type==CONJUNCTIVE_TEST)
        new_ct->data.conjunct_list =
          destructively_reverse_list (new_ct->data.conjunct_list);
    }
    return new_t;

  default:  /* relational tests other than equality */
    return copy_test (thisAgent, t);
  }
}

void deallocate_action_list	(	agent *	thisAgent,
		action *	actions
	)

Definition at line 983 of file production.cpp.

References agent_struct::action_pool, action_struct::attr, deallocate_rhs_value(), FUNCALL_ACTION, action_struct::id, action_struct::next, preference_is_binary(), action_struct::preference_type, action_struct::referent, action_struct::type, and action_struct::value.

Referenced by chunk_instantiation(), deallocate_production(), free_explain_chunk(), parse_attr_value_make(), parse_preferences(), parse_preferences_soar8_non_operator(), parse_production(), parse_rhs(), parse_rhs_action(), and print_production().

                                                                {
  action *a;
  
  while (actions) {
    a = actions;
    actions = actions->next;
    if (a->type==FUNCALL_ACTION) {
      deallocate_rhs_value (thisAgent, a->value);
    } else {
      /* --- make actions --- */
      deallocate_rhs_value (thisAgent, a->id);
      deallocate_rhs_value (thisAgent, a->attr);
      deallocate_rhs_value (thisAgent, a->value);
      if (preference_is_binary(a->preference_type))
        deallocate_rhs_value (thisAgent, a->referent);
    }
    free_with_pool (&thisAgent->action_pool,a);
  }
}

void deallocate_condition_list	(	agent *	thisAgent,
		condition *	cond_list
	)

Definition at line 772 of file production.cpp.

References three_field_tests_struct::attr_test, agent_struct::condition_pool, CONJUNCTIVE_NEGATION_CONDITION, condition_struct::data, deallocate_condition_list(), three_field_tests_struct::id_test, condition_struct::condition_main_data_union::ncc, condition_struct::next, quickly_deallocate_test(), condition_struct::condition_main_data_union::tests, ncc_info_struct::top, condition_struct::type, and three_field_tests_struct::value_test.

Referenced by chunk_instantiation(), deallocate_condition_list(), deallocate_instantiation(), deallocate_production(), free_backtrace_list(), free_explain_chunk(), parse_attr_value_tests(), parse_cond(), parse_cond_plus(), parse_production(), parse_tail_of_conds_for_one_id(), parse_value_test_star(), print_partial_match_information(), print_production(), rl_build_template_instantiation(), and xml_partial_match_information().

                              {
  condition *c;
  
  while (cond_list) {
    c = cond_list;
    cond_list = cond_list->next;
    if (c->type==CONJUNCTIVE_NEGATION_CONDITION) {
      deallocate_condition_list (thisAgent, c->data.ncc.top);
    } else { /* positive and negative conditions */
      quickly_deallocate_test (thisAgent, c->data.tests.id_test);
      quickly_deallocate_test (thisAgent, c->data.tests.attr_test);
      quickly_deallocate_test (thisAgent, c->data.tests.value_test);
    }
    free_with_pool (&thisAgent->condition_pool, c);
  }
}

void deallocate_list_of_nots	(	agent *	thisAgent,
		not_struct *	nots
	)

Definition at line 1024 of file production.cpp.

References not_struct::next, agent_struct::not_pool, not_struct::s1, not_struct::s2, and symbol_remove_ref().

Referenced by deallocate_instantiation().

                           {
  not_struct *temp;

  while (nots) {
    temp = nots;
    nots = nots->next;
    symbol_remove_ref (thisAgent, temp->s1);
    symbol_remove_ref (thisAgent, temp->s2);
    free_with_pool (&thisAgent->not_pool, temp);
  }
}

void deallocate_production	(	agent *	thisAgent,
		production *	prod
	)

Definition at line 1653 of file production.cpp.

References abort_with_fatal_error(), production_struct::action_list, BUFFER_MSG_SIZE, deallocate_action_list(), deallocate_condition_list(), deallocate_symbol_list_removing_references(), production_struct::documentation, production_struct::filename, free_memory_block_for_string(), production_struct::instantiations, production_struct::name, agent_struct::production_pool, production_struct::rhs_unbound_variables, production_struct::rl_template_conds, production_struct::rl_template_instantiations, and symbol_remove_ref().

Referenced by production_remove_ref().

                                                                {
  if (prod->instantiations) {
    char msg[BUFFER_MSG_SIZE];
    strncpy (msg, "Internal error: deallocating prod. that still has inst's\n", BUFFER_MSG_SIZE);
    msg[BUFFER_MSG_SIZE - 1] = 0; /* ensure null termination */
    abort_with_fatal_error(thisAgent, msg);
  }
  deallocate_action_list (thisAgent, prod->action_list);
  /* RBD 3/28/95 the following line used to use free_list(), leaked memory */
  deallocate_symbol_list_removing_references (thisAgent, prod->rhs_unbound_variables);
  symbol_remove_ref (thisAgent, prod->name);
  if (prod->documentation) free_memory_block_for_string (thisAgent, prod->documentation);
  /* next line, kjh CUSP(B11) */
  if (prod->filename) free_memory_block_for_string (thisAgent, prod->filename); 

  if (prod->rl_template_conds) deallocate_condition_list(thisAgent,prod->rl_template_conds);
  if (prod->rl_template_instantiations) delete prod->rl_template_instantiations;

  free_with_pool (&thisAgent->production_pool, prod);
}

void deallocate_rhs_value	(	agent *	thisAgent,
		rhs_value	rv
	)

Definition at line 934 of file production.cpp.

References deallocate_rhs_value(), cons_struct::first, free_list(), NIL, cons_struct::rest, rhs_value_is_funcall(), rhs_value_is_reteloc(), rhs_value_is_unboundvar(), rhs_value_to_funcall_list(), rhs_value_to_symbol(), and symbol_remove_ref().

Referenced by deallocate_action_list(), deallocate_rhs_value(), parse_attr_value_make(), and parse_function_call_after_lparen().

                                                           {
  cons *c;
  list *fl;

  if (rhs_value_is_reteloc(rv)) return;
  if (rhs_value_is_unboundvar(rv)) return;
  if (rhs_value_is_funcall(rv)) {
    fl = rhs_value_to_funcall_list(rv);
    for (c=fl->rest; c!=NIL; c=c->rest)
      deallocate_rhs_value (thisAgent, static_cast<char *>(c->first));
    free_list (thisAgent, fl);
  } else {
    symbol_remove_ref (thisAgent, rhs_value_to_symbol(rv));
  }
}

void deallocate_symbol_list_removing_references	(	agent *	thisAgent,
		::list *	sym_list
	)

void deallocate_test	(	agent *	thisAgent,
		test	t
	)

Definition at line 275 of file production.cpp.

References complex_test_from_test(), agent_struct::complex_test_pool, complex_test_struct::test_info_union::conjunct_list, CONJUNCTIVE_TEST, complex_test_struct::data, deallocate_symbol_list_removing_references(), deallocate_test(), complex_test_struct::test_info_union::disjunction_list, DISJUNCTION_TEST, cons_struct::first, free_cons(), GOAL_ID_TEST, IMPASSE_ID_TEST, complex_test_struct::test_info_union::referent, referent_of_equality_test(), cons_struct::rest, symbol_remove_ref(), test_is_blank_or_equality_test(), test_is_blank_test(), and complex_test_struct::type.

Referenced by add_new_test_to_test_if_not_already_there(), deallocate_test(), fill_in_attr_tests(), fill_in_id_tests(), parse_attr_value_tests(), parse_conds_for_one_id(), parse_disjunction_test(), parse_head_of_conds_for_one_id(), parse_test(), print_condition_list(), quickly_deallocate_test(), remove_isa_state_tests_for_non_roots(), and xml_condition_list().

                                                {
  cons *c, *next_c;
  complex_test *ct;

  if (test_is_blank_test(t)) return;
  if (test_is_blank_or_equality_test(t)) {
    symbol_remove_ref (thisAgent, referent_of_equality_test(t));
    return;
  }

  ct = complex_test_from_test(t);
  
  switch (ct->type) {
  case GOAL_ID_TEST:
  case IMPASSE_ID_TEST:
    break;
  case DISJUNCTION_TEST:
    deallocate_symbol_list_removing_references (thisAgent, ct->data.disjunction_list);
    break;
  case CONJUNCTIVE_TEST:
    c = ct->data.conjunct_list;
    while (c) {
      next_c = c->rest;
      deallocate_test (thisAgent, static_cast<char *>(c->first));
      free_cons (thisAgent, c);
      c = next_c;
    }
    break;
  default: /* relational tests other than equality */
    symbol_remove_ref (thisAgent, ct->data.referent);
    break;
  }
  free_with_pool (&thisAgent->complex_test_pool, ct);
}

void excise_all_productions	(	agent *	thisAgent,
		Bool	print_sharp_sign
	)

Definition at line 1705 of file production.cpp.

References excise_all_productions_of_type(), NUM_PRODUCTION_TYPES, agent_struct::sysparams, and TRACE_LOADING_SYSPARAM.

Referenced by destroy_soar_agent(), and load_rete_net().

                                                   {

  // Excise all the productions of the four different types
  for (int i=0; i < NUM_PRODUCTION_TYPES; i++) {
    excise_all_productions_of_type(thisAgent, 
                                   static_cast<byte>(i), 
                                   print_sharp_sign&&thisAgent->sysparams[TRACE_LOADING_SYSPARAM]);
  }
}

void excise_all_productions_of_type	(	agent *	thisAgent,
		byte	type,
		Bool	print_sharp_sign
	)

Definition at line 1693 of file production.cpp.

References agent_struct::all_productions_of_type, excise_production(), agent_struct::sysparams, and TRACE_LOADING_SYSPARAM.

Referenced by excise_all_productions().

                                                           {

  // Iterating through the productions of the appropriate type and excising them
  while (thisAgent->all_productions_of_type[type]) {
    excise_production (thisAgent, 
                       thisAgent->all_productions_of_type[type],
                       print_sharp_sign&&thisAgent->sysparams[TRACE_LOADING_SYSPARAM]);
  }
}

void excise_production	(	agent *	thisAgent,
		production *	prod,
		Bool	print_sharp_sign
	)

Definition at line 1674 of file production.cpp.

References agent_struct::all_productions_of_type, rl_param_container::apoptosis, rl_param_container::apoptosis_none, CHUNK_PRODUCTION_TYPE, excise_production_from_rete(), soar_module::constant_param< T >::get_value(), production_struct::name, NIL, agent_struct::num_productions_of_type, production_struct::p_node, print(), sym_constant_struct::production, production_remove_ref(), remove_from_dll, soar_module::object_memory< T, N >::remove_object(), remove_pwatch(), agent_struct::rl_params, agent_struct::rl_prods, rl_remove_refs_for_prod(), production_struct::rl_rule, symbol_union::sc, production_struct::trace_firings, and production_struct::type.

Referenced by chunk_instantiation(), do_one_top_level_phase(), excise_all_productions_of_type(), parse_production(), retract_instantiation(), and rl_build_template_instantiation().

                                                                                   {
  if (prod->trace_firings) remove_pwatch (thisAgent, prod);
  remove_from_dll (thisAgent->all_productions_of_type[prod->type], prod, next, prev);

  // Remove reference from apoptosis object store
  if ( ( prod->type == CHUNK_PRODUCTION_TYPE ) && ( thisAgent->rl_params ) && ( thisAgent->rl_params->apoptosis->get_value() != rl_param_container::apoptosis_none ) )
    thisAgent->rl_prods->remove_object( prod );

  // Remove RL-related pointers to this production
  if ( prod->rl_rule ) 
    rl_remove_refs_for_prod( thisAgent, prod ); 

  thisAgent->num_productions_of_type[prod->type]--;
  if (print_sharp_sign) print (thisAgent, "#");
  if (prod->p_node) excise_production_from_rete (thisAgent, prod);
  prod->name->sc.production = NIL;
  production_remove_ref (thisAgent, prod);
}

char first_letter_from_rhs_value

(

rhs_value

rv

)

Definition at line 1008 of file production.cpp.

References first_letter_from_symbol(), rhs_value_is_symbol(), and rhs_value_to_symbol().

Referenced by copy_action_list_and_substitute_varnames(), and parse_attr_value_make().

                                                {
  if (rhs_value_is_symbol(rv))
    return first_letter_from_symbol (rhs_value_to_symbol(rv));
  return '*'; /* function calls, reteloc's, unbound variables */
}

char first_letter_from_symbol

(

Symbol *

sym

)

Definition at line 86 of file production.cpp.

References symbol_union::id, IDENTIFIER_SYMBOL_TYPE, sym_constant_struct::name, variable_struct::name, identifier_struct::name_letter, symbol_union::sc, SYM_CONSTANT_SYMBOL_TYPE, symbol_union::var, and VARIABLE_SYMBOL_TYPE.

Referenced by execute_action(), first_letter_from_rhs_value(), first_letter_from_test(), and rl_build_template_instantiation().

                                            {
  switch (sym->common.symbol_type) {
  case VARIABLE_SYMBOL_TYPE: return *(sym->var.name + 1);
  case IDENTIFIER_SYMBOL_TYPE: return sym->id.name_letter;
  case SYM_CONSTANT_SYMBOL_TYPE: return *(sym->sc.name);
  default: return '*';
  }
}

char first_letter_from_test

(

test

t

)

Definition at line 100 of file production.cpp.

References complex_test_from_test(), complex_test_struct::test_info_union::conjunct_list, CONJUNCTIVE_TEST, complex_test_struct::data, cons_struct::first, first_letter_from_symbol(), first_letter_from_test(), GOAL_ID_TEST, IMPASSE_ID_TEST, NIL, referent_of_equality_test(), cons_struct::rest, test_is_blank_or_equality_test(), test_is_blank_test(), and complex_test_struct::type.

Referenced by add_rete_test_list_to_tests(), first_letter_from_test(), parse_attr_value_tests(), and rete_node_to_conditions().

                                     {
  complex_test *ct;
  cons *c;
  char ch;
  
  if (test_is_blank_test (t)) return '*';
  if (test_is_blank_or_equality_test (t))
    return first_letter_from_symbol (referent_of_equality_test(t));

  ct = complex_test_from_test (t);
  switch(ct->type) {
  case GOAL_ID_TEST: return 's';
  case IMPASSE_ID_TEST: return 'i';
  case CONJUNCTIVE_TEST:
    for (c=ct->data.conjunct_list; c!=NIL; c=c->rest) {
      ch = first_letter_from_test (static_cast<char *>(c->first));
      if (ch != '*') return ch;
    }
    return '*';
  default:  /* disjunction tests, and relational tests other than equality */
    return '*';
  }
}

Symbol* generate_new_variable	(	agent *	thisAgent,
		const char *	prefix
	)

Definition at line 1515 of file production.cpp.

References variable_struct::current_binding_value, agent_struct::current_variable_gensym_number, GENERATE_NEW_VARIABLE_BUFFER_SIZE, variable_struct::gensym_number, agent_struct::gensymed_variable_count, make_variable(), NIL, symbol_remove_ref(), TRUE, and symbol_union::var.

Referenced by add_gensymmed_equality_test(), copy_rhs_value_and_substitute_varnames(), simplify_test(), substitute_for_placeholders_in_symbol(), and variablize_symbol().

                                                                     {
#define GENERATE_NEW_VARIABLE_BUFFER_SIZE 200 /* that ought to be long enough! */
  char name[GENERATE_NEW_VARIABLE_BUFFER_SIZE];
  Symbol *New;
  char first_letter;

  first_letter = *prefix;
  if (isalpha(first_letter)) {
    if (isupper(first_letter)) first_letter = static_cast<char>(tolower(first_letter));
  } else {
    first_letter = 'v';
  }

  while (TRUE) {
    SNPRINTF (name,GENERATE_NEW_VARIABLE_BUFFER_SIZE, "<%s%lu>", prefix,
             static_cast<long unsigned int>(thisAgent->gensymed_variable_count[first_letter-'a']++));
 name[GENERATE_NEW_VARIABLE_BUFFER_SIZE - 1] = 0; /* ensure null termination */

    New = make_variable (thisAgent, name);
    if (New->var.gensym_number != thisAgent->current_variable_gensym_number) break;
    symbol_remove_ref (thisAgent, New);
  }
  
  New->var.current_binding_value = NIL;
  New->var.gensym_number = thisAgent->current_variable_gensym_number;
  return New;
}

tc_number get_new_tc_number

(

agent *

thisAgent

)

Definition at line 1059 of file production.cpp.

References agent_struct::current_tc_number, and reset_id_and_variable_tc_numbers().

Referenced by add_goal_or_impasse_tests(), add_production_to_rete(), backtrace_through_instantiation(), begin_os_tc(), calculate_compile_time_o_support(), chunk_instantiation(), do_demotion(), dougs_calculate_support_for_instantiation_preferences(), epmem_build_dnf(), epmem_new_episode(), epmem_process_query(), epmem_respond_to_cmd(), find_compile_time_match_goal(), find_known_goals(), find_thing_off_goal(), get_results_for_instantiation(), make_production(), print_object_trace(), print_object_trace_using_provided_format_string(), print_stack_trace(), reorder_lhs(), reset_variable_generator(), rl_add_goal_or_impasse_tests_to_conds(), rl_build_template_instantiation(), smem_respond_to_cmd(), smem_soar_store(), and trace_grounded_potentials().

                                               {
  /* This was originally a global variable. For the present I'll move it here, 
     but it probably belongs in kernel_struct. */

  thisAgent->current_tc_number++;
  if (thisAgent->current_tc_number==0) {
    reset_id_and_variable_tc_numbers (thisAgent);
    thisAgent->current_tc_number = 1;
  }
  return thisAgent->current_tc_number;
}

uint32_t hash_condition	(	agent *	thisAgent,
		condition *	cond
	)

Definition at line 883 of file production.cpp.

References abort_with_fatal_error(), three_field_tests_struct::attr_test, BUFFER_MSG_SIZE, CONJUNCTIVE_NEGATION_CONDITION, condition_struct::data, hash_condition(), hash_test(), three_field_tests_struct::id_test, condition_struct::condition_main_data_union::ncc, NEGATIVE_CONDITION, condition_struct::next, NIL, POSITIVE_CONDITION, condition_struct::test_for_acceptable_preference, condition_struct::condition_main_data_union::tests, ncc_info_struct::top, condition_struct::type, uint32_t(), and three_field_tests_struct::value_test.

Referenced by hash_condition(), and make_chunk_cond_for_condition().

                          {
  uint32_t result;
  condition *c;

  switch (cond->type) {
  case POSITIVE_CONDITION:
    result = hash_test (thisAgent, cond->data.tests.id_test);
    result = (result << 24) | (result >>  8);
    result ^= hash_test (thisAgent, cond->data.tests.attr_test);
    result = (result << 24) | (result >>  8);
    result ^= hash_test (thisAgent, cond->data.tests.value_test);
    if (cond->test_for_acceptable_preference) result++;
    break;
  case NEGATIVE_CONDITION:
    result = 1267818;
    result ^= hash_test (thisAgent, cond->data.tests.id_test);
    result = (result << 24) | (result >>  8);
    result ^= hash_test (thisAgent, cond->data.tests.attr_test);
    result = (result << 24) | (result >>  8);
    result ^= hash_test (thisAgent, cond->data.tests.value_test);
    if (cond->test_for_acceptable_preference) result++;
    break;
  case CONJUNCTIVE_NEGATION_CONDITION:
    result = 82348149;
    for (c=cond->data.ncc.top; c!=NIL; c=c->next) {
      result ^= hash_condition (thisAgent, c);
      result = (result << 24) | (result >>  8);
    }
    break;
  default:
    { char msg[BUFFER_MSG_SIZE];
    strncpy (msg, "Internal error: bad cond type in hash_condition\n", BUFFER_MSG_SIZE);
    msg[BUFFER_MSG_SIZE - 1] = 0; /* ensure null termination */
    abort_with_fatal_error(thisAgent, msg);
    }
    result = 0; /* unreachable, but gcc -Wall warns without it */
  }
  return result;
}

uint32_t hash_test	(	agent *	thisAgent,
		test	t
	)

Definition at line 502 of file production.cpp.

References abort_with_fatal_error(), BUFFER_MSG_SIZE, common, complex_test_from_test(), complex_test_struct::test_info_union::conjunct_list, CONJUNCTIVE_TEST, complex_test_struct::data, DISJUNCTION_TEST, cons_struct::first, GOAL_ID_TEST, GREATER_OR_EQUAL_TEST, GREATER_TEST, IMPASSE_ID_TEST, LESS_OR_EQUAL_TEST, LESS_TEST, NIL, NOT_EQUAL_TEST, complex_test_struct::test_info_union::referent, referent_of_equality_test(), cons_struct::rest, SAME_TYPE_TEST, test_is_blank_or_equality_test(), test_is_blank_test(), complex_test_struct::type, and uint32_t().

Referenced by hash_condition().

                                              {
  complex_test *ct;
  cons *c;
  uint32_t result;
  
  if (test_is_blank_test(t))
    return 0;

  if (test_is_blank_or_equality_test(t))
    return referent_of_equality_test(t)->common.hash_id;

  ct = complex_test_from_test(t);

  switch (ct->type) {
  case GOAL_ID_TEST: return 34894895;  /* just use some unusual number */
  case IMPASSE_ID_TEST: return 2089521;
  case DISJUNCTION_TEST:
    result = 7245;
    for (c=ct->data.conjunct_list; c!=NIL; c=c->rest)
      result = result + static_cast<Symbol *>(c->first)->common.hash_id;
    return result;
  case CONJUNCTIVE_TEST:
    result = 100276;
 // bug 510: conjunctive tests' order needs to be ignored
    //for (c=ct->data.disjunction_list; c!=NIL; c=c->rest)
    //  result = result + hash_test (thisAgent, static_cast<char *>(c->first));
    return result;
  case NOT_EQUAL_TEST:
  case LESS_TEST:
  case GREATER_TEST:
  case LESS_OR_EQUAL_TEST:
  case GREATER_OR_EQUAL_TEST:
  case SAME_TYPE_TEST:
    return (ct->type << 24) + ct->data.referent->common.hash_id;
  default:
    { char msg[BUFFER_MSG_SIZE];
    strncpy (msg, "production.c: Error: bad test type in hash_test\n", BUFFER_MSG_SIZE);
    msg[BUFFER_MSG_SIZE - 1] = 0; /* ensure null termination */
    abort_with_fatal_error(thisAgent, msg);
    }
  }
  return 0; /* unreachable, but without it, gcc -Wall warns here */
}

void init_production_utilities

(

agent *

thisAgent

)

Definition at line 53 of file production.cpp.

References agent_struct::action_pool, agent_struct::complex_test_pool, agent_struct::condition_pool, init_memory_pool(), init_reorderer(), agent_struct::not_pool, and agent_struct::production_pool.

Referenced by init_soar_agent().

                                                  {
  init_memory_pool (thisAgent, &thisAgent->complex_test_pool, sizeof(complex_test), "complex test");
  init_memory_pool (thisAgent, &thisAgent->condition_pool, sizeof(condition), "condition");
  init_memory_pool (thisAgent, &thisAgent->production_pool, sizeof(production), "production");
  init_memory_pool (thisAgent, &thisAgent->action_pool, sizeof(action), "action");
  init_memory_pool (thisAgent, &thisAgent->not_pool, sizeof(not_struct), "not");
  init_reorderer(thisAgent);
}

production* make_production	(	agent *	thisAgent,
		byte	type,
		Symbol *	name,
		condition **	lhs_top,
		condition **	lhs_bottom,
		action **	rhs_top,
		Bool	reorder_nccs
	)

Definition at line 1562 of file production.cpp.

References production_struct::action_list, add_bound_variables_in_condition_list(), agent_struct::all_productions_of_type, calculate_compile_time_o_support(), production_struct::declared_support, production_struct::documentation, FALSE, production_struct::filename, production_struct::firing_count, get_new_tc_number(), get_number_from_symbol(), insert_at_head_of_dll, production_struct::instantiations, production_struct::interrupt, JUSTIFICATION_PRODUCTION_TYPE, MAKE_ACTION, production_struct::name, sym_constant_struct::name, agent_struct::name_of_production_being_reordered, action_struct::next, NIL, agent_struct::num_productions_of_type, production_struct::p_node, print(), print_with_symbols(), sym_constant_struct::production, agent_struct::production_pool, production_struct::reference_count, action_struct::referent, reorder_action_list(), reorder_lhs(), reset_variable_generator(), production_struct::rhs_unbound_variables, rhs_value_to_symbol(), production_struct::rl_delta_bar_delta_beta, production_struct::rl_delta_bar_delta_h, production_struct::rl_ecr, production_struct::rl_efr, production_struct::rl_ref_count, production_struct::rl_rule, production_struct::rl_template_conds, production_struct::rl_template_instantiations, production_struct::rl_update_count, rl_update_template_tracking(), rl_valid_rule(), symbol_union::sc, smem_valid_production(), action_struct::support, TEMPLATE_PRODUCTION_TYPE, production_struct::trace_firings, production_struct::type, action_struct::type, UNDECLARED_SUPPORT, and UNKNOWN_SUPPORT.

Referenced by chunk_instantiation(), parse_production(), and rl_build_template_instantiation().

                                                {
  production *p;
  tc_number tc;
  action *a;


  thisAgent->name_of_production_being_reordered = name->sc.name;

  if (type!=JUSTIFICATION_PRODUCTION_TYPE) {
    reset_variable_generator (thisAgent, *lhs_top, *rhs_top);
    tc = get_new_tc_number(thisAgent);
    add_bound_variables_in_condition_list (thisAgent, *lhs_top, tc, NIL);
    if (! reorder_action_list (thisAgent, rhs_top, tc)) return NIL;
    if (! reorder_lhs (thisAgent, lhs_top, lhs_bottom, reorder_nccs)) return NIL;

 if ( !smem_valid_production( *lhs_top, *rhs_top ) ) 
 {
  print( thisAgent, "ungrounded LTI in production\n" );
  return NIL;
 }
    
#ifdef DO_COMPILE_TIME_O_SUPPORT_CALCS
    calculate_compile_time_o_support (*lhs_top, *rhs_top);
#ifdef LIST_COMPILE_TIME_O_SUPPORT_FAILURES
    for (a = *rhs_top; a!=NIL; a=a->next)
      if ((a->type==MAKE_ACTION) && (a->support==UNKNOWN_SUPPORT)) break;
    if (a) print_with_symbols (thisAgent, "\nCan't classify %y\n", name);
#endif
#else
    for (a = *rhs_top; a!=NIL; a=a->next) a->support = UNKNOWN_SUPPORT;
#endif
  } else {
    /* --- for justifications --- */
    /* force run-time o-support (it'll only be done once) */
    for (a = *rhs_top; a!=NIL; a=a->next) a->support = UNKNOWN_SUPPORT;
  }

  allocate_with_pool (thisAgent, &thisAgent->production_pool, &p);
  p->name = name;
  if (name->sc.production) {
    print (thisAgent, "Internal error: make_production called with name %s\n",
           thisAgent->name_of_production_being_reordered);
    print (thisAgent, "for which a production already exists\n");
  }
  name->sc.production = p;
  p->documentation = NIL;
  p->filename = NIL;   
  p->firing_count = 0;
  p->reference_count = 1;
  insert_at_head_of_dll (thisAgent->all_productions_of_type[type], p, next, prev);
  thisAgent->num_productions_of_type[type]++;
  p->type = type;
  p->declared_support = UNDECLARED_SUPPORT;
  p->trace_firings = FALSE;
  p->p_node = NIL;               /* it's not in the Rete yet */
  p->action_list = *rhs_top;
  p->rhs_unbound_variables = NIL; /* the Rete fills this in */
  p->instantiations = NIL;
  p->interrupt = FALSE;
  
  // Soar-RL stuff
  p->rl_update_count = 0.0;
  p->rl_delta_bar_delta_beta = -3.0;
  p->rl_delta_bar_delta_h = 0.0;
  p->rl_rule = false;
  p->rl_update_count = 0;
  p->rl_ref_count = 0;
  p->rl_ecr = 0.0;
  p->rl_efr = 0.0;
  if ( ( type != JUSTIFICATION_PRODUCTION_TYPE ) && ( type != TEMPLATE_PRODUCTION_TYPE ) )  
  {
    p->rl_rule = rl_valid_rule( p );
 if ( p->rl_rule )
 {
   p->rl_efr = get_number_from_symbol( rhs_value_to_symbol( p->action_list->referent ) );
 }
  }
  p->rl_template_conds = NIL;
  p->rl_template_instantiations = NIL;
  
  rl_update_template_tracking( thisAgent, name->sc.name );
  
  return p;
}

void production_add_ref ( production *  p )

inline

Definition at line 398 of file production.h.

Referenced by fill_in_new_instantiation_stuff().

{
  (p)->reference_count++;
}

void production_remove_ref ( agent *  thisAgent, production *  p  )

inline

Definition at line 403 of file production.h.

References deallocate_production().

Referenced by deallocate_instantiation(), and excise_production().

{
  (p)->reference_count--;
  if ((p)->reference_count == 0)
    deallocate_production(thisAgent, p);
}

void reset_variable_generator	(	agent *	thisAgent,
		condition *	conds_with_vars_to_avoid,
		action *	actions_with_vars_to_avoid
	)

Definition at line 1489 of file production.cpp.

References add_all_variables_in_action_list(), add_all_variables_in_condition_list(), agent_struct::current_variable_gensym_number, cons_struct::first, free_list(), agent_struct::gensymed_variable_count, get_new_tc_number(), NIL, reset_variable_gensym_numbers(), and cons_struct::rest.

Referenced by chunk_instantiation(), make_production(), p_node_to_conditions_and_nots(), parse_production(), and rl_build_template_instantiation().

                                                                   {
  tc_number tc;
  list *var_list;
  cons *c;
  int i;

  /* --- reset counts, and increment the gensym number --- */
  for (i=0; i<26; i++) thisAgent->gensymed_variable_count[i] = 1;
  thisAgent->current_variable_gensym_number++;
  if (thisAgent->current_variable_gensym_number==0) {
    reset_variable_gensym_numbers (thisAgent);
    thisAgent->current_variable_gensym_number = 1;
  }

  /* --- mark all variables in the given conds and actions --- */
  tc = get_new_tc_number(thisAgent);
  var_list = NIL;
  add_all_variables_in_condition_list (thisAgent, conds_with_vars_to_avoid,tc, &var_list);
  add_all_variables_in_action_list (thisAgent, actions_with_vars_to_avoid, tc, &var_list);
  for (c=var_list; c!=NIL; c=c->rest)
    static_cast<Symbol *>(c->first)->var.gensym_number = thisAgent->current_variable_gensym_number;
  free_list (thisAgent, var_list);
}

Bool test_includes_equality_test_for_symbol	(	test	t,
		Symbol *	sym
	)

Definition at line 687 of file production.cpp.

References complex_test_from_test(), complex_test_struct::test_info_union::conjunct_list, CONJUNCTIVE_TEST, complex_test_struct::data, FALSE, cons_struct::first, NIL, referent_of_equality_test(), cons_struct::rest, test_includes_equality_test_for_symbol(), test_is_blank_or_equality_test(), test_is_blank_test(), TRUE, and complex_test_struct::type.

Referenced by add_rete_test_list_to_tests(), collect_root_variables(), condition_list_has_id_test_for_sym(), id_or_value_of_condition_list_is_in_os_tc(), match_state_tests_non_operator_slot(), parse_attr_value_tests(), parse_head_of_conds_for_one_id(), parse_value_test_star(), restore_saved_tests_to_test(), rete_node_to_conditions(), test_includes_equality_test_for_symbol(), and variablize_nots_and_insert_into_conditions().

                                                                  {
  cons *c;
  complex_test *ct;

  if (test_is_blank_test(t)) return FALSE;
  
  if (test_is_blank_or_equality_test(t)) {
    if (sym) return (referent_of_equality_test(t) == sym);
    return TRUE;
  }
  
  ct = complex_test_from_test(t);

  if (ct->type==CONJUNCTIVE_TEST) {
    for (c=ct->data.conjunct_list; c!=NIL; c=c->rest)
      if (test_includes_equality_test_for_symbol (static_cast<char *>(c->first), sym)) return TRUE;
  }
  return FALSE;
}

Bool test_includes_goal_or_impasse_id_test	(	test	t,
		Bool	look_for_goal,
		Bool	look_for_impasse
	)

Definition at line 712 of file production.cpp.

References complex_test_from_test(), complex_test_struct::test_info_union::conjunct_list, CONJUNCTIVE_TEST, complex_test_struct::data, FALSE, cons_struct::first, GOAL_ID_TEST, IMPASSE_ID_TEST, NIL, cons_struct::rest, test_includes_goal_or_impasse_id_test(), test_is_blank_or_equality_test(), TRUE, and complex_test_struct::type.

Referenced by collect_root_variables(), find_known_goals(), remove_isa_state_tests_for_non_roots(), reorder_lhs(), and test_includes_goal_or_impasse_id_test().

                                                                   {
  complex_test *ct;
  cons *c;
  
  if (test_is_blank_or_equality_test(t)) return FALSE;
  ct = complex_test_from_test(t);
  if (look_for_goal && (ct->type==GOAL_ID_TEST)) return TRUE;
  if (look_for_impasse && (ct->type==IMPASSE_ID_TEST)) return TRUE;
  if (ct->type == CONJUNCTIVE_TEST) {
    for (c=ct->data.conjunct_list; c!=NIL; c=c->rest)
      if (test_includes_goal_or_impasse_id_test (static_cast<char *>(c->first),
                                                 look_for_goal,
                                                 look_for_impasse))
        return TRUE;
    return FALSE;
  }
  return FALSE;
}

Bool tests_are_equal	(	test	t1,
		test	t2,
		bool	neg
	)

Definition at line 411 of file production.cpp.

References variable_struct::common_symbol_info, complex_test_from_test(), complex_test_struct::test_info_union::conjunct_list, CONJUNCTIVE_TEST, complex_test_struct::data, complex_test_struct::test_info_union::disjunction_list, DISJUNCTION_TEST, FALSE, cons_struct::first, GOAL_ID_TEST, IMPASSE_ID_TEST, NIL, complex_test_struct::test_info_union::referent, referent_of_equality_test(), cons_struct::rest, symbol_common_data_struct::symbol_type, test_is_blank_or_equality_test(), tests_are_equal(), TRUE, complex_test_struct::type, symbol_union::var, and VARIABLE_SYMBOL_TYPE.

Referenced by add_new_test_to_test_if_not_already_there(), conditions_are_equal(), pick_conds_with_matching_id_test(), tests_are_equal(), and xml_pick_conds_with_matching_id_test().

                                                  {
 cons *c1, *c2;
 complex_test *ct1, *ct2;

 if (test_is_blank_or_equality_test(t1))
 {
  if (!test_is_blank_or_equality_test(t2))
   return FALSE;

  if (t1 == t2) /* Warning: this relies on the representation of tests */
   return TRUE; 
  
  if (!neg)
   return FALSE;

  // ignore variables in negation tests
  Symbol* s1 = referent_of_equality_test(t1);
  Symbol* s2 = referent_of_equality_test(t2);

  if ((s1->var.common_symbol_info.symbol_type == VARIABLE_SYMBOL_TYPE) && (s2->var.common_symbol_info.symbol_type == VARIABLE_SYMBOL_TYPE))
  {
   return TRUE;
  }
  return FALSE;
 }

 ct1 = complex_test_from_test(t1);
 ct2 = complex_test_from_test(t2);

 if (ct1->type != ct2->type) 
  return FALSE;

 switch(ct1->type) {
 case GOAL_ID_TEST: 
  return TRUE;

 case IMPASSE_ID_TEST: 
  return TRUE;

 case DISJUNCTION_TEST:
  for (c1 = ct1->data.disjunction_list, c2 = ct2->data.disjunction_list; (c1!=NIL) && (c2!=NIL); c1 = c1->rest, c2 = c2->rest)
  {
   if (c1->first != c2->first) 
    return FALSE;
  }
  if (c1 == c2) 
   return TRUE;  /* make sure they both hit end-of-list */
  return FALSE;

 case CONJUNCTIVE_TEST:
  // bug 510 fix: ignore order of test members in conjunctions
  {
   std::list<test> copy2;
   for (c2 = ct2->data.conjunct_list; c2 != NIL; c2 = c2->rest)
    copy2.push_back(static_cast<test>(c2->first));

   std::list<test>::iterator iter;
   for (c1 = ct1->data.conjunct_list; c1 != NIL; c1 = c1->rest)
   {
    // check against copy
    for(iter = copy2.begin(); iter != copy2.end(); ++iter)
    {
     if (tests_are_equal(static_cast<test>(c1->first), *iter, neg)) 
      break;
    }

    // iter will be end if no match
    if (iter == copy2.end())
     return FALSE;

    // there was a match, remove it from unmatched
    copy2.erase(iter);
   }

   // make sure no unmatched remain
   if (copy2.empty()) 
    return TRUE;
  }
  return FALSE;

 default:  /* relational tests other than equality */
  if (ct1->data.referent == ct2->data.referent) 
   return TRUE;
  return FALSE;
 }
}

void unmark_variables_and_free_list	(	agent *	thisAgent,
		::list *	var_list
	)