System

Data Structures

struct varip

struct disvarip

struct relip

struct logrelip

struct whenip

struct modip

struct solver_ipdata

struct reuse_t

struct problem_t

union bnd_union

struct bnd_boundary

struct bnd_filter_structure

struct w_when

struct when_filter_structure

struct when_case

struct when_case_filter_structure

struct dis_discrete

struct dis_filter_structure

struct incidence_vars_t

struct logrel_relation

struct logrel_filter_structure

struct rel_extnode

struct rel_relation

struct ExtRelCache

struct rel_filter_structure

struct slv_output_data

struct slv_tolerance_data

struct slv_sub_parameters

struct slv_int_parameter

struct slv_boolean_parameter

struct slv_real_parameter

struct slv_char_parameter

union parm_arg

struct slv_parameter

struct SlvParameterInitMeta

struct SlvParameterInitInt

struct SlvParameterInitBool

struct SlvParameterInitReal

struct SlvParameterInitChar

struct slv_parameters_structure

struct var_variable

struct var_filter_structure

Defines

#define SIP(x)   ((struct solver_ipdata *)(x))

#define slv_block_partition(s)   slv_block_partition_real((s),0)

#define slv_block_partition_upper(s)   slv_block_partition_real((s),1)

#define bnd_log_cond(b)   ((b)->cond.logrelbnd)

#define bnd_real_cond(b)   ((b)->cond.relbnd)

#define bnd_logrel(b)   ((struct logrel_relation *)(b))

#define bnd_rel(b)   ((struct rel_relation *)(b))

#define BND_REAL   0x1

#define BND_IN_LOGREL   0x2

#define BND_EQUALITY   0x4

#define BND_AT_ZERO   0x8

#define BND_CUR_STATUS   0x10

#define BND_PRE_STATUS   0x20

#define BND_CROSSED   0x40

#define BND_PERTURB   0x80

#define bnd_real(b)   bnd_flagbit((b),BND_REAL)

#define bnd_in_logrel(b)   bnd_flagbit((b),BND_IN_LOGREL)

#define bnd_equality(b)   bnd_flagbit((b),BND_EQUALITY)

#define bnd_at_zero(b)   bnd_flagbit((b),BND_AT_ZERO)

#define bnd_cur_status(b)   bnd_flagbit((b),BND_CUR_STATUS)

#define bnd_pre_status(b)   bnd_flagbit((b),BND_PRE_STATUS)

#define bnd_crossed(b)   bnd_flagbit((b),BND_CROSSED)

#define bnd_perturb(b)   bnd_flagbit((b),BND_PERTURB)

#define bnd_set_real(b, bv)   bnd_set_flagbit((b),BND_REAL,(bv))

#define bnd_set_in_logrel(b, bv)   bnd_set_flagbit((b),BND_IN_LOGREL,(bv))

#define bnd_set_equality(b, bv)   bnd_set_flagbit((b),BND_EQUALITY,(bv))

#define bnd_set_at_zero(b, bv)   bnd_set_flagbit((b),BND_AT_ZERO,(bv))

#define bnd_set_cur_status(b, bv)   bnd_set_flagbit((b),BND_CUR_STATUS,(bv))

#define bnd_set_pre_status(b, bv)   bnd_set_flagbit((b),BND_PRE_STATUS,(bv))

#define bnd_set_crossed(b, bv)   bnd_set_flagbit((b),BND_CROSSED,(bv))

#define bnd_set_perturb(b, bv)   bnd_set_flagbit((b),BND_PERTURB,(bv))

#define MAX_VAR_IN_LIST   20

#define WHEN_INWHEN   0x1

#define WHEN_INCLUDED   0x2

#define WHEN_VISITED   0x4

#define WHEN_CHANGES_STRUCTURE   0x8

#define when_inwhen(when)   when_flagbit((when),WHEN_INWHEN)

#define when_included(when)   when_flagbit((when),WHEN_INCLUDED)

#define when_visited(when)   when_flagbit((when),WHEN_VISITED)

#define when_changes_structure(when)   when_flagbit((when),WHEN_CHANGES_STRUCTURE)

#define when_set_inwhen(when, bv)   when_set_flagbit((when),WHEN_INWHEN,(bv))

#define when_set_included(when, bv)   when_set_flagbit((when),WHEN_INCLUDED,(bv))

