/[ascend]/trunk/base/generic/solver/cond_config.c
ViewVC logotype

Diff of /trunk/base/generic/solver/cond_config.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 838 by johnpye, Fri Aug 4 09:08:16 2006 UTC revision 839 by johnpye, Fri Sep 8 07:46:53 2006 UTC
# Line 75  struct ds_case_list { Line 75  struct ds_case_list {
75     int32 *case_number;     int32 *case_number;
76  };  };
77    
78  /*  /*
79   * forward declarations   * forward declarations
80   */   */
81  void analyze_when(struct w_when *);  void analyze_when(struct w_when *);
82  static void simplified_analyze_when(struct w_when *);  static void simplified_analyze_when(struct w_when *);
# Line 91  static int32 g_case_number = 0; Line 91  static int32 g_case_number = 0;
91    
92  /**  /**
93      Set the ACTIVE bit to value for all the relations      Set the ACTIVE bit to value for all the relations
94      included in the case      included in the case
95  */  */
96  static void set_rels_status_in_case(struct when_case *cur_case  static void set_rels_status_in_case(struct when_case *cur_case
97          , uint32 value          , uint32 value
# Line 100  static void set_rels_status_in_case(stru Line 100  static void set_rels_status_in_case(stru
100    struct rel_relation *rel;    struct rel_relation *rel;
101    int32 r,rlen;    int32 r,rlen;
102    
103    CONSOLE_DEBUG("...");    /* CONSOLE_DEBUG("..."); */
104    
105    rels = when_case_rels_list(cur_case);    rels = when_case_rels_list(cur_case);
106    rlen = gl_length(rels);    rlen = gl_length(rels);
107    for(r=1;r<=rlen;r++) {    for(r=1;r<=rlen;r++) {
108      rel = (struct rel_relation *)(gl_fetch(rels,r));      rel = (struct rel_relation *)(gl_fetch(rels,r));
109      if(!value){      if(!value){
110          CONSOLE_DEBUG("INACTIVE REL AT %p",rel);          /* CONSOLE_DEBUG("INACTIVE REL AT %p",rel); */
111      }        }
112      rel_set_active(rel,value);      rel_set_active(rel,value);
113    }    }
114  }  }
# Line 116  static void set_rels_status_in_case(stru Line 116  static void set_rels_status_in_case(stru
116    
117  /*  /*
118   * Set the ACTIVE bit to value for all the logrelations   * Set the ACTIVE bit to value for all the logrelations
119   * included in the case   * included in the case
120   */   */
121  static void set_logrels_status_in_case(struct when_case *cur_case,  static void set_logrels_status_in_case(struct when_case *cur_case,
122                         uint32 value)                         uint32 value)
# Line 136  static void set_logrels_status_in_case(s Line 136  static void set_logrels_status_in_case(s
136    
137  /*  /*
138   * Set the ACTIVE bit to value for all the relations and logrelations   * Set the ACTIVE bit to value for all the relations and logrelations
139   * included in a when (implicitly or explcitly).   * included in a when (implicitly or explcitly).
140   */   */
141  void set_rels_status_in_when(struct w_when *when, uint32 value)  void set_rels_status_in_when(struct w_when *when, uint32 value)
142  {  {
# Line 163  void set_rels_status_in_when(struct w_wh Line 163  void set_rels_status_in_when(struct w_wh
163  }  }
164    
165    
166  /*  /*
167   * After a case is found to apply for the current values of the   * After a case is found to apply for the current values of the
168   * conditional variables, the rel_relations and logrel_relations   * conditional variables, the rel_relations and logrel_relations
169   * in such a case are set ACTIVE.   * in such a case are set ACTIVE.
# Line 207  static void apply_case(struct when_case Line 207  static void apply_case(struct when_case
207    }    }
208  }  }
209    
210  /*  /*
211   * Compare current values of the conditional variables with   * Compare current values of the conditional variables with
212   * the set of values in a CASE, and try to find is such   * the set of values in a CASE, and try to find is such
213   * values are the same. If they are, then the previous function   * values are the same. If they are, then the previous function
# Line 215  static void apply_case(struct when_case Line 215  static void apply_case(struct when_case
215   */   */
216    
217    
218  static int32 analyze_case(struct when_case *cur_case,  static int32 analyze_case(struct when_case *cur_case,
219                struct gl_list_t *dvars)                struct gl_list_t *dvars)
220  {  {
221    
# Line 245  static int32 analyze_case(struct when_ca Line 245  static int32 analyze_case(struct when_ca
245  }  }
246    
247    
248  /*  /*
249   * This function will determine which case of a WHEN statement   * This function will determine which case of a WHEN statement
250   * applies for the current values of the conditional variables.   * applies for the current values of the conditional variables.
251   * The relations in that case are set ACTIVE   * The relations in that case are set ACTIVE
# Line 354  static void simplified_apply_case(struct Line 354  static void simplified_apply_case(struct
354  }  }
355    
356    
357  /*  /*
358   * Compare current values of the conditional variables with   * Compare current values of the conditional variables with
359   * the set of values in a CASE, and try to find is such   * the set of values in a CASE, and try to find is such
360   * values are the same. If they are, then the previous function   * values are the same. If they are, then the previous function
# Line 390  static int32 simplified_analyze_case(str Line 390  static int32 simplified_analyze_case(str
390  }  }
391    
392    
393  /*  /*
394   * This function will determine which case of a WHEN statement   * This function will determine which case of a WHEN statement
395   * applies for the current values of the conditional variables.   * applies for the current values of the conditional variables.
396   * That case will be set ACTIVE   * That case will be set ACTIVE
# Line 567  void set_inactive_disvars_in_list(struct Line 567  void set_inactive_disvars_in_list(struct
567    
568    
569  /*  /*
570   * Set the ACTIVE bit to TRUE for all the variables included in   * Set the ACTIVE bit to TRUE for all the variables included in
571   * ACTIVE relations.   * ACTIVE relations.
572   */   */
573  void set_active_vars_in_active_rels(struct rel_relation **solverrl)  void set_active_vars_in_active_rels(struct rel_relation **solverrl)
# Line 591  void set_active_vars_in_active_rels(stru Line 591  void set_active_vars_in_active_rels(stru
591  }  }
592    
593  /*  /*
594   * Set the ACTIVE_AT_BND bit to TRUE for all the variables included in   * Set the ACTIVE_AT_BND bit to TRUE for all the variables included in
595   * ACTIVE relations.   * ACTIVE relations.
596   */   */
597  static  static
598  void set_active_vars_at_bnd_in_active_rels(struct rel_relation **solverrl)  void set_active_vars_at_bnd_in_active_rels(struct rel_relation **solverrl)
599  {  {
600    struct var_variable *var;    struct var_variable *var;
# Line 617  void set_active_vars_at_bnd_in_active_re Line 617  void set_active_vars_at_bnd_in_active_re
617    
618    
619  /*  /*
620   * Set the ACTIVE bit to TRUE for all the discrete variables included in   * Set the ACTIVE bit to TRUE for all the discrete variables included in
621   * ACTIVE logrelations.   * ACTIVE logrelations.
622   */   */
623  void set_active_disvars_in_active_logrels(struct logrel_relation **solverll)  void set_active_disvars_in_active_logrels(struct logrel_relation **solverll)
# Line 688  void set_active_vars_at_bnd(slv_system_t Line 688  void set_active_vars_at_bnd(slv_system_t
688   * Set the INVARIANT flag to TRUE for all the relations invariant with   * Set the INVARIANT flag to TRUE for all the relations invariant with
689   * respect to the current boundary(ies)   * respect to the current boundary(ies)
690   */   */
691  void identify_invariant_rels_at_bnd(slv_system_t sys,  void identify_invariant_rels_at_bnd(slv_system_t sys,
692                      struct gl_list_t *disvars)                      struct gl_list_t *disvars)
693  {  {
694    struct rel_relation **solverrl;    struct rel_relation **solverrl;
# Line 761  static int32 case_in_nested_whens(int32 Line 761  static int32 case_in_nested_whens(int32
761        num_case = when_case_case_number(cur_case);        num_case = when_case_case_number(cur_case);
762        if (num_case == -1) {        if (num_case == -1) {
763          if (case_in_nested_whens(cases,ncases,nested_case)) { /* recursion */          if (case_in_nested_whens(cases,ncases,nested_case)) { /* recursion */
764            return 1;            return 1;
765      }      }
766        } else {        } else {
767          if(case_in_array_of_cases(num_case,cases,ncases)) {          if(case_in_array_of_cases(num_case,cases,ncases)) {
768            return 1;            return 1;
769      }      }
770        }        }
771      }          }
772    }    }
773    
774    return 0;    return 0;
# Line 778  static int32 case_in_nested_whens(int32 Line 778  static int32 case_in_nested_whens(int32
778   * If some case of the when belong to the list of cases, the rels   * If some case of the when belong to the list of cases, the rels
779   * in such a case are set as active   * in such a case are set as active
780   */   */
781  static void set_active_rels_in_cases(int32 *cases, int32 ncases,  static void set_active_rels_in_cases(int32 *cases, int32 ncases,
782                       struct w_when *when)                       struct w_when *when)
783  {  {
784    struct gl_list_t *case_list;    struct gl_list_t *case_list;
# Line 795  static void set_active_rels_in_cases(int Line 795  static void set_active_rels_in_cases(int
795      num_case = when_case_case_number(cur_case);      num_case = when_case_case_number(cur_case);
796      if (num_case == -1) { /* nested whens in case */      if (num_case == -1) { /* nested whens in case */
797        if (case_in_nested_whens(cases,ncases,cur_case)) {        if (case_in_nested_whens(cases,ncases,cur_case)) {
798          when_case_set_active(cur_case,TRUE);          when_case_set_active(cur_case,TRUE);
799          set_rels_status_in_case(cur_case,TRUE);          set_rels_status_in_case(cur_case,TRUE);
800          set_logrels_status_in_case(cur_case,TRUE);          set_logrels_status_in_case(cur_case,TRUE);
801          whens = when_case_whens_list(cur_case);          whens = when_case_whens_list(cur_case);
# Line 807  static void set_active_rels_in_cases(int Line 807  static void set_active_rels_in_cases(int
807        }        }
808      } else {      } else {
809        if(case_in_array_of_cases(num_case,cases,ncases)) {        if(case_in_array_of_cases(num_case,cases,ncases)) {
810          when_case_set_active(cur_case,TRUE);          when_case_set_active(cur_case,TRUE);
811          set_rels_status_in_case(cur_case,TRUE);          set_rels_status_in_case(cur_case,TRUE);
812          set_logrels_status_in_case(cur_case,TRUE);                set_logrels_status_in_case(cur_case,TRUE);
813        }        }
814      }      }
815    }    }
# Line 821  static void set_active_rels_in_cases(int Line 821  static void set_active_rels_in_cases(int
821   * set as active the relations corresponding to the cases passed   * set as active the relations corresponding to the cases passed
822   * as argument in cases.   * as argument in cases.
823   */   */
824  void set_active_rels_in_subregion(slv_system_t sys, int32 *cases,  void set_active_rels_in_subregion(slv_system_t sys, int32 *cases,
825                    int32 ncases, struct gl_list_t *disvars)                    int32 ncases, struct gl_list_t *disvars)
826  {  {
827    struct rel_relation **solverrl;    struct rel_relation **solverrl;
# Line 867  static void set_variant_rels_in_subregio Line 867  static void set_variant_rels_in_subregio
867    
868    for (c = 0; rlist[c]!= NULL; c++) {    for (c = 0; rlist[c]!= NULL; c++) {
869      rel = rlist[c];      rel = rlist[c];
870      if (rel_active(rel) && (!rel_invariant(rel))      if (rel_active(rel) && (!rel_invariant(rel))
871          && rel_included(rel) && rel_equality(rel)) {          && rel_included(rel) && rel_equality(rel)) {
872        rel_set_in_cur_subregion(rel,TRUE);        rel_set_in_cur_subregion(rel,TRUE);
873      }      }
# Line 918  void set_active_vars_in_subregion(slv_sy Line 918  void set_active_vars_in_subregion(slv_sy
918   * pattern) of the different alternatives in a conditional   * pattern) of the different alternatives in a conditional
919   * model. So, alternatives that have the same incidence   * model. So, alternatives that have the same incidence
920   * pattern can be identified and the combinatorial cosistency   * pattern can be identified and the combinatorial cosistency
921   * analysis (proper selection of the degrees of freedom in a   * analysis (proper selection of the degrees of freedom in a
922   * conditional model) can be simplified. This current   * conditional model) can be simplified. This current
923   * implementation does not handle nested WHENs. So, if a WHEN have   * implementation does not handle nested WHENs. So, if a WHEN have
924   * a nested WHEN, the outter most WHEN is considered as a WHEN   * a nested WHEN, the outter most WHEN is considered as a WHEN
# Line 1026  static int32 compare_alternative_cases(s Line 1026  static int32 compare_alternative_cases(s
1026    for (v=0; v<nvar1; v++) {    for (v=0; v<nvar1; v++) {
1027      ind1 = ninc1[v];      ind1 = ninc1[v];
1028      ind2 = ninc2[v];      ind2 = ninc2[v];
1029      
1030      if (ind1 != ind2) {      if (ind1 != ind2) {
1031  #if DEBUG_PRE_ANALYSIS  #if DEBUG_PRE_ANALYSIS
1032        FPRINTF(ASCERR,"Incidences are different in CASEs\n");        FPRINTF(ASCERR,"Incidences are different in CASEs\n");
1033        FPRINTF(ASCERR,"index in case A =%d  index in case B =%d\n",ind1,ind2);        FPRINTF(ASCERR,"index in case A =%d  index in case B =%d\n",ind1,ind2);
1034  #endif /* DEBUG_PRE_ANALYSIS */  #endif /* DEBUG_PRE_ANALYSIS */
1035        return 0;        return 0;
1036      }      }
1037    }    }
1038    
1039    rel_list1 = when_case_rels_list(cur_case1);    rel_list1 = when_case_rels_list(cur_case1);
# Line 1109  static int32 compare_alternative_structu Line 1109  static int32 compare_alternative_structu
1109  #if DEBUG_PRE_ANALYSIS  #if DEBUG_PRE_ANALYSIS
1110          FPRINTF(ASCERR,"CASEs have different structure\n");          FPRINTF(ASCERR,"CASEs have different structure\n");
1111  #endif /* DEBUG_PRE_ANALYSIS */  #endif /* DEBUG_PRE_ANALYSIS */
1112          return 0;                  return 0;
1113        }        }
1114      }      }
1115      return 1;      return 1;
# Line 1123  static int32 compare_alternative_structu Line 1123  static int32 compare_alternative_structu
1123  }  }
1124    
1125  /*  /*
1126   * Define values for the flag incident_in_case of the variables in the   * Define values for the flag incident_in_case of the variables in the
1127   * master list   * master list
1128   */   */
1129  static void set_incident_in_case_status(struct var_variable **vlist,  static void set_incident_in_case_status(struct var_variable **vlist,
# Line 1142  static void set_incident_in_case_status( Line 1142  static void set_incident_in_case_status(
1142   * Get the list of master indices of the variables incident in a   * Get the list of master indices of the variables incident in a
1143   * CASE   * CASE
1144   */   */
1145  static void get_incidences_in_case(struct when_case *cur_case,  static void get_incidences_in_case(struct when_case *cur_case,
1146                  struct var_variable **mastervl)                  struct var_variable **mastervl)
1147  {  {
1148    struct gl_list_t *rels;    struct gl_list_t *rels;
1149    struct rel_relation *rel;    struct rel_relation *rel;
1150    struct var_variable **var_list;    struct var_variable **var_list;
1151    struct var_variable *var;    struct var_variable *var;
# Line 1163  static void get_incidences_in_case(struc Line 1163  static void get_incidences_in_case(struc
1163        var_list = rel_incidence_list_to_modify(rel);        var_list = rel_incidence_list_to_modify(rel);
1164        for (v=0; v<vlen; v++) {        for (v=0; v<vlen; v++) {
1165         var = var_list[v];         var = var_list[v];
1166         var_set_incident_in_case(var,TRUE);               var_set_incident_in_case(var,TRUE);
1167        }        }
1168      }      }
1169    }    }
# Line 1236  static void order_relations_by_incidence Line 1236  static void order_relations_by_incidence
1236          vindex = var_ind[r][v];          vindex = var_ind[r][v];
1237          rind =r;          rind =r;
1238          break;          break;
1239        }        }
1240      }      }
1241      for (rin=0; rin<rlen; rin++) {      for (rin=0; rin<rlen; rin++) {
1242        vind = var_ind[rin][v];        vind = var_ind[rin][v];
# Line 1256  static void order_relations_by_incidence Line 1256  static void order_relations_by_incidence
1256            }            }
1257                    break;                    break;
1258          }          }
1259            }            }
1260          }          }
1261        }        }
1262      }      }
# Line 1289  static void order_relations_by_incidence Line 1289  static void order_relations_by_incidence
1289  }  }
1290    
1291  /*  /*
1292   * Order the list of relations of a CASE according to the number of   * Order the list of relations of a CASE according to the number of
1293   * incidences and index of the incidences   * incidences and index of the incidences
1294   */   */
1295  static void order_relations_in_case(struct when_case *cur_case)  static void order_relations_in_case(struct when_case *cur_case)
# Line 1316  static void order_relations_in_case(stru Line 1316  static void order_relations_in_case(stru
1316          rel = (struct rel_relation *)(gl_fetch(rels,r));          rel = (struct rel_relation *)(gl_fetch(rels,r));
1317          num_inc[r-1] = rel_n_incidences(rel);          num_inc[r-1] = rel_n_incidences(rel);
1318        }        }
1319    
1320        /* order number of incidences */        /* order number of incidences */
1321        aux = 0;        aux = 0;
1322        while (aux < rlen) {        while (aux < rlen) {
# Line 1348  static void order_relations_in_case(stru Line 1348  static void order_relations_in_case(stru
1348          rcount = ordered_num_inc[r];          rcount = ordered_num_inc[r];
1349          for (rin=0; rin<rlen;rin++) {          for (rin=0; rin<rlen;rin++) {
1350            if (num_inc[rin] >= 0) {            if (num_inc[rin] >= 0) {
1351              rel = (struct rel_relation *)(gl_fetch(rels,rin+1));                      rel = (struct rel_relation *)(gl_fetch(rels,rin+1));
1352              rind = rel_n_incidences(rel);              rind = rel_n_incidences(rel);
1353              if (rcount == rind) {              if (rcount == rind) {
1354                gl_append_ptr(new_rels,rel);                gl_append_ptr(new_rels,rel);
# Line 1359  static void order_relations_in_case(stru Line 1359  static void order_relations_in_case(stru
1359          }          }
1360        }        }
1361    
1362        /*        /*
1363         * order relations with same order of incidences according to         * order relations with same order of incidences according to
1364         * the master indices of their incidences         * the master indices of their incidences
1365         */         */
# Line 1389  static void order_relations_in_case(stru Line 1389  static void order_relations_in_case(stru
1389             order_relations_by_incidences(scratch);             order_relations_by_incidences(scratch);
1390             for (r=1; r<=glob_count - aux + 1; r++) {             for (r=1; r<=glob_count - aux + 1; r++) {
1391              rel = (struct rel_relation *)(gl_fetch(scratch,r));              rel = (struct rel_relation *)(gl_fetch(scratch,r));
1392              gl_append_ptr(tmp,rel);              gl_append_ptr(tmp,rel);
1393         }         }
1394             gl_destroy(scratch);             gl_destroy(scratch);
1395       } else {       } else {
1396              rel = (struct rel_relation *)(gl_fetch(rels,glob_count+1));              rel = (struct rel_relation *)(gl_fetch(rels,glob_count+1));
1397              gl_append_ptr(tmp,rel);              gl_append_ptr(tmp,rel);
1398       }       }
1399           aux = glob_count+1;           aux = glob_count+1;
1400           glob_count = aux;           glob_count = aux;
1401         }         }
# Line 1414  static void order_relations_in_case(stru Line 1414  static void order_relations_in_case(stru
1414    
1415    
1416  /*  /*
1417   * Analyzes (get number of relations and variables, get global list of   * Analyzes (get number of relations and variables, get global list of
1418   * incident variables, order relation and variables by master index)   * incident variables, order relation and variables by master index)
1419   * a CASE of a WHEN statement   * a CASE of a WHEN statement
1420   */   */
# Line 1430  static int32 analyze_structure_of_case(s Line 1430  static int32 analyze_structure_of_case(s
1430  #if DEBUG_PRE_ANALYSIS  #if DEBUG_PRE_ANALYSIS
1431    FPRINTF(ASCERR,"case # = %d  \n",when_case_case_number(cur_case));    FPRINTF(ASCERR,"case # = %d  \n",when_case_case_number(cur_case));
1432  #endif /* DEBUG_PRE_ANALYSIS */  #endif /* DEBUG_PRE_ANALYSIS */
1433  /*  /*
1434   * No nested WHENs right now   * No nested WHENs right now
1435   * Here we'll need to recursively call   * Here we'll need to recursively call
1436   * the analysis of the nested when and   * the analysis of the nested when and
# Line 1466  static int32 analyze_structure_of_case(s Line 1466  static int32 analyze_structure_of_case(s
1466    
1467  /*  /*
1468   * analyzes the structure of the different alternatives (CASES)   * analyzes the structure of the different alternatives (CASES)
1469   * in a WHEN statement so  that we can find out later if it is   * in a WHEN statement so  that we can find out later if it is
1470   * necessary to perform a combinatorial search for a consistent   * necessary to perform a combinatorial search for a consistent
1471   * variable partitioning   * variable partitioning
1472   */   */
1473    
# Line 1517  static int32 analyze_alternative_structu Line 1517  static int32 analyze_alternative_structu
1517    
1518  /*  /*
1519   *-------------------------------------------   *-------------------------------------------
1520   * ENUMERATION OF CASES   * ENUMERATION OF CASES
1521   *------------------------------------------   *------------------------------------------
1522   */   */
1523    
# Line 1563  void enumerate_cases_in_when(struct w_wh Line 1563  void enumerate_cases_in_when(struct w_wh
1563        g_case_number++;        g_case_number++;
1564        when_case_set_case_number(cur_case,g_case_number);        when_case_set_case_number(cur_case,g_case_number);
1565  #if CASE_NUMBER  #if CASE_NUMBER
1566        FPRINTF(ASCERR,"Case number = %d \n",        FPRINTF(ASCERR,"Case number = %d \n",
1567                             when_case_case_number(cur_case));                             when_case_case_number(cur_case));
1568  #endif /* CASE NUMBER*/  #endif /* CASE NUMBER*/
1569      } else {      } else {
# Line 1779  void configure_conditional_problem(int32 Line 1779  void configure_conditional_problem(int32
1779      result = analyze_alternative_structures_in_when(when,mastervl);      result = analyze_alternative_structures_in_when(when,mastervl);
1780    }    }
1781    
1782    /*    /*
1783     *All rel_relations and logrel_relations explicitly or implicitly     *All rel_relations and logrel_relations explicitly or implicitly
1784     * (models) inside a w_when are deactivated     * (models) inside a w_when are deactivated
1785     */     */
1786    for (w = 0; w < numwhens; w++) {    for (w = 0; w < numwhens; w++) {
1787      when = whenlist[w];      when = whenlist[w];
# Line 1793  void configure_conditional_problem(int32 Line 1793  void configure_conditional_problem(int32
1793    /* All of the rels which are ACTIVE, are also INVARIANT */    /* All of the rels which are ACTIVE, are also INVARIANT */
1794    set_active_rels_as_invariant(solverrl);    set_active_rels_as_invariant(solverrl);
1795    
1796    /*    /*
1797     * Analyze whens and find active relations and logrelations     * Analyze whens and find active relations and logrelations
1798     * in each of them     * in each of them
1799     */     */
1800    
1801    for (w = 0; w < numwhens; w++) {    for (w = 0; w < numwhens; w++) {
# Line 1901  int32 system_reanalyze(slv_system_t sys, Line 1901  int32 system_reanalyze(slv_system_t sys,
1901  }  }
1902    
1903    
1904  /*  /*
1905   * The next four functions are not currently in use, but they may   * The next four functions are not currently in use, but they may
1906   * in the future. See the header   * in the future. See the header
1907   */   */
# Line 1990  int32 build_logrel_solver_from_master(st Line 1990  int32 build_logrel_solver_from_master(st
1990   * Build the var solver list from the master list in the case of our   * Build the var solver list from the master list in the case of our
1991   * problem contains when's.  This function is not currently in use. It   * problem contains when's.  This function is not currently in use. It
1992   * could be use to build a solver var list of ACTIVE variables (Vars   * could be use to build a solver var list of ACTIVE variables (Vars
1993   * incident in ACTIVE relations). It returns the number of variables   * incident in ACTIVE relations). It returns the number of variables
1994   * in the list.   * in the list.
1995   */   */
1996  int32 build_var_solver_from_master(struct var_variable **mastervl,  int32 build_var_solver_from_master(struct var_variable **mastervl,

Legend:
Removed from v.838  
changed lines
  Added in v.839

john.pye@anu.edu.au
ViewVC Help
Powered by ViewVC 1.1.22