home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1993 #3 / NN_1993_3.iso / spool / alt / sources / 3104 < prev    next >
Encoding:
Text File  |  1993-01-28  |  34.2 KB  |  1,234 lines
  1. Path: sparky!uunet!crdgw1!rpi!usc!howland.reston.ans.net!bogus.sura.net!darwin.sura.net!ukma!cs.widener.edu!dsinc!ub!galileo.cc.rochester.edu!ee.rochester.edu!rbc!al
  2. From: al@rbc.uucp (Al Davis)
  3. Newsgroups: alt.sources
  4. Subject: ACS  circuit simulator  part 19/20
  5. Message-ID: <1993Jan27.041125.12131@rbc.uucp>
  6. Date: 27 Jan 93 04:11:25 GMT
  7. Sender: al@rbc.uucp (Al Davis)
  8. Organization: Huh?
  9. Lines: 1223
  10.  
  11. #! /bin/sh
  12. # This is a shell archive, meaning:
  13. # 1. Remove everything above the #! /bin/sh line.
  14. # 2. Save the resulting text in a file.
  15. # 3. Execute the file with /bin/sh (not csh) to create the files:
  16. #    src/skiparg.c
  17. #    src/skipbl.c
  18. #    src/solve.c
  19. #    src/status.c
  20. #    src/stubs.c
  21. #    src/sweep.c
  22. #    src/syscall.c
  23. #    src/utos.c
  24. #    src/version.c
  25. #    src/xopen.c
  26. #    src/xsolve.c
  27. #    src/_msc.c
  28. #    src/_unix.c
  29. # This archive created: Tue Jan 26 22:51:14 1993
  30. export PATH; PATH=/bin:$PATH
  31. if test -f 'src/skiparg.c'
  32. then
  33.     echo shar: will not over-write existing file "'src/skiparg.c'"
  34. else
  35. cat << \SHAR_EOF > 'src/skiparg.c'
  36. /* skiparg  01/05/93
  37.  * Copyright 1983-1992   Albert Davis
  38.  * skip an argument in a string
  39.  */
  40. #include "ecah.h"
  41. #include "declare.h"
  42.  
  43. void skiparg(cmd,cnt)
  44. const char *cmd;
  45. int  *cnt;
  46. {
  47.  if (!skipcom(cmd,cnt)){
  48.     if (cmd[*cnt])
  49.        (*cnt)++;
  50.     while (isalnum(cmd[*cnt]) || cmd[*cnt]=='.')
  51.        (*cnt)++;
  52.     skipcom(cmd,cnt);
  53.  }
  54. }
  55. SHAR_EOF
  56. fi # end of overwriting check
  57. if test -f 'src/skipbl.c'
  58. then
  59.     echo shar: will not over-write existing file "'src/skipbl.c'"
  60. else
  61. cat << \SHAR_EOF > 'src/skipbl.c'
  62. /* skipbl  01/05/93
  63.  * Copyright 1983-1992   Albert Davis
  64.  * skip whitespace.  (any non-graphic character is ws)
  65.  * =,(,) are also ws
  66.  * update string pointer
  67.  * pointer points to first non-space
  68.  * also ..... skipcom, skiplparen, skiprparen.  obvious
  69.  * all but skipbl returns the # of them skipped (1 or 0).
  70.  */
  71. #include "ecah.h"
  72. #include "declare.h"
  73. /*--------------------------------------------------------------------------*/
  74.     void    skipbl(const char*,int*);
  75.     int    skipcom(const char*,int*);
  76.     int    skiplparen(const char*,int*);
  77.     int    skiprparen(const char*,int*);
  78.     int    skipequal(const char*,int*);
  79. /*--------------------------------------------------------------------------*/
  80. void skipbl(cmd,cnt)
  81. const char *cmd;
  82. int  *cnt;
  83. {
  84.  while (cmd[*cnt]  &&  (!isgraph(cmd[*cnt])))
  85.     (*cnt)++ ;
  86. }
  87. /*--------------------------------------------------------------------------*/
  88. int skipcom(cmd,cnt)
  89. const char *cmd;
  90. int  *cnt;
  91. {
  92.  skipbl(cmd,cnt);
  93.  if (cmd[*cnt] == ','  ||  cmd[*cnt] == '='){
  94.     (*cnt)++;
  95.     skipbl(cmd,cnt);
  96.     return 1;
  97.  }else{
  98.     skipbl(cmd,cnt);
  99.     return 0;
  100.  }
  101. }
  102. /*--------------------------------------------------------------------------*/
  103. int skiplparen(cmd,cnt)
  104. const char *cmd;
  105. int  *cnt;
  106. {
  107.  skipbl(cmd,cnt);
  108.  if (cmd[*cnt] == '('  ||  cmd[*cnt] == '['){
  109.     (*cnt)++;
  110.     skipbl(cmd,cnt);
  111.     return 1;
  112.  }else{
  113.     skipbl(cmd,cnt);
  114.     return 0;
  115.  }
  116. }
  117. /*--------------------------------------------------------------------------*/
  118. int skiprparen(cmd,cnt)
  119. const char *cmd;
  120. int  *cnt;
  121. {
  122.  skipbl(cmd,cnt);
  123.  if (cmd[*cnt] == ')'  ||  cmd[*cnt] == ']'){
  124.     (*cnt)++;
  125.     skipbl(cmd,cnt);
  126.     return 1;
  127.  }else{
  128.     skipbl(cmd,cnt);
  129.     return 0;
  130.  }
  131. }
  132. /*--------------------------------------------------------------------------*/
  133. int skipequal(cmd,cnt)
  134. const char *cmd;
  135. int  *cnt;
  136. {
  137.  skipbl(cmd,cnt);
  138.  if (cmd[*cnt] == '='){
  139.     (*cnt)++;
  140.     skipbl(cmd,cnt);
  141.     return 1;
  142.  }else{
  143.     skipbl(cmd,cnt);
  144.     return 0;
  145.  }
  146. }
  147. /*--------------------------------------------------------------------------*/
  148. /*--------------------------------------------------------------------------*/
  149. SHAR_EOF
  150. fi # end of overwriting check
  151. if test -f 'src/solve.c'
  152. then
  153.     echo shar: will not over-write existing file "'src/solve.c'"
  154. else
  155. cat << \SHAR_EOF > 'src/solve.c'
  156. /* solve  12/29/92
  157.  * Copyright 1983-1992   Albert Davis
  158.  * LU decomposition and fwd-back substitution for real numbers
  159.  * 2 modules:  lu() and solve()
  160.  * lu() does LU decomposition using the Crout algorithm (modified)
  161.  * solve() does forward and back substitution after calling lu() if necessary
  162.  */
  163. #include "ecah.h"
  164. #include "array.h"
  165. #include "error.h"
  166. #include "mode.h"
  167. #include "nodestat.h"
  168. #include "options.h"
  169. #include "status.h"
  170. #include "declare.h"
  171. /*--------------------------------------------------------------------------*/
  172.     void    solve(void);
  173. static    void    lu(void);
  174. static    double    dotprod(int,int,int);
  175. /*--------------------------------------------------------------------------*/
  176. extern const struct options opt;
  177. extern       struct status stats;
  178.  
  179. extern double *recon,*imcon,*fwcon; /* constant terms, answer column        */
  180. extern struct nodestat *nstat;
  181.  
  182. extern const double trtime;
  183. extern const int *basnode;        /* array of lowest node connected here  */
  184. /*--------------------------------------------------------------------------*/
  185. #ifdef max
  186. #undef max
  187. #endif
  188. #define max(x,y)    ( ((x)>(y)) ? (x) : (y) )
  189. /*--------------------------------------------------------------------------*/
  190. void solve()
  191. {
  192.  int jj, ii;
  193.  
  194.  lu();
  195.  time_start(&(stats.back));
  196.  for (ii = 1;  ii <= stats.total_nodes;  ++ii){        /* forward substitution */
  197.     fwcon[ii] = recon[ii];
  198.     for (jj = basnode[ii];   jj < ii;   ++jj)
  199.        fwcon[ii] -= *LUl(ii,jj) * fwcon[jj];
  200.     fwcon[ii] /= *LUd(ii,ii);
  201.  }
  202.  if (opt.foooo!=4){
  203.     for (ii = stats.total_nodes;  ii >= 1;  --ii){
  204.       imcon[ii] = fwcon[ii];
  205.       nstat[ii].aiter = stats.iter[iTOTAL];
  206.     }
  207.     for (jj = stats.total_nodes;  jj > 1;  --jj){   /* back substitution    */
  208.        for (ii = basnode[jj];   ii < jj;   ++ii){
  209.        imcon[ii] -= *LUu(ii,jj) * imcon[jj];
  210.        }
  211.     }
  212.  }else{
  213.     for (ii = stats.total_nodes;  ii >= 1;  --ii){
  214.        /*if (nstat[ii].mode != mGATE){*/
  215.       imcon[ii] = fwcon[ii];
  216.       for (jj = ii+1;  jj <= stats.total_nodes;  ++jj){
  217.          imcon[ii] -= *im(ii,jj) * imcon[jj];
  218.       }
  219.       nstat[ii].aiter = stats.iter[iTOTAL];
  220.       /*nstat[ii].mode = mLU;*/
  221.       /*nstat[ii].lastchange = trtime;*/
  222.        /*}*/
  223.     }
  224.  }
  225.  time_stop(&(stats.back));
  226.  if (opt.foooo == 1){
  227.     for (ii=1; ii<=stats.total_nodes; ++ii){
  228.        for (jj=1; jj<=stats.total_nodes; ++jj){
  229.       printf("%9.2e ", *re(ii,jj));
  230.        }
  231.        printf("%9.2e\n", recon[ii]);
  232.     }
  233.  }
  234. }
  235. /*--------------------------------------------------------------------------*/
  236. static void lu()
  237. {
  238.  int ii, jj, mm;
  239.  int bn;
  240.  
  241.  time_start(&(stats.lu));
  242.  for (mm = 1;   mm <= stats.total_nodes;   ++mm){
  243.     bn = basnode[mm];
  244.     if (bn < mm){
  245.        *LUu(bn,mm) = *AAu(bn,mm) / *LUd(bn,bn);
  246.        for (ii = bn+1;  ii<mm;  ii++){
  247.       *LUu(ii,mm) = (*AAu(ii,mm) - dotprod(ii,mm,ii)) / *LUd(ii,ii);
  248.        }
  249.        *LUl(mm,bn) = *AAl(mm,bn);
  250.        for (jj = bn+1;  jj<mm;  jj++){
  251.       *LUl(mm,jj) = *AAl(mm,jj) - dotprod(mm,jj,jj);
  252.        }
  253.        /* jj == mm */{
  254.       *LUd(mm,mm) = *AAd(mm,mm) - dotprod(mm,mm,mm);
  255.       if (*LUd(mm,mm) == 0.){
  256.          error(bTRACE, "open circuit: node %u\n", mm);
  257.          *LUd(mm,mm) = opt.gmin;
  258.       }
  259.        }
  260.     }else{    /* bn == mm */
  261.        *LUd(mm,mm) = *AAd(mm,mm);
  262.        if (*LUd(mm,mm) == 0.){
  263.       error(bTRACE, "open circuit: node %u\n", mm);
  264.       *LUd(mm,mm) = opt.gmin;
  265.        }
  266.     }
  267.  }
  268.  time_stop(&(stats.lu));
  269. }
  270. /*--------------------------------------------------------------------------*/
  271. static double dotprod(ii,jj,mm)
  272. int ii, jj, mm;
  273. {
  274.  int ind, len;
  275.  int kk;
  276.  double *row, *col;
  277.  double dot = 0.;
  278.  
  279.  kk = max(basnode[ii], basnode[jj]);
  280.  len = mm - kk;
  281.  if (len > 0){
  282.     row = LUl(ii,kk);
  283.     col = LUu(kk,jj);
  284.     /* for (i = kk;   i < mm;   i++) */
  285.     for (ind = 0;   ind < len;   ind++)
  286.         dot += row[-ind] * col[ind];
  287.  }
  288.  return dot;
  289. }
  290. /*--------------------------------------------------------------------------*/
  291. /*--------------------------------------------------------------------------*/
  292. SHAR_EOF
  293. fi # end of overwriting check
  294. if test -f 'src/status.c'
  295. then
  296.     echo shar: will not over-write existing file "'src/status.c'"
  297. else
  298. cat << \SHAR_EOF > 'src/status.c'
  299. /* status  02/15/92
  300.  * Copyright 1983-1992   Albert Davis
  301.     Displays the status of the system.    Makes all the calculations associated
  302. with allocating memory but does not actually allocate it, unless necessary to
  303. make the rest of the calculations.
  304.  
  305.     If "allocate" is changed, this must also be changed.
  306.  
  307. */
  308. #include "ecah.h"
  309. #include "branch.h"
  310. #include "error.h"
  311. #include "io.h"
  312. #include "mode.h"
  313. #include "status.h"
  314. #include "declare.h"
  315. /*--------------------------------------------------------------------------*/
  316.     void    cmd_status(void);
  317. static    void    fixoverhead(struct status*);
  318. static    void    printtime(char*, struct time_s);
  319. /*--------------------------------------------------------------------------*/
  320. extern const struct ioctrl io;
  321. extern       struct status stats;
  322.  
  323. extern const unsigned aspace;
  324. /*--------------------------------------------------------------------------*/
  325. void cmd_status()
  326. { 
  327.  mprintf(io.mstdout,"ACS   System status\n");
  328.  allocate(sSTATUS);
  329.  
  330.  if (stats.total_nodes)
  331.     stats.density = ((double)(aspace-1)*100.)/
  332.                 ((double)stats.total_nodes*(double)stats.total_nodes);
  333.  else
  334.     stats.density = 0.;
  335.  
  336.  mprintf(io.mstdout,
  337.  "command      --------  last  --------    --------  total  --------\n");
  338.  mprintf(io.mstdout,
  339.  "               user      sys    total       user      sys    total\n");
  340.  printtime("get",     stats.get);
  341.  printtime("op",      stats.op);
  342.  printtime("dc",      stats.dc);
  343.  printtime("tran",    stats.tran);
  344.  printtime("fourier", stats.four);
  345.  printtime("ac",      stats.ac);
  346.  
  347.  mprintf(io.mstdout,
  348.  "function     --------  last  --------    --------  total  --------\n");
  349.  mprintf(io.mstdout,
  350.  "               user      sys    total       user      sys    total\n");
  351.  printtime("setup",   stats.setup);
  352.  printtime("order",   stats.order);
  353.  
  354.  fixoverhead(&stats);
  355.  mprintf(io.mstdout,
  356.  "function     --------  last  --------    --------  total  --------\n");
  357.  mprintf(io.mstdout,
  358.  "               user      sys    total       user      sys    total\n");
  359.  printtime("load",    stats.load);
  360.  printtime("lu",      stats.lu);
  361.  printtime("back",    stats.back);
  362.  printtime("review",  stats.review);
  363.  printtime("output",  stats.output);
  364.  printtime("overhead",stats.overhead);
  365.  printtime("total",   stats.total);
  366.  
  367.  mprintf(io.mstdout,"iterations: op=%d, dc=%d, tran=%d, fourier=%d, total=%d\n",
  368.      stats.iter[sOP], stats.iter[sDC], stats.iter[sTRAN], stats.iter[sFOURIER],
  369.      stats.iter[iTOTAL]);
  370.  mprintf(io.mstdout,"nodes: user=%d, subckt=%d, model=%d, total=%d\n",
  371.      stats.user_nodes, stats.subckt_nodes, stats.model_nodes,
  372.      stats.total_nodes);
  373.  mprintf(io.mstdout,"density=%.1f%%\n", stats.density);
  374. #ifdef NEVER
  375.  mprintf(io.mstdout,"diodes=%d, bjts=%d, mosfets=%d, gates=%d subckts=%d\n",
  376.      stats.diodes, stats.bjts, stats.mosfets, stats.gates, stats.subckts);
  377.  mprintf(io.mstdout,"matrix: terms=%d, fills=%d, total=%d, ops=%d\n",
  378.      stats.matrix_terms, stats.matrix_fills, stats.matrix_total,
  379.      stats.matrix_ops);
  380. #endif
  381. }
  382. /*--------------------------------------------------------------------------*/
  383. static void fixoverhead(x)
  384. struct status *x;
  385. {
  386.  x->overhead.last_user = x->total.last_user - x->load.last_user -
  387.     x->lu.last_user - x->back.last_user - x->output.last_user - x->review.last_user;
  388.  
  389.  x->overhead.last_system = x->total.last_system - x->load.last_system -
  390.     x->lu.last_system - x->back.last_system - x->output.last_system - x->review.last_system;
  391.  
  392.  x->overhead.total_user = x->total.total_user - x->load.total_user -
  393.     x->lu.total_user - x->back.total_user - x->output.total_user - x->review.total_user;
  394.  
  395.  x->overhead.total_system = x->total.total_system - x->load.total_system -
  396.     x->lu.total_system - x->back.total_system - x->output.total_system - x->review.total_system;
  397. }
  398. /*--------------------------------------------------------------------------*/
  399. static void printtime(name, v)
  400. char *name;
  401. struct time_s v;
  402. {
  403.  mprintf(io.mstdout, "%10s %8.2f %8.2f %8.2f   %8.2f %8.2f %8.2f\n", name,
  404.     v.last_user,  v.last_system,  v.last_user  + v.last_system,
  405.     v.total_user, v.total_system, v.total_user + v.total_system);
  406. }
  407. /*--------------------------------------------------------------------------*/
  408. /*--------------------------------------------------------------------------*/
  409. SHAR_EOF
  410. fi # end of overwriting check
  411. if test -f 'src/stubs.c'
  412. then
  413.     echo shar: will not over-write existing file "'src/stubs.c'"
  414. else
  415. cat << \SHAR_EOF > 'src/stubs.c'
  416. /* stubs.c  01/01/93
  417.  * Copyright 1983-1992   Albert Davis
  418.  * stubs to satisfy references to Spice commands not supported here
  419.  */
  420. #include "ecah.h"
  421. #include "error.h"
  422. #include "declare.h"
  423. /*--------------------------------------------------------------------------*/
  424.     void    cmd_alter(const char*,int*);
  425.     void    cmd_disto(const char*,int*);
  426.     void    cmd_model(const char*,int*);
  427.     void    cmd_noise(const char*,int*);
  428.     void    cmd_sens(const char*,int*);
  429.     void    cmd_subckt(const char*,int*);
  430.     void    cmd_temp(const char*,int*);
  431.     void    cmd_tf(const char*,int*);
  432. /*--------------------------------------------------------------------------*/
  433. static    char    e_spice[] = "Spice dot-card not implemented: %s\n";
  434. /*--------------------------------------------------------------------------*/
  435. /*ARGSUSED*/
  436. void cmd_alter(cmd,cnt)
  437. const char *cmd;
  438. int *cnt;
  439. {
  440.  error(bWARNING, e_spice, cmd);
  441. }
  442. /*--------------------------------------------------------------------------*/
  443. /*ARGSUSED*/
  444. void cmd_disto(cmd,cnt)
  445. const char *cmd;
  446. int *cnt;
  447. {
  448.  error(bWARNING, e_spice, cmd);
  449. }
  450. /*--------------------------------------------------------------------------*/
  451. /*ARGSUSED*/
  452. void cmd_model(cmd,cnt)
  453. const char *cmd;
  454. int *cnt;
  455. {
  456.  error(bWARNING, e_spice, cmd);
  457. }
  458. /*--------------------------------------------------------------------------*/
  459. /*ARGSUSED*/
  460. void cmd_noise(cmd,cnt)
  461. const char *cmd;
  462. int *cnt;
  463. {
  464.  error(bWARNING, e_spice, cmd);
  465. }
  466. /*--------------------------------------------------------------------------*/
  467. /*ARGSUSED*/
  468. void cmd_sens(cmd,cnt)
  469. const char *cmd;
  470. int *cnt;
  471. {
  472.  error(bWARNING, e_spice, cmd);
  473. }
  474. /*--------------------------------------------------------------------------*/
  475. /*ARGSUSED*/
  476. void cmd_subckt(cmd,cnt)
  477. const char *cmd;
  478. int *cnt;
  479. {
  480.  error(bWARNING, e_spice, cmd);
  481. }
  482. /*--------------------------------------------------------------------------*/
  483. /*ARGSUSED*/
  484. void cmd_temp(cmd,cnt)
  485. const char *cmd;
  486. int *cnt;
  487. {
  488.  error(bWARNING, e_spice, cmd);
  489. }
  490. /*--------------------------------------------------------------------------*/
  491. /*ARGSUSED*/
  492. void cmd_tf(cmd,cnt)
  493. const char *cmd;
  494. int *cnt;
  495. {
  496.  error(bWARNING, e_spice, cmd);
  497. }
  498. /*--------------------------------------------------------------------------*/
  499. /*--------------------------------------------------------------------------*/
  500. SHAR_EOF
  501. fi # end of overwriting check
  502. if test -f 'src/sweep.c'
  503. then
  504.     echo shar: will not over-write existing file "'src/sweep.c'"
  505. else
  506. cat << \SHAR_EOF > 'src/sweep.c'
  507. /* sweep  12/31/92
  508.  * Copyright 1983-1992   Albert Davis
  509.  * Step a parameter and repeat a group of commands
  510.  */
  511. #include "ecah.h"
  512. #include "branch.h"
  513. #include "error.h"
  514. #include "io.h"
  515. #include "declare.h"
  516. /*--------------------------------------------------------------------------*/
  517.     void    cmd_sweep(const char*,int*);
  518. static    void    buildfile(const char*,int*);
  519. static    void    doit(void);
  520. static    void    setup(const char*,int*);
  521. /*--------------------------------------------------------------------------*/
  522. extern const struct ioctrl io;
  523. extern int crtplot;
  524. extern int swp_count[], swp_steps[];
  525. extern int swp_type[];
  526. extern int swp_nest;
  527. static char tempfile[] = STEPFILE;
  528. /*--------------------------------------------------------------------------*/
  529. void cmd_sweep(cmd,cnt)
  530. const char *cmd;
  531. int  *cnt;
  532. {
  533.  if (cmd[*cnt])
  534.     buildfile(cmd,cnt);
  535.  doit();
  536.  cmd_unfault();
  537. }
  538. /*--------------------------------------------------------------------------*/
  539. static void buildfile(cmd,cnt)
  540. const char *cmd;
  541. int  *cnt;
  542. {
  543.  auto char buffer[BUFLEN];
  544.  static FILE *fptr;
  545.  
  546.  setup(cmd,cnt);
  547.  if (fptr)
  548.      (void)fclose(fptr);
  549.  fptr = fopen( tempfile, "w" );
  550.  if (!fptr)
  551.     error(bERROR, "can't open temporary file\n" );
  552.  (void)fprintf(fptr, "%s\n", cmd );
  553.  
  554.  for (;;){
  555.     (void)getcmd( ">>>", buffer, BUFLEN );
  556.     if ( match(buffer,"GO") )
  557.        break;
  558.     (void)fprintf(fptr,"%s\n",buffer);
  559.  }
  560.  (void)fclose(fptr);
  561.  fptr = (FILE*)NULL;
  562. }
  563. /*--------------------------------------------------------------------------*/
  564. static void doit()
  565. {
  566.  auto char buffer[BUFLEN];
  567.  static FILE *fptr;
  568.  volatile int ind;
  569.  
  570.  for ( swp_count[swp_nest]=0 ; swp_count[swp_nest]<=swp_steps[swp_nest] ;
  571.        swp_count[swp_nest]++ ){
  572.     if (fptr)
  573.        (void)fclose(fptr);
  574.     fptr = fopen(tempfile, "r");
  575.     if (!fptr)
  576.        error(bERROR, "can't open %s\n", tempfile);
  577.     (void)fgets(buffer,BUFLEN,fptr);
  578.     ind = 0;
  579.     if ( pmatch(buffer,&ind,"SWeep") )
  580.        setup(buffer,&ind);
  581.     else
  582.        error(bERROR, "bad file format: %s\n", tempfile);
  583.     strncpy( buffer, "fault                              ", ind);
  584.     buffer[ind-1] = ' ';        /* make sure there is a delimiter   */
  585.                     /* in case the words run together   */
  586.     for (;;){                /* may wipe out one letter of fault */
  587.        (void)cmdproc(buffer);
  588.        if (!fgets(buffer,BUFLEN,fptr))
  589.       break;
  590.        if (!crtplot)
  591.       mprintf(io.mstdout,"%u> %s", swp_count[swp_nest]+1, buffer);
  592.     }
  593.  }
  594.  (void)fclose(fptr);
  595.  fptr = (FILE*)NULL;
  596.  swp_count[swp_nest] = 0;
  597. }
  598. /*--------------------------------------------------------------------------*/
  599. static void setup(cmd,cnt)
  600. const char *cmd;
  601. int  *cnt;
  602. {
  603.  for (;;){
  604.     if (isdigit(cmd[*cnt])){
  605.        swp_steps[swp_nest] = ctoi(cmd,cnt) ;
  606.        swp_steps[swp_nest] = (swp_steps[swp_nest]) ? swp_steps[swp_nest]-1
  607.                            : 0;
  608.     }else if (pmatch(cmd,cnt,"LInear")){
  609.        swp_type[swp_nest] = 0;
  610.     }else if (pmatch(cmd,cnt,"LOg")){
  611.        swp_type[swp_nest] = 'L';
  612.     }else{
  613.        break;
  614.     }
  615.  }
  616. }
  617. /*--------------------------------------------------------------------------*/
  618. /*--------------------------------------------------------------------------*/
  619. SHAR_EOF
  620. fi # end of overwriting check
  621. if test -f 'src/syscall.c'
  622. then
  623.     echo shar: will not over-write existing file "'src/syscall.c'"
  624. else
  625. cat << \SHAR_EOF > 'src/syscall.c'
  626. /* syscall  10/08/91
  627.  * Copyright 1983-1992   Albert Davis
  628.  * system calls: change directory, invoke another program, invoke editor, etc.
  629.  */
  630. #include "ecah.h"
  631. #include "error.h"
  632. #include "io.h"
  633. #include "declare.h"
  634. /*--------------------------------------------------------------------------*/
  635.     void    cmd_edit(const char*,int*);
  636.     void    cmd_system(const char*,int*);
  637.     void    cmd_chdir(const char*,int*);
  638. /*--------------------------------------------------------------------------*/
  639. extern const struct ioctrl io;
  640. extern char e_int[];
  641. /*--------------------------------------------------------------------------*/
  642. /* cmd_edit: (command) invoke user defined editor on the netlist
  643.  * if command has an argument, it edits that file instead
  644.  * else actually edits a temporary file, and reads it back.
  645.  */
  646. void cmd_edit(cmd,cnt)
  647. const char *cmd;
  648. int  *cnt;
  649. {
  650.  char *editor;
  651.  char name[BUFLEN];
  652.  char args[BUFLEN];
  653.  
  654.  editor = getenv("EDITOR");
  655.  if (!editor)
  656.     error(bERROR, "no editor defined\n");
  657.  
  658.  if (cmd[*cnt]) {
  659.     sprintf(args, "%s %s\n", editor, &cmd[*cnt]);
  660.     system(args);
  661.  } else {
  662.     strcpy(name, EDITFILE);
  663.     (void)mktemp(name);
  664.     sprintf(args, "save %s\n", name);
  665.     (void)cmdproc(args);
  666.     sprintf(args, "%s %s\n", editor, name);
  667.     system(args);
  668.     sprintf(args, "get %s quiet\n", name);
  669.     (void)cmdproc(args);
  670.     unlink(name);
  671.  }
  672. }
  673. /*--------------------------------------------------------------------------*/
  674. /* cmd_system: (! command) call the system to execute a command
  675.  * no arg spawns a shell.
  676.  */
  677. void cmd_system(cmd,cnt)
  678. const char *cmd;
  679. int  *cnt;
  680. {
  681.  if (cmd[*cnt])
  682.     system(&cmd[*cnt]);
  683.  else
  684.     shell();
  685. }
  686. /*--------------------------------------------------------------------------*/
  687. /* cmd_chdir: (cd, chdir command)
  688.  * change working directory, print name of where it ends up
  689.  * no arg just prints, does not change to a default.
  690.  */
  691. void cmd_chdir(cmd,cnt)
  692. const char *cmd;
  693. int  *cnt;
  694. {
  695.  char buf[BUFLEN];
  696.  
  697.  if (cmd[*cnt])
  698.     (void)chdir( ctostr(cmd,cnt,buf,BUFLEN-1) );
  699.  if (getwd(buf))
  700.     mprintf(io.mstderr, "%s\n", buf);
  701.  else
  702.     error(bERROR, e_int, "getcwd");
  703. }
  704. /*--------------------------------------------------------------------------*/
  705. /*--------------------------------------------------------------------------*/
  706. SHAR_EOF
  707. fi # end of overwriting check
  708. if test -f 'src/utos.c'
  709. then
  710.     echo shar: will not over-write existing file "'src/utos.c'"
  711. else
  712. cat << \SHAR_EOF > 'src/utos.c'
  713. /* utos     11/06/89
  714.  * Copyright 1983-1992   Albert Davis
  715.  * unsigned to string
  716.  * num = number to convert.
  717.  * str = string to put it in.  Must be big enough, or else!!
  718.  *        Must have length at least len.
  719.  * len = number of significant digits.
  720.  *     If minus, left justify, else right.
  721.  */
  722. #include "ecah.h"
  723. #include "declare.h"
  724. /*--------------------------------------------------------------------------*/
  725.     char      *utos(unsigned,char*,int);
  726. /*--------------------------------------------------------------------------*/
  727. char *utos( num, str, len )
  728. char *str;
  729. unsigned  num;
  730. int len;
  731. {
  732.  int ii, jj;
  733.  
  734.  if ( len==0 ) return str;                /*    reject zero length  */
  735.  ii = abs(len);
  736.  
  737.  do {                    /*   build string starting at tail  */
  738.     str[--ii] = (char)(num % 10 + '0');
  739.  } while ( (num/=10)>0 && ii>0 );
  740.  
  741.  if (len > 0){                /*     if right justify, fill with blank  */
  742.     while (ii > 0)
  743.        str[--ii] = ' ';
  744.  }else{                    /* else if left justify, move left  */
  745.     for (jj=0;  ii<-len;  )        /*    then fill with blanks        */
  746.        str[jj++] = str[ii++];
  747.     while (jj < -len)
  748.        str[jj++] = ' ';
  749.  }
  750.  return str;
  751. }
  752. /*--------------------------------------------------------------------------*/
  753. /*--------------------------------------------------------------------------*/
  754. SHAR_EOF
  755. fi # end of overwriting check
  756. if test -f 'src/version.c'
  757. then
  758.     echo shar: will not over-write existing file "'src/version.c'"
  759. else
  760. cat << \SHAR_EOF > 'src/version.c'
  761. /* version.c  10/08/91
  762.  * Copyright 1983-1992   Albert Davis
  763.  * a dumb selector for portability
  764.  */
  765. #include "ecah.h"
  766. #include "io.h"
  767. #include "declare.h"
  768. /*--------------------------------------------------------------------------*/
  769. #ifdef UNIX
  770. #include "_unix.c"
  771. #endif
  772.  
  773. #ifdef MSC
  774. #include "_msc.c"
  775. #endif
  776. /*--------------------------------------------------------------------------*/
  777. /*--------------------------------------------------------------------------*/
  778. SHAR_EOF
  779. fi # end of overwriting check
  780. if test -f 'src/xopen.c'
  781. then
  782.     echo shar: will not over-write existing file "'src/xopen.c'"
  783. else
  784. cat << \SHAR_EOF > 'src/xopen.c'
  785. /* xopen  01/11/93
  786.  * Copyright 1983-1992   Albert Davis
  787.  * scan a string for a file name
  788.  * fill in extension, if necessary
  789.  * open file
  790.  */
  791. #include "ecah.h"
  792. #include "error.h"
  793. #include <time.h>
  794. #include "declare.h"
  795. /*--------------------------------------------------------------------------*/
  796.     void    xclose(FILE**);
  797.     FILE*    xopen(const char*,int*,const char*,const char*);
  798. /*--------------------------------------------------------------------------*/
  799. extern FILE *stream[];
  800. /*--------------------------------------------------------------------------*/
  801. void xclose(fn)
  802. FILE **fn;
  803. {
  804.  if (*fn){
  805.     (void)fclose(*fn);
  806.     *fn = (FILE*)NULL;
  807.  }
  808. }
  809. /*--------------------------------------------------------------------------*/
  810. FILE *xopen(cmd,cnt,ext,how)
  811. const char *cmd, *ext, *how;
  812. int *cnt;
  813. {
  814.  int i;
  815.  int defalt;
  816.  FILE *code;
  817.  char fname[BUFLEN+5];
  818.  
  819.  skipbl(cmd,cnt);
  820.  if (!cmd[*cnt]){
  821.     volatile int loccount;
  822.     cmd = getcmd ("file name?  ",fname,BUFLEN);
  823.     loccount = 0;
  824.     cnt = &loccount;
  825.  }
  826.  
  827.  skipbl(cmd,cnt);            /* find out if we want to add the   */
  828.  defalt = YES;                /* default extension            */
  829.  for (i = 0;   i < BUFLEN;   ){
  830.     char c;
  831.     c = cmd[(*cnt)++];
  832.     if (isterm(c))
  833.        break;
  834.     if (c == '$'){
  835.        sprintf(&(fname[i]), "%ld", time((long*)NULL));
  836.        i = strlen(fname);
  837.     }else{
  838.        fname[i++] = c;
  839.        if (c == '.')
  840.           defalt = NO;
  841.        else if (c == '\\'  ||  c == '/')
  842.           defalt = YES;
  843.     }
  844.  }
  845.  (*cnt)--;
  846.  if (defalt){                /* add the extension            */
  847.     fname[i++] = '.';
  848.     strcpy(&fname[i],ext);
  849.  }else{
  850.     fname[i] = '\0';
  851.  }
  852.  
  853.  (void)trim(fname);
  854.  skipcom(cmd,cnt);
  855.  
  856.  if ((*how == 'w')   &&   (access(fname,F_OK) == GOOD)){
  857.     char buffer[BUFLEN];        
  858.     error(bWARNING, "%s exists.  replace? ", fname);
  859.     (void)getcmd ("", buffer, BUFLEN);
  860.     if (match(buffer,"Yes"))        /* should be new file, but        */
  861.     code = fopen(fname,how);    /* file already exists,  ask        */
  862.     else
  863.     return (FILE*)NULL;
  864.  }else{
  865.     code = fopen(fname,how);
  866.  }
  867.  
  868.  if (code && fileno(code)>MAXHANDLE){
  869.     error(bWARNING, "internal error: files: %d\n", fileno(code));
  870.     (void)fclose(code);
  871.     code = (FILE*)NULL;
  872.  }
  873.  if (code)
  874.     stream[fileno(code)] = code;
  875.  else
  876.     error(bWARNING, "can't open %s\n", fname);
  877.  return code;
  878. }
  879. /*--------------------------------------------------------------------------*/
  880. /*--------------------------------------------------------------------------*/
  881. SHAR_EOF
  882. fi # end of overwriting check
  883. if test -f 'src/xsolve.c'
  884. then
  885.     echo shar: will not over-write existing file "'src/xsolve.c'"
  886. else
  887. cat << \SHAR_EOF > 'src/xsolve.c'
  888. /* xsolve  12/29/92
  889.  * Copyright 1983-1992   Albert Davis
  890.  * LU decomposition and fwd-back substitution for complex numbers
  891.  * 2 modules:  xlu() and xsolve()
  892.  * xlu() does LU decomposition using the Crout algorithm
  893.  * xsolve() does forward and back substitution after calling xlu() if necessary
  894.  * For a readable version of this, see the real number version: solve
  895.  */
  896. #include "ecah.h"
  897. #include "array.h"
  898. #include "error.h"
  899. #include "options.h"
  900. #include "status.h"
  901. #include "declare.h"
  902. /*--------------------------------------------------------------------------*/
  903.     void      xsolve(void);
  904. static    void      lu(void);
  905. static    complex_t dotprod(int,int,int);
  906. /*--------------------------------------------------------------------------*/
  907. extern const struct options opt;
  908. extern       struct status stats;
  909.  
  910. extern double *recon,*imcon;        /* constant terms, answer column        */
  911. extern int decomp;            /* how far been decomposed            */
  912. extern const int *basnode;        /* array of lowest node connected here  */
  913. /*--------------------------------------------------------------------------*/
  914. void xsolve()
  915. {
  916.  int jj, ii;
  917.  
  918.  lu();
  919.  ccck();
  920.  time_start(&(stats.back));
  921.  for (ii = 1; ii <= stats.total_nodes; ++ii){        /* forward substitution */
  922.     complex_t acc;
  923.     acc.x = recon[ii];
  924.     acc.y = imcon[ii];
  925.     for ( jj=basnode[ii]; jj<ii; ++jj ){
  926.        /* con[ii] -= Lower[ii][jj] * con[jj] */
  927.        acc = csub(acc, cxmul(*Rel(ii,jj),*Iml(ii,jj), recon[jj],imcon[jj]));
  928.     }
  929.  
  930.     /*  con[ii] /= *xy(ii,ii)   */
  931.     acc = cxdiv(acc.x,acc.y, *Red(ii,ii),*Imd(ii,ii));
  932.     recon[ii] = acc.x;
  933.     imcon[ii] = acc.y;
  934.  }
  935.  ccck();
  936.  for (jj = stats.total_nodes; jj > 1; --jj)        /* back substitution    */
  937.     for (ii = basnode[jj];   ii < jj;   ++ii){
  938.        /* con[ii] -= *Upper[ii][jj] * con[jj] */
  939.        complex_t acc;
  940.        acc = cxmul(*Reu(ii,jj),*Imu(ii,jj), recon[jj],imcon[jj]);
  941.        acc = cxsub(recon[ii],imcon[ii], acc.x,acc.y);
  942.        recon[ii] = acc.x;
  943.        imcon[ii] = acc.y;
  944.     }
  945.  time_stop(&(stats.back));
  946.  ccck();
  947. }
  948. /*--------------------------------------------------------------------------*/
  949. static void lu()
  950. {
  951.  complex_t acc;
  952.  int ii, jj, mm;
  953.  int bn;
  954.  
  955.  time_start(&(stats.lu));
  956.  for (mm = decomp+1;   mm <= stats.total_nodes;   ++mm){
  957.     bn = basnode[mm];
  958.     if (bn < mm){
  959.        /* *Upper(bn,mm) /= *Diag(bn,bn); */
  960.        acc = cxdiv(*Reu(bn,mm),*Imu(bn,mm), *Red(bn,bn),*Imd(bn,bn));
  961.        *Reu(bn,mm) = acc.x;
  962.        *Imu(bn,mm) = acc.y;
  963.  
  964.        for (ii =bn+1;  ii<mm;  ii++){
  965.       acc = dotprod(ii,mm,ii);
  966.       acc = cxsub(*Reu(ii,mm),*Imu(ii,mm), acc.x,acc.y);
  967.       acc = cxdiv(acc.x,acc.y, *Red(ii,ii),*Imd(ii,ii));
  968.       *Reu(ii,mm) = acc.x;
  969.       *Imu(ii,mm) = acc.y;
  970.        }
  971.        for (jj = bn+1;  jj<mm;  jj++){
  972.       acc = dotprod(mm,jj,jj);
  973.       acc = cxsub(*Rel(mm,jj),*Iml(mm,jj), acc.x,acc.y);
  974.       *Rel(mm,jj) = acc.x;
  975.       *Iml(mm,jj) = acc.y;
  976.        }
  977.        /* jj == mm */{
  978.       acc = dotprod(mm,mm,mm);
  979.       acc = cxsub(*Red(mm,mm),*Imd(mm,mm), acc.x,acc.y);
  980.       if (acc.x == 0.  &&  acc.y == 0.){
  981.          error(bWARNING, "open circuit: node %u\n", mm);
  982.          acc.x = opt.gmin;
  983.       }
  984.       *Red(mm,mm) = acc.x;
  985.       *Imd(mm,mm) = acc.y;
  986.        }
  987.     }else{    /* bn == mm */
  988.        if (*Red(mm,mm)==0. && *Imd(mm,mm)==0.){
  989.       if (recon[mm]!=0. || imcon[mm]!=0.)
  990.          error(bWARNING, "open circuit: node %u\n", mm);
  991.       *Red(mm,mm) = opt.gmin;
  992.        }
  993.     }
  994.     ccck();
  995.  }
  996.  decomp = stats.total_nodes;
  997.  time_stop(&(stats.lu));
  998. }
  999. /*--------------------------------------------------------------------------*/
  1000. static complex_t dotprod(ii,jj,mm)
  1001. int ii, jj, mm;
  1002. {
  1003.  int ind, len;
  1004.  int kk;
  1005.  double *xrow, *xcol;
  1006.  double *yrow, *ycol;
  1007.  complex_t dot;
  1008.  
  1009.  dot.x = dot.y = 0.;
  1010.  kk = (basnode[ii]>basnode[jj]) ? basnode[ii] : basnode[jj];
  1011.  len = mm-kk;
  1012.  if (len > 0){
  1013.     xrow = Rel(ii,kk);
  1014.     xcol = Reu(kk,jj);
  1015.     yrow = Iml(ii,kk);
  1016.     ycol = Imu(kk,jj);
  1017.     /* for (i = kk;   i < mm;   i++) */
  1018.     for (ind = 0;   ind < len;   ind++){
  1019.        dot.x += (xrow[-ind] * xcol[ind]) - (yrow[-ind] * ycol[ind]);
  1020.        dot.y += (xrow[-ind] * ycol[ind]) + (yrow[-ind] * xcol[ind]);
  1021.        /*dot = cadd(dot, cxmul(xrow[-ind],yrow[-ind],xcol[ind],ycol[ind]));*/
  1022.     }
  1023.  }
  1024.  return dot;
  1025. }
  1026. /*--------------------------------------------------------------------------*/
  1027. /*--------------------------------------------------------------------------*/
  1028. SHAR_EOF
  1029. fi # end of overwriting check
  1030. if test -f 'src/_msc.c'
  1031. then
  1032.     echo shar: will not over-write existing file "'src/_msc.c'"
  1033. else
  1034. cat << \SHAR_EOF > 'src/_msc.c'
  1035. /* _msc  12/29/92
  1036.  * Copyright 1983-1992   Albert Davis
  1037.  * Non-portable functions for Microsoft C.
  1038.  */
  1039. #include "error.h"
  1040. #include <dos.h>
  1041. #include <process.h>
  1042. #include <time.h>
  1043. /*--------------------------------------------------------------------------*/
  1044.     void    initialize(void);
  1045.     char    csts(void);
  1046.     char    ci(void);
  1047.     void    shell(void);
  1048.     int    system(const char*);
  1049. static    char    getswitchar(void);
  1050.     double    Exp(double);
  1051.     char*    getwd(char*);
  1052. /*--------------------------------------------------------------------------*/
  1053. struct tms {
  1054.     time_t    tms_utime;        /* user time */
  1055.     time_t    tms_stime;        /* system time */
  1056.     time_t    tms_cutime;        /* user time, children */
  1057.     time_t    tms_cstime;        /* system time, children */
  1058. };
  1059. #define times(x) ((x)->tms_utime=clock(),(x)->tms_stime=0)
  1060.  
  1061. /*extern int _fmode;*/        /* defined in stdlib.h */
  1062. /*extern char **environ;*/  /* defined in stdlib.h */
  1063. extern struct ioctrl io;
  1064. extern char e_int[], e_om[];
  1065. extern FILE *stream[];        /* reverse of fileno() */
  1066. /*--------------------------------------------------------------------------*/
  1067. void initialize()
  1068. {
  1069.  _fpreset();
  1070.  _fmode = (int)O_BINARY;
  1071.  setbuf( stdprn, NULL );
  1072.  setmode( fileno(stdin), (int)O_BINARY );
  1073.  stream[fileno(stdaux)] = stdaux;
  1074.  stream[fileno(stdprn)] = stdprn;
  1075.  io.mprint = 1<<fileno(stdprn);
  1076. }
  1077. /*--------------------------------------------------------------------------*/
  1078. static char cc;
  1079. char csts()
  1080. {
  1081.  return cc = (char)bdos(6,0xff,0);
  1082. }
  1083. char ci()
  1084. {
  1085.  char x;
  1086.  x = cc;
  1087.  if (x) {
  1088.     cc = '\0';
  1089.     return x;
  1090.  } else {
  1091.     return (char)bdos(7,0,0);
  1092.  }
  1093. }
  1094. /*--------------------------------------------------------------------------*/
  1095. void shell()
  1096. {
  1097.  char *shell;
  1098.  int errcod;
  1099.  
  1100.  if (!(shell=getenv("COMSPEC")))
  1101.     error(bERROR, e_int, "comspec");
  1102.  
  1103.  errcod = spawnle(P_WAIT, shell, shell, NULL, environ);
  1104.  _fpreset();
  1105.  if (errcod == EOF) {
  1106.     switch (errno) {
  1107.        case E2BIG:
  1108.           error(bERROR, e_int, "arg list");
  1109.        case EINVAL:
  1110.           error(bERROR, e_int, "mode flag");
  1111.        case ENOENT:
  1112.           error(bERROR, "no shell");
  1113.        case ENOEXEC:
  1114.           error(bERROR, "bad shell");
  1115.        case ENOMEM:
  1116.           error(bERROR, e_om,"");
  1117.        default:
  1118.           error(bERROR, e_int, "system");
  1119.     }
  1120.  }
  1121. }
  1122. /*--------------------------------------------------------------------------*/
  1123. int system(string)
  1124. const char *string;
  1125. {
  1126.  char *shell;
  1127.  char args[200];
  1128.  int errcod;
  1129.  
  1130.  if (!(shell=getenv("COMSPEC")))
  1131.     error(bERROR, e_int, "comspec");
  1132.  
  1133.  sprintf(args,"%cc %s",getswitchar(),string);
  1134.  
  1135.  errcod = spawnle(P_WAIT, shell, shell, args, NULL, environ);
  1136.  _fpreset();
  1137.  if (errcod == EOF) {
  1138.     switch (errno) {
  1139.        case E2BIG:
  1140.           error(bERROR, e_int, "arg list");
  1141.        case EINVAL:
  1142.           error(bERROR, e_int, "mode flag");
  1143.        case ENOENT:
  1144.           error(bERROR, "no shell");
  1145.        case ENOEXEC:
  1146.           error(bERROR, "bad shell");
  1147.        case ENOMEM:
  1148.           error(bERROR, e_om, "");
  1149.        default:
  1150.           error(bERROR, e_int, "system");
  1151.     }
  1152.  }
  1153. return 0;
  1154. }
  1155. /*--------------------------------------------------------------------------*/
  1156. static char getswitchar()
  1157. {
  1158.  union REGS r;
  1159.  
  1160.  r.h.al = 0;
  1161.  r.h.ah = 0x37;
  1162.  intdos(&r, &r);
  1163.  return r.h.dl;
  1164. }
  1165. /*--------------------------------------------------------------------------*/
  1166. double Exp(x)        /* exp with trap.                    */
  1167. double x;        /* function that comes with compiler gives strange  */
  1168. {            /* answers for large negative args,            */
  1169.             /* after spawning a process                */
  1170. #undef exp        /* temporary fix is to return 0 for more negative   */
  1171.             /* than -200.  (about -700 is the threshold)        */
  1172.  return (x>-200.) ? exp(x) : 0.;
  1173. }
  1174. /*--------------------------------------------------------------------------*/
  1175. char *getwd(buf)
  1176. char *buf;
  1177. {
  1178.  char *getcwd();
  1179.  return getcwd(buf,BUFSIZ);
  1180. }
  1181. /*--------------------------------------------------------------------------*/
  1182. /*--------------------------------------------------------------------------*/
  1183. SHAR_EOF
  1184. fi # end of overwriting check
  1185. if test -f 'src/_unix.c'
  1186. then
  1187.     echo shar: will not over-write existing file "'src/_unix.c'"
  1188. else
  1189. cat << \SHAR_EOF > 'src/_unix.c'
  1190. /* _unix.c  12/29/92
  1191.  * Copyright 1983-1992   Albert Davis
  1192.  * Non-portable functions for unix systems (Sun, Next, ....)
  1193.  */
  1194. #include <signal.h>
  1195. /*--------------------------------------------------------------------------*/
  1196.     void    initialize(void);
  1197.     char    csts(void);
  1198.     char    ci(void);
  1199.     void    shell(void);
  1200.     int    min(int,int);
  1201. /*--------------------------------------------------------------------------*/
  1202. extern struct ioctrl io;
  1203. /*--------------------------------------------------------------------------*/
  1204. void initialize()
  1205. {
  1206.  io.mprint = 0;
  1207. }
  1208. /*--------------------------------------------------------------------------*/
  1209. char csts()
  1210. {
  1211.  return '\0';
  1212. }
  1213. char ci()
  1214. {
  1215.  return '\0';
  1216. }
  1217. /*--------------------------------------------------------------------------*/
  1218. void shell()
  1219. {
  1220.  (void)system(getenv("SHELL"));
  1221. }
  1222. /*--------------------------------------------------------------------------*/
  1223. int min(a,b)
  1224. int a,b;
  1225. {
  1226.  return (a<b) ? a : b;
  1227. }
  1228. /*--------------------------------------------------------------------------*/
  1229. /*--------------------------------------------------------------------------*/
  1230. SHAR_EOF
  1231. fi # end of overwriting check
  1232. #    End of shell archive
  1233. exit 0
  1234.