#define when_set_visited(when, bv)   when_set_flagbit((when),WHEN_VISITED,(bv))

#define when_set_changes_structure(when, bv)   when_set_flagbit((when),WHEN_CHANGES_STRUCTURE,(bv))

#define WHEN_CASE_ACTIVE   0x1

#define when_case_active(case)   when_case_flagbit((case),WHEN_CASE_ACTIVE)

#define when_case_set_active(case, bv)   when_case_set_flagbit((case),WHEN_CASE_ACTIVE,(bv))

#define dis_instance(dis)   dis_instanceF(dis)

#define dis_set_instance(dis, inst)   dis_set_instanceF((dis),(inst))

#define dis_kind(dis)   dis_kindF(dis)

#define dis_set_kind(dis, kind)   dis_set_kindF((dis),(kind))

#define dis_mindex(dis)   dis_mindexF(dis)

#define dis_set_mindex(dis, index)   dis_set_mindexF((dis),(index))

#define dis_sindex(dis)   dis_sindexF(dis)

#define dis_set_sindex(dis, index)   dis_set_sindexF((dis),(index))

#define dis_set_boolean_value(dis, val)   dis_set_inst_and_field_value(dis,val)

#define BOOLEAN_VAR_STR   "boolean_var"

#define DIS_INCIDENT   0x1

#define DIS_INWHEN   0x2

#define DIS_BVAR   0x4

#define DIS_CONST   0x8

#define DIS_FIXED   0x10

#define DIS_INBLOCK   0x20

#define DIS_ACTIVE   0x40

#define DIS_BOOLEAN   0x80

#define DIS_VAL_MODIFIED   0x100

#define DIS_CHANGES_STRUCTURE   0x200

#define dis_flags(dis)   dis_flagsF(dis)

#define dis_set_flags(dis, flags)   dis_set_flagsF((dis),(flags))

#define dis_inwhen(dis)   dis_flagbit((dis),DIS_INWHEN)

#define dis_const(dis)   dis_flagbit((dis),DIS_CONST)

#define dis_in_block(dis)   dis_flagbit((dis),DIS_INBLOCK)

#define dis_incident(dis)   dis_flagbit((dis),DIS_INCIDENT)

#define dis_active(dis)   dis_flagbit((dis),DIS_ACTIVE)

#define dis_boolean(dis)   dis_flagbit((dis),DIS_BOOLEAN)

#define dis_val_modified(dis)   dis_flagbit((dis),DIS_VAL_MODIFIED)

#define dis_changes_structure(dis)   dis_flagbit((dis),DIS_CHANGES_STRUCTURE)

#define dis_set_inwhen(dis, b)   dis_set_flagbit((dis),DIS_INWHEN,(b))

#define dis_set_const(dis, b)   dis_set_flagbit((dis),DIS_CONST,(b))

#define dis_set_in_block(dis, b)   dis_set_flagbit((dis),DIS_INBLOCK,(b))

#define dis_set_incident(dis, b)   dis_set_flagbit((dis),DIS_INCIDENT,(b))

#define dis_set_active(dis, b)   dis_set_flagbit((dis),DIS_ACTIVE,(b))

#define dis_set_boolean(dis, b)   dis_set_flagbit((dis),DIS_BOOLEAN,(b))

#define dis_set_val_modified(dis, b)   dis_set_flagbit((dis),DIS_VAL_MODIFIED,(b))

#define dis_set_changes_structure(dis, b)   dis_set_flagbit((dis),DIS_CHANGES_STRUCTURE,(b))

#define logrel_n_incidences(lr)   logrel_n_incidencesF(lr)

#define logrel_set_incidences(lr, n, ilist)   logrel_set_incidencesF((lr),(n),(ilist))

#define LOGREL_INCLUDED   0x1

#define LOGREL_SATISFIED   0x2

#define LOGREL_EQUALITY   0x4

#define LOGREL_INWHEN   0x8

#define LOGREL_ACTIVE   0x10

#define LOGREL_CONDITIONAL   0x20

#define LOGREL_IN_BLOCK   0x40

#define logrel_satisfied(lr)   logrel_flagbit((lr),LOGREL_SATISFIED)

#define logrel_equality(lr)   logrel_flagbit((lr),LOGREL_EQUALITY)

#define logrel_in_when(lr)   logrel_flagbit((lr),LOGREL_INWHEN)

