distrib/sources/tas/stm/stm_modtbl_merge.c

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*                      Chaine de CAO & VLSI   AVERTEC                      */
   4 /*                                                                          */
   5 /*    Produit : STM Version 1.00                                            */
   6 /*    Fichier : stm_modtb_merge.c                                           */
   7 /*                                                                          */
   8 /*    (c) copyright 2000 AVERTEC                                            */
   9 /*    Tous droits reserves                                                  */
  10 /*                                                                          */
  11 /*    Auteur(s) : Gilles Augustins                                          */
  12 /*                                                                          */
  13 /****************************************************************************/
  14
  15 /****************************************************************************/
  16 /*     includes                                                             */
  17 /****************************************************************************/
  18
  19 #include "stm.h"
  20
  21 /****************************************************************************/
  22 /*     functions                                                            */
  23 /****************************************************************************/
  24
  25 timing_table *stm_modtbl_mergec (timing_table *dttable, timing_table *cktable, float cstr, float dtload, float ckload)
  26 {
  27     timing_table *delaytabAB = NULL;
  28     timing_table *delaytabA;
  29     timing_table *delaytabB;
  30     int           nldA,           /* nb load delaytable A */
  31                   nsdA,           /* nb slew delaytable A */
  32                   nsdB,           /* nb load delaytable B */
  33                   nldB;           /* nb slew delaytable B */
  34     int           i, j;
  35     float         inslewA, inslewB;
  36     float         delayA, delayB;
  37     float         loadA = dtload;
  38     float         loadB = ckload;
  39
  40     delaytabA = dttable;
  41     delaytabB = cktable;
  42
  43     nldA = stm_modtbl_getnload (delaytabA);
  44     nsdA = stm_modtbl_getnslew (delaytabA);
  45     nldB = stm_modtbl_getnload (delaytabB);
  46     nsdB = stm_modtbl_getnslew (delaytabB);
  47
  48     if (nsdA && nsdB) {
  49         delaytabAB = stm_modtbl_create (nsdA, nsdB, STM_INPUT_SLEW, STM_CLOCK_SLEW);
  50         stm_modtbl_Ximportslewaxis (delaytabAB, delaytabA);
  51         stm_modtbl_Yimportslewaxis (delaytabAB, delaytabB);
  52         for (i = 0; i < nsdA; i++) {
  53             inslewA = stm_modtbl_getslewaxisval (delaytabA, i);
  54             delayA = stm_modtbl_delay (delaytabA, loadA, inslewA);
  55             for (j = 0; j < nsdB; j++) {
  56                 inslewB = stm_modtbl_getslewaxisval (delaytabB, j);
  57                 delayB = stm_modtbl_delay (delaytabB, loadB, inslewB);
  58                 stm_modtbl_set2Dval (delaytabAB, i, j, delayA + cstr + delayB);
  59             }
  60         }
  61     }
  62
  63     if (nsdA && !nsdB) {
  64         delaytabAB = stm_modtbl_create (nsdA, 0, STM_INPUT_SLEW, STM_NOTYPE);
  65         stm_modtbl_Ximportslewaxis (delaytabAB, delaytabA);
  66         delayB = stm_modtbl_delay (delaytabB, loadB, STM_DONTCARE);
  67         for (i = 0; i < nsdA; i++) {
  68             inslewA = stm_modtbl_getslewaxisval (delaytabA, i);
  69             delayA = stm_modtbl_delay (delaytabA, loadA, inslewA);
  70             stm_modtbl_set1Dval (delaytabAB, i, delayA + cstr + delayB);
  71         }
  72     }
  73
  74     if (!nsdA && nsdB) {
  75         delaytabAB = stm_modtbl_create (nsdB, 0, STM_CLOCK_SLEW, STM_NOTYPE);
  76         stm_modtbl_Ximportloadaxis (delaytabAB, delaytabB);
  77         delayA = stm_modtbl_delay (delaytabA, loadA, STM_DONTCARE);
  78         for (i = 0; i < nsdB; i++) {
  79             inslewB = stm_modtbl_getslewaxisval (delaytabB, i);
  80             delayB  = stm_modtbl_delay (delaytabB, loadB, inslewB);
  81             stm_modtbl_set1Dval (delaytabAB, i, delayA + cstr + delayB);
  82         }
  83     }
  84
  85     if (!nsdA && !nsdB) {
  86         delaytabAB = stm_modtbl_create (0, 0, STM_NOTYPE, STM_NOTYPE) ;
  87         delayA = stm_modtbl_delay (delaytabA, loadA, STM_DONTCARE) ;
  88         delayB = stm_modtbl_delay (delaytabB, loadB, STM_DONTCARE) ;
  89         stm_modtbl_setconst (delaytabAB, delayA + cstr + delayB) ;
  90     }
  91
  92     if (!delaytabAB)
  93         avt_errmsg (STM_ERRMSG, "029", AVT_ERROR);
  94
  95     return delaytabAB;
  96 }
  97
  98 /****************************************************************************/
  99 timing_table *stm_modtbl_mergecd (timing_table *dttable, timing_table *dstable, timing_table *cstrtable, float cstr, float dtload)
 100 {
 101     timing_table *delaytabAB = NULL;
 102     timing_table *delaytabA;
 103     timing_table *slewtabA;
 104     timing_table *delaytabB;
 105     int           nldA,           /* nb load delaytable A */
 106                   nsdA,           /* nb slew delaytable A */
 107                   nsdB,           /* nb load delaytable B */
 108                   nldB;           /* nb slew delaytable B */
 109     int           i, j;
 110     float         inslewA, ckslewB, slewA;
 111     float         delayA, delayB;
 112     float         loadA = dtload;
 113
 114     delaytabA = dttable;
 115     slewtabA = dstable;
 116     delaytabB = cstrtable;
 117
 118     nldA = stm_modtbl_getnload (delaytabA);
 119     nsdA = stm_modtbl_getnslew (delaytabA);
 120     nldB = stm_modtbl_getnload (delaytabB);
 121     nsdB = stm_modtbl_getnckslew (delaytabB);
 122
 123     if (cstrtable && cstr) {
 124         avt_errmsg (STM_ERRMSG, "041", AVT_ERROR);
 125         return NULL;
 126     }
 127
 128     if (nsdA && nsdB) {
 129         delaytabAB = stm_modtbl_create (nsdA, nsdB, STM_INPUT_SLEW, STM_CLOCK_SLEW);
 130         stm_modtbl_Ximportslewaxis (delaytabAB, delaytabA);
 131         stm_modtbl_Yimportckslewaxis (delaytabAB, delaytabB);
 132         for (i = 0; i < nsdA; i++) {
 133             inslewA = stm_modtbl_getslewaxisval (delaytabA, i);
 134             delayA = stm_modtbl_delay (delaytabA, loadA, inslewA);
 135             slewA = stm_modtbl_slew (slewtabA, loadA, inslewA);
 136             for (j = 0; j < nsdB; j++) {
 137                 ckslewB = stm_modtbl_getckslewaxisval (delaytabB, j);
 138                 delayB = stm_modtbl_constraint (delaytabB, slewA, ckslewB);
 139                 stm_modtbl_set2Dval (delaytabAB, i, j, delayA + cstr + delayB);
 140             }
 141         }
 142     }
 143
 144     if (nsdA && !nsdB) {
 145         delaytabAB = stm_modtbl_create (nsdA, 0, STM_INPUT_SLEW, STM_NOTYPE);
 146         stm_modtbl_Ximportslewaxis (delaytabAB, delaytabA);
 147         for (i = 0; i < nsdA; i++) {
 148             inslewA = stm_modtbl_getslewaxisval (delaytabA, i);
 149             delayA = stm_modtbl_delay (delaytabA, loadA, inslewA);
 150             slewA = stm_modtbl_slew (slewtabA, loadA, inslewA);
 151             delayB = stm_modtbl_constraint (delaytabB, slewA, STM_DONTCARE);
 152             stm_modtbl_set1Dval (delaytabAB, i, delayA + cstr + delayB);
 153         }
 154     }
 155
 156     if (!nsdA && nsdB) {
 157         delaytabAB = stm_modtbl_create (nsdB, 0, STM_CLOCK_SLEW, STM_NOTYPE);
 158         stm_modtbl_Ximportckslewaxis (delaytabAB, delaytabB);
 159         delayA = stm_modtbl_delay (delaytabA, loadA, STM_DONTCARE);
 160         slewA = stm_modtbl_slew (slewtabA, loadA, STM_DONTCARE);
 161         for (i = 0; i < nsdB; i++) {
 162             ckslewB = stm_modtbl_getckslewaxisval (delaytabB, i);
 163             delayB  = stm_modtbl_constraint (delaytabB, slewA, ckslewB);
 164             stm_modtbl_set1Dval (delaytabAB, i, delayA + cstr + delayB);
 165         }
 166     }
 167
 168     if (!nsdA && !nsdB) {
 169         delaytabAB = stm_modtbl_create (0, 0, STM_NOTYPE, STM_NOTYPE) ;
 170         delayA = stm_modtbl_delay (delaytabA, loadA, STM_DONTCARE) ;
 171         slewA = stm_modtbl_slew (slewtabA, loadA, STM_DONTCARE);
 172         delayB = stm_modtbl_constraint (delaytabB, slewA, STM_DONTCARE) ;
 173         stm_modtbl_setconst (delaytabAB, delayA + cstr + delayB) ;
 174     }
 175
 176     if (!delaytabAB)
 177         avt_errmsg (STM_ERRMSG, "029", AVT_ERROR);
 178
 179     return delaytabAB;
 180 }
 181
 182 /****************************************************************************/
 183
 184 timing_table *stm_modtbl_mergecc (timing_table *dttable, timing_table *dstable, timing_table *cstrtable, float cstr, float dtload)
 185 {
 186     timing_table *delaytabAB = NULL;
 187     timing_table *delaytabA;
 188     timing_table *slewtabA;
 189     timing_table *delaytabB;
 190     int           nldA,           /* nb load delaytable A */
 191                   nsdA,           /* nb slew delaytable A */
 192                   nsdB,           /* nb load delaytable B */
 193                   nldB;           /* nb slew delaytable B */
 194     int           i, j;
 195     float         inslewA, inslewB, slewA;
 196     float         delayA, delayB;
 197     float         loadA = dtload;
 198
 199     delaytabA = dttable;
 200     slewtabA = dstable;
 201     delaytabB = cstrtable;
 202
 203     nldA = stm_modtbl_getnload (delaytabA);
 204     nsdA = stm_modtbl_getnslew (delaytabA);
 205     nldB = stm_modtbl_getnload (delaytabB);
 206     nsdB = stm_modtbl_getnslew (delaytabB);
 207
 208     if (cstrtable && cstr) {
 209         avt_errmsg (STM_ERRMSG, "041", AVT_ERROR);
 210         return NULL;
 211     }
 212
 213     if (nsdA && nsdB) {
 214         delaytabAB = stm_modtbl_create (nsdB, nsdA, STM_INPUT_SLEW, STM_CLOCK_SLEW);
 215         stm_modtbl_Ximportslewaxis (delaytabAB, delaytabB);
 216         stm_modtbl_Yimportslewaxis (delaytabAB, delaytabA);
 217         for (i = 0; i < nsdA; i++) {
 218             inslewA = stm_modtbl_getslewaxisval (delaytabA, i);
 219             delayA = stm_modtbl_delay (delaytabA, loadA, inslewA);
 220             slewA = stm_modtbl_slew (slewtabA, loadA, inslewA);
 221             for (j = 0; j < nsdB; j++) {
 222                 inslewB = stm_modtbl_getslewaxisval (delaytabB, j);
 223                 delayB = stm_modtbl_constraint (delaytabB, inslewB, slewA);
 224                 stm_modtbl_set2Dval (delaytabAB, j, i, delayA + cstr + delayB);
 225             }
 226         }
 227     }
 228
 229     if (nsdA && !nsdB) {
 230         delaytabAB = stm_modtbl_create (nsdA, 0, STM_CLOCK_SLEW, STM_NOTYPE);
 231         stm_modtbl_Ximportslewaxis (delaytabAB, delaytabA);
 232         for (i = 0; i < nsdA; i++) {
 233             inslewA = stm_modtbl_getslewaxisval (delaytabA, i);
 234             delayA = stm_modtbl_delay (delaytabA, loadA, inslewA);
 235             slewA = stm_modtbl_slew (slewtabA, loadA, inslewA);
 236             delayB = stm_modtbl_constraint (delaytabB, STM_DONTCARE, slewA);
 237             stm_modtbl_set1Dval (delaytabAB, i, delayA + cstr + delayB);
 238         }
 239     }
 240
 241     if (!nsdA && nsdB) {
 242         delaytabAB = stm_modtbl_create (nsdB, 0, STM_INPUT_SLEW, STM_NOTYPE);
 243         stm_modtbl_Ximportslewaxis (delaytabAB, delaytabB);
 244         delayA = stm_modtbl_delay (delaytabA, loadA, STM_DONTCARE);
 245         slewA = stm_modtbl_slew (slewtabA, loadA, STM_DONTCARE);
 246         for (i = 0; i < nsdB; i++) {
 247             inslewB = stm_modtbl_getslewaxisval (delaytabB, i);
 248             delayB  = stm_modtbl_constraint (delaytabB, inslewB, slewA);
 249             stm_modtbl_set1Dval (delaytabAB, i, delayA + cstr + delayB);
 250         }
 251     }
 252
 253     if (!nsdA && !nsdB) {
 254         delaytabAB = stm_modtbl_create (0, 0, STM_NOTYPE, STM_NOTYPE) ;
 255         delayA = stm_modtbl_delay (delaytabA, loadA, STM_DONTCARE) ;
 256         slewA = stm_modtbl_slew (slewtabA, loadA, STM_DONTCARE);
 257         delayB = stm_modtbl_constraint (delaytabB, STM_DONTCARE, slewA) ;
 258         stm_modtbl_setconst (delaytabAB, delayA + cstr + delayB) ;
 259     }
 260
 261     if (!delaytabAB)
 262         avt_errmsg (STM_ERRMSG, "029", AVT_ERROR);
 263
 264     return delaytabAB;
 265 }
 266
 267 /****************************************************************************/
 268
 269 timing_table *stm_modtbl_merge (timing_table *delaytabA, timing_table *delaytabB, float delay, float load, float slew)
 270 {
 271     timing_table *delaytabAB;
 272     int           nldA,           /* nb load delaytable A */
 273                   nsdA,           /* nb slew delaytable A */
 274                   nsdB,           /* nb load delaytable B */
 275                   nldB;           /* nb slew delaytable B */
 276     int           i, j;
 277     float         inslew, outload;
 278     float         delayA, delayB;
 279
 280     nldA = stm_modtbl_getnload (delaytabA);
 281     nsdA = stm_modtbl_getnslew (delaytabA);
 282     nldB = stm_modtbl_getnload (delaytabB);
 283     nsdB = stm_modtbl_getnslew (delaytabB);
 284
 285     if (nsdA && nldB) {
 286         delaytabAB = stm_modtbl_create (nsdA, nldB, STM_INPUT_SLEW, STM_LOAD);
 287         stm_modtbl_Ximportslewaxis (delaytabAB, delaytabA);
 288         stm_modtbl_Yimportloadaxis (delaytabAB, delaytabB);
 289         for (i = 0; i < nsdA; i++) {
 290             inslew = stm_modtbl_getslewaxisval (delaytabA, i);
 291             delayA = stm_modtbl_delay (delaytabA, load, inslew);
 292             for (j = 0; j < nldB; j++) {
 293                 outload = stm_modtbl_getloadaxisval (delaytabB, j);
 294                 delayB = stm_modtbl_delay (delaytabB, outload, slew);
 295                 stm_modtbl_set2Dval (delaytabAB, i, j, delayA + delay + delayB);
 296             }
 297         }
 298     }
 299
 300     if (nsdA && !nldB) {
 301         delaytabAB = stm_modtbl_create (nsdA, 0, STM_INPUT_SLEW, STM_NOTYPE);
 302         stm_modtbl_Ximportslewaxis (delaytabAB, delaytabA);
 303         delayB = stm_modtbl_delay (delaytabB, STM_DONTCARE, slew);
 304         for (i = 0; i < nsdA; i++) {
 305             inslew = stm_modtbl_getslewaxisval (delaytabA, i);
 306             delayA = stm_modtbl_delay (delaytabA, load, inslew);
 307             stm_modtbl_set1Dval (delaytabAB, i, delayA + delay + delayB);
 308         }
 309     }
 310
 311     if (!nsdA && nldB) {
 312         delaytabAB = stm_modtbl_create (nldB, 0, STM_LOAD, STM_NOTYPE);
 313         stm_modtbl_Ximportloadaxis (delaytabAB, delaytabB);
 314         delayA = stm_modtbl_delay (delaytabA, load, STM_DONTCARE);
 315         for (i = 0; i < nldB; i++) {
 316             outload = stm_modtbl_getloadaxisval (delaytabB, i);
 317             delayB  = stm_modtbl_delay (delaytabB, outload, slew);
 318             stm_modtbl_set1Dval (delaytabAB, i, delayA + delay + delayB);
 319         }
 320     }
 321
 322     if (!nsdA && !nldB) {
 323         delaytabAB = stm_modtbl_create (0, 0, STM_NOTYPE, STM_NOTYPE) ;
 324         delayA = stm_modtbl_delay (delaytabA, load, STM_DONTCARE) ;
 325         delayB = stm_modtbl_delay (delaytabB, STM_DONTCARE, slew) ;
 326         stm_modtbl_setconst (delaytabAB, delayA + delay + delayB) ;
 327     }
 328
 329     if (!delaytabAB)
 330         avt_errmsg (STM_ERRMSG, "029", AVT_ERROR);
 331
 332     return delaytabAB;
 333 }
 334
 335 /****************************************************************************/
 336
 337 timing_table *stm_modtbl_multidelaymerge (timing_table *stableA,
 338                                        timing_table *dtableA,
 339                                        float         capa,
 340                                        timing_table *dtableB)
 341 {
 342    timing_table *dtable = NULL;
 343    int           nl, ns;
 344    int           i, j;
 345    float         delay = 0, slew, newslew, load;
 346
 347    ns = stm_modtbl_getnslew (dtableA);
 348    nl = stm_modtbl_getnload (dtableB);
 349
 350    if (ns && nl) {
 351       dtable = stm_modtbl_create (ns, nl, STM_INPUT_SLEW, STM_LOAD);
 352       stm_modtbl_Ximportslewaxis (dtable, dtableA);
 353       stm_modtbl_Yimportloadaxis (dtable, dtableB);
 354       for (i = 0; i < ns; i++) {
 355          slew = stm_modtbl_getslewaxisval (dtableA, i);
 356          for (j = 0; j < nl; j++) {
 357             load = stm_modtbl_getloadaxisval (dtableB, j);
 358             newslew = slew;
 359             delay = stm_modtbl_delay (dtableA, capa, slew);
 360             newslew = stm_modtbl_slew (stableA, capa, newslew);
 361             delay += stm_modtbl_delay (dtableB, load, slew);
 362             stm_modtbl_set2Dval (dtable, i, j, delay);
 363          }
 364       }
 365    }
 366    else
 367    if (ns && !nl) {
 368       dtable = stm_modtbl_create (ns, 0, STM_INPUT_SLEW, STM_NOTYPE);
 369       stm_modtbl_Ximportslewaxis (dtable, dtableA);
 370       for (i = 0; i < ns; i++) {
 371          slew = stm_modtbl_getslewaxisval (dtableA, i);
 372          delay = stm_modtbl_delay (dtableA, capa, slew);
 373          slew = stm_modtbl_slew (stableA, capa, slew);
 374          delay = stm_modtbl_delay (dtableB, STM_DONTCARE, slew);
 375          stm_modtbl_set1Dval (dtable, i, delay);
 376       }
 377    }
 378
 379    return dtable;
 380 }
 381
 382 /****************************************************************************/
 383
 384 timing_table *stm_modtbl_multidelaymerge_n (chain_list *stables, chain_list *dtables)
 385 {
 386    timing_table *dtable = NULL, *dtable_org, *dtable_end;
 387    int           nl, ns;
 388    int           i, j;
 389    chain_list   *dch, *sch;
 390    float         delay = 0, slew, newslew, load;
 391
 392    dtable_org = (timing_table*)dtables->DATA;
 393    ns = stm_modtbl_getnslew (dtable_org);
 394
 395    for (dch = dtables; dch->NEXT; dch = dch->NEXT);
 396    dtable_end = (timing_table*)dch->DATA;
 397    nl = stm_modtbl_getnload (dtable_end);
 398
 399    if (ns && nl) {
 400       dtable = stm_modtbl_create (ns, nl, STM_INPUT_SLEW, STM_LOAD);
 401       stm_modtbl_Ximportslewaxis (dtable, dtable_org);
 402       stm_modtbl_Yimportloadaxis (dtable, dtable_end);
 403       for (i = 0; i < ns; i++) {
 404          slew = stm_modtbl_getslewaxisval (dtable_org, i);
 405          for (j = 0; j < nl; j++) {
 406             load = stm_modtbl_getloadaxisval (dtable_end, j);
 407             newslew = slew;
 408             delay = 0;
 409             for (dch = dtables, sch = stables; dch->NEXT; dch = dch->NEXT, sch = sch->NEXT) {
 410                delay += stm_modtbl_delay ((timing_table*)dch->DATA, STM_DONTCARE, slew);
 411                newslew = stm_modtbl_slew ((timing_table*)sch->DATA, STM_DONTCARE, newslew);
 412             }
 413             delay += stm_modtbl_delay ((timing_table*)dch->DATA, load, slew);
 414             newslew = stm_modtbl_slew ((timing_table*)sch->DATA, load, newslew);
 415             stm_modtbl_set2Dval (dtable, i, j, delay);
 416          }
 417       }
 418    }
 419    else
 420    if (ns && !nl) {
 421       dtable = stm_modtbl_create (ns, 0, STM_INPUT_SLEW, STM_NOTYPE);
 422       stm_modtbl_Ximportslewaxis (dtable, dtable_org);
 423       for (i = 0; i < ns; i++) {
 424          slew = stm_modtbl_getslewaxisval (dtable_org, i);
 425          delay = 0;
 426          for (dch = dtables, sch = stables; dch; dch = dch->NEXT, sch = sch->NEXT) {
 427             delay += stm_modtbl_delay ((timing_table*)dch->DATA, STM_DONTCARE, slew);
 428             slew = stm_modtbl_slew ((timing_table*)sch->DATA, STM_DONTCARE, slew);
 429          }
 430          stm_modtbl_set1Dval (dtable, i, delay);
 431       }
 432    }
 433
 434    return dtable;
 435 }
 436
 437 /****************************************************************************/
 438
 439 timing_table *stm_modtbl_multislewmerge (timing_table *stableA, float capa, timing_table *stableB)
 440 {
 441    timing_table *stable = NULL;
 442    int           nl, ns;
 443    int           i, j;
 444    float         slew, load, newslew;
 445
 446    ns  = stm_modtbl_getnslew (stableA);
 447    nl  = stm_modtbl_getnload (stableB);
 448
 449    if (ns && nl) {
 450       stable = stm_modtbl_create (ns, nl, STM_INPUT_SLEW, STM_LOAD);
 451       stm_modtbl_Ximportslewaxis (stable, stableA);
 452       stm_modtbl_Yimportloadaxis (stable, stableB);
 453
 454       for (i = 0; i < ns; i++) {
 455          slew = stm_modtbl_getslewaxisval (stableA, i);
 456          for (j = 0; j < nl; j++) {
 457             load = stm_modtbl_getloadaxisval (stableB, j);
 458             newslew = stm_modtbl_slew (stableA, capa, slew);
 459             newslew = stm_modtbl_slew (stableB, load, newslew);
 460             stm_modtbl_set2Dval (stable, i, j, newslew);
 461          }
 462       }
 463    }
 464    else
 465    if (ns && !nl) {
 466       stable = stm_modtbl_create (ns, 0, STM_INPUT_SLEW, STM_NOTYPE);
 467       stm_modtbl_Ximportslewaxis (stable, stableA);
 468
 469       for (i = 0; i < ns; i++) {
 470          slew = stm_modtbl_getslewaxisval (stableA, i);
 471          slew = stm_modtbl_slew (stableA, capa, slew);
 472          slew = stm_modtbl_slew (stableB, capa, slew);
 473          stm_modtbl_set1Dval (stable, i, slew);
 474       }
 475    }
 476
 477    return stable;
 478 }
 479
 480 /****************************************************************************/
 481
 482 timing_table *stm_modtbl_multislewmerge_n (chain_list *stables)
 483 {
 484    timing_table *stable = NULL, *stable_org, *stable_end;
 485    int           nl, ns;
 486    int           i, j;
 487    float         slew, load, newslew;
 488    chain_list   *sch;
 489
 490    stable_org = (timing_table*)stables->DATA;
 491    ns  = stm_modtbl_getnslew (stable_org);
 492
 493    for (sch = stables; sch->NEXT; sch = sch->NEXT);
 494    stable_end = (timing_table*)sch->DATA;
 495    nl  = stm_modtbl_getnload (stable_end);
 496
 497    if (ns && nl) {
 498       stable = stm_modtbl_create (ns, nl, STM_INPUT_SLEW, STM_LOAD);
 499       stm_modtbl_Ximportslewaxis (stable, stable_org);
 500       stm_modtbl_Yimportloadaxis (stable, stable_end);
 501
 502       for (i = 0; i < ns; i++) {
 503          slew = stm_modtbl_getslewaxisval (stable_org, i);
 504          for (j = 0; j < nl; j++) {
 505             load = stm_modtbl_getloadaxisval (stable_end, j);
 506             newslew = slew;
 507             for (sch = stables; sch->NEXT; sch = sch->NEXT)
 508                newslew = stm_modtbl_slew ((timing_table*)sch->DATA, STM_DONTCARE, newslew);
 509             newslew = stm_modtbl_slew ((timing_table*)sch->DATA, load, newslew);
 510             stm_modtbl_set2Dval (stable, i, j, newslew);
 511          }
 512       }
 513    }
 514    else
 515    if (ns && !nl) {
 516       stable = stm_modtbl_create (ns, 0, STM_INPUT_SLEW, STM_NOTYPE);
 517       stm_modtbl_Ximportslewaxis (stable, stable_org);
 518
 519       for (i = 0; i < ns; i++) {
 520          slew = stm_modtbl_getslewaxisval (stable_org, i);
 521          for (sch = stables; sch; sch = sch->NEXT)
 522             slew = stm_modtbl_slew ((timing_table*)sch->DATA, STM_DONTCARE, slew);
 523          stm_modtbl_set1Dval (stable, i, slew);
 524       }
 525    }
 526
 527    return stable;
 528 }
 529
 530 /****************************************************************************/
 531
 532 int stm_modtbl_sametablesize (timing_table *tableA, timing_table *tableB)
 533 {
 534    if (tableA && !tableB)
 535       return 0;
 536
 537    if (!tableA && tableB)
 538       return 0;
 539
 540    if (!tableA && !tableB)
 541       return 1;
 542
 543    if (tableA->SET1D && tableB->SET1D)
 544       return 1;
 545
 546    if (tableA->SET2D && tableB->SET2D)
 547       return 1;
 548
 549    return 0;
 550 }
 551
 552