#define logrel_active(lr)   logrel_flagbit((lr),LOGREL_ACTIVE)

#define logrel_conditional(lr)   logrel_flagbit((lr),LOGREL_CONDITIONAL)

#define logrel_in_bolck(lr)   logrel_flagbit((lr),LOGREL_IN_BLOCK)

#define logrel_set_satisfied(lr, bv)   logrel_set_flagbit((lr),LOGREL_SATISFIED,(bv))

#define logrel_set_equality(lr, bv)   logrel_set_flagbit((lr),LOGREL_EQUALITY,(bv))

#define logrel_set_in_when(lr, bv)   logrel_set_flagbit((lr),LOGREL_INWHEN,(bv))

#define logrel_set_active(lr, bv)   logrel_set_flagbit((lr),LOGREL_ACTIVE,(bv))

#define logrel_set_conditional(lr, bv)   logrel_set_flagbit((lr),LOGREL_CONDITIONAL,(bv))

#define logrel_set_in_block(lr, bv)   logrel_set_flagbit((lr),LOGREL_IN_BLOCK,(bv))

#define rel_TOK_less   0x1

#define rel_TOK_equal   0x2

#define rel_TOK_greater   0x4

#define rel_n_incidences(rel)   rel_n_incidencesF(rel)

#define rel_set_incidences(rel, n, ilist)   rel_set_incidencesF((rel),(n),(ilist))

#define REL_PARTITION   0x1

#define REL_TORN   0x2

#define REL_INTERFACE   0x4

#define REL_INCLUDED   0x8

#define REL_OBJNEGATE   0x10

#define REL_BLACKBOX   0x20

#define REL_SATISFIED   0x40

#define REL_EQUALITY   0x80

#define REL_INBLOCK   0x100

#define REL_INWHEN   0x200

#define REL_ACTIVE   0x400

#define REL_INVARIANT   0x800

#define REL_CONDITIONAL   0x1000

#define REL_IN_CUR_SUBREGION   0x2000

#define REL_GENERATED   0x10000

#define REL_DIFFERENTIAL   0x20000

#define rel_partition(rel)   rel_flagbit((rel),REL_PARTITION)

#define rel_torn(rel)   rel_flagbit((rel),REL_TORN)

#define rel_interface(rel)   rel_flagbit((rel),REL_INTERFACE)

#define rel_obj_negate(rel)   rel_flagbit((rel),REL_OBJNEGATE)

#define rel_blackbox(rel)   rel_flagbit((rel),REL_BLACKBOX)

#define rel_satisfied(rel)   rel_flagbit((rel),REL_SATISFIED)

#define rel_equality(rel)   rel_flagbit((rel),REL_EQUALITY)

#define rel_in_block(rel)   rel_flagbit((rel),REL_INBLOCK)

#define rel_in_when(rel)   rel_flagbit((rel),REL_INWHEN)

#define rel_active(rel)   rel_flagbit((rel),REL_ACTIVE)

#define rel_invariant(rel)   rel_flagbit((rel),REL_INVARIANT)

#define rel_conditional(rel)   rel_flagbit((rel),REL_CONDITIONAL)

#define rel_in_cur_subregion(rel)   rel_flagbit((rel),REL_IN_CUR_SUBREGION)

#define rel_generated(rel)   rel_flagbit((rel),REL_GENERATED)

#define rel_differential(rel)   rel_flagbit((rel),REL_DIFFERENTIAL)

#define rel_set_partition(rel, bitval)   rel_set_flagbit((rel),REL_PARTITION,(bitval))

#define rel_set_torn(rel, bitval)   rel_set_flagbit((rel),REL_TORN,(bitval))

#define rel_set_interface(rel, bitval)   rel_set_flagbit((rel),REL_INTERFACE,(bitval))

#define rel_set_obj_negate(rel, bitval)   rel_set_flagbit((rel),REL_OBJNEGATE,(bitval))

#define rel_set_blackbox(rel, bitval)   rel_set_flagbit((rel),REL_BLACKBOX,(bitval))

#define rel_set_satisfied(rel, bitval)   rel_set_flagbit((rel),REL_SATISFIED,(bitval))

#define rel_set_equality(rel, bitval)   rel_set_flagbit((rel),REL_EQUALITY,(bitval))

#define rel_set_in_block(rel, bitval)   rel_set_flagbit((rel),REL_INBLOCK,(bitval))

#define rel_set_in_when(rel, bitval)   rel_set_flagbit((rel),REL_INWHEN,(bitval))

#define rel_set_active(rel, bitval)   rel_set_flagbit((rel),REL_ACTIVE,(bitval))

#define rel_set_invariant(rel, bitval)   rel_set_flagbit((rel),REL_INVARIANT,(bitval))

#define rel_set_conditional(rel, bitval)   rel_set_flagbit((rel),REL_CONDITIONAL,(bitval))

#define rel_set_in_cur_subregion(rel, bitval)   rel_set_flagbit((rel),REL_IN_CUR_SUBREGION,(bitval))

#define rel_set_generated(rel, bitval)   rel_set_flagbit((rel),REL_GENERATED,(bitval))

#define rel_set_differential(rel, bitval)   rel_set_flagbit((rel),REL_DIFFERENTIAL,(bitval))

#define SLV_PARAM_INT(PARAMS, INDEX)   (PARAMS)->parms[INDEX].info.i.value

#define SLV_PARAM_BOOL(PARAMS, INDEX)   (PARAMS)->parms[INDEX].info.b.value

#define SLV_PARAM_REAL(PARAMS, INDEX)   (PARAMS)->parms[INDEX].info.r.value

#define SLV_PARAM_CHAR(PARAMS, INDEX)   (PARAMS)->parms[INDEX].info.c.value

#define U_p_int(parm_u, val)   ((((parm_u).argi = (val))), (parm_u))

#define U_p_bool(parm_u, val)   ((((parm_u).argb = (val))), (parm_u))

#define U_p_real(parm_u, val)   ((((parm_u).argr = (val))), (parm_u))

#define U_p_string(parm_u, val)   ((((parm_u).argc = (val))), (parm_u))

#define U_p_strings(parm_u, val)   ((((parm_u).argv = (val))), (parm_u))

#define SLV_IPARM_MACRO(NAME, slv_parms)

#define SLV_BPARM_MACRO(NAME, slv_parms)

#define SLV_RPARM_MACRO(NAME, slv_parms)

#define SLV_CPARM_MACRO(NAME, slv_parms)

#define VAR_REAL   0x1

#define VAR_INCIDENT   0x2

#define VAR_PVAR   0x4

#define VAR_SVAR   0x8

#define VAR_INTEGER   0x10

#define VAR_BINARY   0x20

#define VAR_SEMICONT   0x40

#define VAR_DERIV   0x80

#define VAR_DIFF   0x100

#define VAR_PARAM   0x1000

#define VAR_FIXED   0x2000

#define VAR_INBLOCK   0x4000

#define VAR_INTERFACE   0x8000

#define VAR_RELAXED   0x10000

#define VAR_ACTIVE   0x20000

#define VAR_NONBASIC   0x40000

#define VAR_ACTIVE_AT_BND   0x80000

#define VAR_ELIGIBLE   0x100000

#define VAR_ELIGIBLE_IN_SUBREGION   0x200000

#define VAR_POTENTIALLY_FIXED   0x400000

#define VAR_INCIDENT_IN_CASE   0x800000

#define var_NO_UPPER_BOUND   MAXDOUBLE

#define var_NO_LOWER_BOUND   (-MAXDOUBLE/2)

#define var_instance(var)   var_instanceF(var)

#define var_set_instance(var, inst)   var_set_instanceF((var),(inst))

#define var_mindex(var)   var_mindexF(var)

#define var_set_mindex(var, index)   var_set_mindexF((var),(index))

#define var_sindex(var)   var_sindexF(var)

#define var_set_sindex(var, index)   var_set_sindexF((var),(index))

#define var_n_incidences(var)   var_n_incidencesF(var)

#define var_set_incidences(var, n, ilist)   var_set_incidencesF((var),(n),(ilist))

#define var_flags(var)   var_flagsF(var)

#define var_set_flags(var, flags)   var_set_flagsF((var),(flags))

#define var_in_block(var)   var_flagbit((var),VAR_INBLOCK)

#define var_incident(var)   var_flagbit((var),VAR_INCIDENT)

#define var_deriv(var)   var_flagbit((var),VAR_DERIV)

#define var_diff(var)   var_flagbit((var),VAR_DIFF)

#define var_active(var)   var_flagbit((var),VAR_ACTIVE)

#define var_nonbasic(var)   var_flagbit((var),VAR_NONBASIC)

#define var_active_at_bnd(var)   var_flagbit((var),VAR_ACTIVE_AT_BND)

#define var_eligible(var)   var_flagbit((var),VAR_ELIGIBLE)

#define var_eligible_in_subregion(var)   var_flagbit((var),VAR_ELIGIBLE_IN_SUBREGION)

#define var_incident_in_case(var)   var_flagbit((var),VAR_INCIDENT_IN_CASE)

#define var_potentially_fixed(var)   var_flagbit((var),VAR_POTENTIALLY_FIXED)

#define var_set_in_block(var, oneorzero)   var_set_flagbit((var),VAR_INBLOCK,(oneorzero))

#define var_set_incident(var, oneorzero)   var_set_flagbit((var),VAR_INCIDENT,(oneorzero))

#define var_set_deriv(var, oneorzero)   var_set_flagbit((var),VAR_DERIV,(oneorzero))

#define var_set_diff(var, oneorzero)   var_set_flagbit((var),VAR_DIFF,(oneorzero))

#define var_set_interface(var, oneorzero)   var_set_flagbit((var),VAR_INTERFACE,(oneorzero))

#define var_set_active(var, oneorzero)   var_set_flagbit((var),VAR_ACTIVE,(oneorzero))

#define var_set_nonbasic(var, oneorzero)   var_set_flagbit((var),VAR_NONBASIC,(oneorzero))

#define var_set_active_at_bnd(var, oneorzero)   var_set_flagbit((var),VAR_ACTIVE_AT_BND,(oneorzero))

#define var_set_eligible(var, oneorzero)   var_set_flagbit((var),VAR_ELIGIBLE,(oneorzero))

#define var_set_eligible_in_subregion(var, oneorzero)   var_set_flagbit((var),VAR_ELIGIBLE_IN_SUBREGION,(oneorzero))

#define var_set_incident_in_case(var, oneorzero)   var_set_flagbit((var),VAR_INCIDENT_IN_CASE,(oneorzero))

#define var_set_potentially_fixed(var, oneorzero)   var_set_flagbit((var),VAR_POTENTIALLY_FIXED,(oneorzero))

#define SOLVER_VAR_STR   "solver_var"

#define SOLVER_INT_STR   "solver_int"

#define SOLVER_BINARY_STR   "solver_binary"

#define SOLVER_SEMI_STR   "solver_semi"

#define solver_par(i)   (0)

Typedefs

typedef bnd_filter_structure bnd_filter_t

typedef when_filter_structure when_filter_t

typedef when_case_filter_structure when_case_filter_t

typedef dis_filter_structure dis_filter_t

typedef logrel_filter_structure logrel_filter_t

typedef rel_filter_structure rel_filter_t

typedef slv_parameters_structure slv_parameters_t

typedef void * SlvBackendToken

typedef system_structure * slv_system_t

typedef var_filter_structure var_filter_t

Enumerations

enum bnd_enum { e_bnd_rel, e_bnd_logrel, e_bnd_undefined }

enum discrete_kind { e_dis_boolean_t, e_dis_integer_t, e_dis_symbol_t, e_dis_error_t }

enum logrel_enum { e_logrel_equal, e_logrel_not_equal }

enum rel_enum {
  e_rel_minimize, e_rel_maximize, e_rel_equal, e_rel_not_equal,
  e_rel_less, e_rel_greater, e_rel_lesseq, e_rel_greatereq
}

enum backend_enum { e_rel_token, e_rel_glassbox, e_rel_blackbox }

enum parm_type { int_parm, bool_parm, real_parm, char_parm }

Functions

ASC_DLLSPEC int slv_block_partition_real (slv_system_t sys, int uppertriangular)

ASC_DLLSPEC int slv_block_unify (slv_system_t sys)

ASC_DLLSPEC int slv_set_up_block (slv_system_t sys, int32 block)

ASC_DLLSPEC int slv_spk1_reorder_block (slv_system_t sys, int32 block, int32 transpose)

ASC_DLLSPEC int slv_tear_drop_reorder_block (slv_system_t sys, int32 blockindex, int32 cutoff, int two, enum mtx_reorder_method blockmethod)

ASC_DLLSPEC int system_block_debug (slv_system_t sys, FILE *fp)

ASC_DLLSPEC void system_var_list_debug (slv_system_t sys)

ASC_DLLSPEC void system_rel_list_debug (slv_system_t sys)

ASC_DLLSPEC int system_cut_vars (slv_system_t sys, const int start, const var_filter_t *vfilt, int *nvars)

ASC_DLLSPEC int system_cut_rels (slv_system_t sys, const int start, const rel_filter_t *rfilt, int *nrels)

bnd_boundary * bnd_create (struct bnd_boundary *bnd)

void bnd_destroy (struct bnd_boundary *bnd)

void bnd_set_kind (struct bnd_boundary *bnd, enum bnd_enum kind)

ASC_DLLSPEC enum bnd_enum bnd_kind (struct bnd_boundary *bnd)

void bnd_set_logrels (struct bnd_boundary *bnd, struct gl_list_t *logrels)

gl_list_t * bnd_logrels (struct bnd_boundary *bnd)

void bnd_set_tolerance (struct bnd_boundary *bnd, real64 tolerance)

real64 bnd_tolerance (struct bnd_boundary *bnd)

char * bnd_make_name (slv_system_t sys, struct bnd_boundary *bnd)

int32 bnd_mindex (struct bnd_boundary *bnd)

void bnd_set_mindex (struct bnd_boundary *bnd, int32 mindex)

int32 bnd_sindex (const struct bnd_boundary *bnd)

void bnd_set_sindex (struct bnd_boundary *bnd, int32 sindex)

int32 bnd_model (const struct bnd_boundary *bnd)

void bnd_set_model (struct bnd_boundary *bnd, int32 mindex)

ASC_DLLSPEC struct var_variable ** bnd_real_incidence (struct bnd_boundary *bnd)

ASC_DLLSPEC int32 bnd_n_real_incidences (struct bnd_boundary *bnd)

int bnd_apply_filter (const struct bnd_boundary *bnd, const bnd_filter_t *filter)

unsigned int bnd_flags (struct bnd_boundary *bnd)

void bnd_set_flags (struct bnd_boundary *bnd, uint32 flags)

ASC_DLLSPEC uint32 bnd_flagbit (struct bnd_boundary *bnd, uint32 name)

ASC_DLLSPEC void bnd_set_flagbit (struct bnd_boundary *bnd, uint32 NAME, uint32 oneorzero)

ASC_DLLSPEC int32 bnd_status_cur (struct bnd_boundary *bnd)

ASC_DLLSPEC int32 bnd_status_pre (struct bnd_boundary *bnd)

w_when * when_create (SlvBackendToken instance, struct w_when *newwhen)

SlvBackendToken when_instance (struct w_when *when)

void when_write_name (slv_system_t sys, struct w_when *when, FILE *file)

void when_destroy_cases (struct w_when *when)

void when_destroy (struct w_when *when)

ASC_DLLSPEC char * when_make_name (slv_system_t sys, struct w_when *when)

gl_list_t * when_dvars_list (struct w_when *when)

void when_set_dvars_list (struct w_when *when, struct gl_list_t *dvlist)

gl_list_t * when_cases_list (struct w_when *when)

void when_set_cases_list (struct w_when *when, struct gl_list_t *clist)

int32 when_num_cases (struct w_when *when)

void when_set_num_cases (struct w_when *when, int32 num_cases)

int32 when_mindex (struct w_when *when)

void when_set_mindex (struct w_when *when, int32 mindex)

int32 when_sindex (struct w_when *when)

void when_set_sindex (struct w_when *when, int32 sindex)

int32 when_model (const struct w_when *when)

void when_set_model (struct w_when *when, int32 mindex)

int32 when_apply_filter (struct w_when *when, const when_filter_t *filter)

uint32 when_flags (struct w_when *when)

void when_set_flags (struct w_when *when, uint32 flags)

uint32 when_flagbit (struct w_when *when, uint32 name)

void when_set_flagbit (struct w_when *when, uint32 NAME, uint32 oneorzero)

when_case * when_case_create (struct when_case *newcase)

void when_case_destroy (struct when_case *wc)

int32 * when_case_values_list (struct when_case *wc)

void when_case_set_values_list (struct when_case *wc, int32 *vallist)

gl_list_t * when_case_rels_list (struct when_case *wc)

void when_case_set_rels_list (struct when_case *wc, struct gl_list_t *rlist)

gl_list_t * when_case_logrels_list (struct when_case *wc)

void when_case_set_logrels_list (struct when_case *wc, struct gl_list_t *lrlist)

gl_list_t * when_case_whens_list (struct when_case *wc)

void when_case_set_whens_list (struct when_case *wc, struct gl_list_t *wlist)

int32 when_case_case_number (struct when_case *wc)

void when_case_set_case_number (struct when_case *wc, int32 case_number)

int32 when_case_num_rels (struct when_case *wc)

void when_case_set_num_rels (struct when_case *wc, int32 num_rels)

int32 when_case_num_inc_var (struct when_case *wc)

void when_case_set_num_inc_var (struct when_case *wc, int32 num_inc_var)

int32 * when_case_ind_inc (struct when_case *wc)

void when_case_set_ind_inc (struct when_case *wc, int32 *ind_inc)

int32 when_case_apply_filter (struct when_case *wc, const when_case_filter_t *filter)

uint32 when_case_flags (struct when_case *wc)

void when_case_set_flags (struct when_case *wc, uint32 flags)

uint32 when_case_flagbit (struct when_case *wc, uint32 name)

void when_case_set_flagbit (struct when_case *wc, uint32 NAME, uint32 oneorzero)

dis_discrete * dis_create (SlvBackendToken instance, struct dis_discrete *newdis)

SlvBackendToken dis_instanceF (const struct dis_discrete *dis)

void dis_set_instanceF (struct dis_discrete *dis, SlvBackendToken i)

char * dis_make_name (const slv_system_t sys, const struct dis_discrete *dis)

char * dis_make_xname (const struct dis_discrete *dis)

void dis_write_name (const slv_system_t sys, const struct dis_discrete *dis, FILE *file)

void dis_destroy (struct dis_discrete *dis)

gl_list_t * dis_whens_list (struct dis_discrete *dis)

void dis_set_whens_list (struct dis_discrete *dis, struct gl_list_t *wlist)

ASC_DLLSPEC enum discrete_kind dis_kindF (const struct dis_discrete *dis)

void dis_set_kindF (struct dis_discrete *dis, enum discrete_kind kind)

int32 dis_mindexF (const struct dis_discrete *dis)

void dis_set_mindexF (struct dis_discrete *dis, int32 mindex)

int32 dis_sindexF (const struct dis_discrete *dis)

void dis_set_sindexF (struct dis_discrete *dis, int32 sindex)

ASC_DLLSPEC int32 dis_value (const struct dis_discrete *dis)

ASC_DLLSPEC void dis_set_value (struct dis_discrete *dis, int32 value)

ASC_DLLSPEC void dis_set_inst_and_field_value (struct dis_discrete *dis, int32 value)

void dis_set_value_from_inst (struct dis_discrete *dis, struct gl_list_t *symbol_list)

ASC_DLLSPEC int32 dis_previous_value (const struct dis_discrete *dis)

ASC_DLLSPEC void dis_set_previous_value (struct dis_discrete *dis, int32 value)

boolean boolean_var (SlvBackendToken inst)

boolean set_boolean_types (void)

int32 dis_nominal (struct dis_discrete *dis)

void dis_set_nominal (struct dis_discrete *dis, int32 nominal)

ASC_DLLSPEC uint32 dis_fixed (struct dis_discrete *dis)

void dis_set_fixed (struct dis_discrete *dis, uint32 fixed)

uint32 dis_flagsF (const struct dis_discrete *dis)

void dis_set_flagsF (struct dis_discrete *dis, uint32 flags)

ASC_DLLSPEC uint32 dis_flagbit (const struct dis_discrete *dis, const uint32 name)

ASC_DLLSPEC void dis_set_flagbit (struct dis_discrete *dis, uint32 NAME, uint32 oneorzero)

int32 dis_apply_filter (const struct dis_discrete *dis, const dis_filter_t *filter)

dis_discrete ** dis_BackendTokens_to_dis (slv_system_t sys, SlvBackendToken *tokenlist, int32 len)

ASC_DLLSPEC int build_incidence_data (CONST slv_system_t sys, incidence_vars_t *pd)

ASC_DLLSPEC void free_incidence_data (incidence_vars_t *pd)

logrel_relation * logrel_create (