Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/unix/volume2/wire/part2

Internet Message Format | 1986-11-30 | 30.3 KB

From: panda!talcott!uwvax!geowhiz!karsh
Subject: wirewrap program part 02 of 02
Reply-To: [e-mail] (Bruce Karsh)
Keywords: wirewrap circuit board construction cad cadcam cam pc chip
Newsgroups: mod.sources
Approved: [e-mail]

Mod.sources:  Volume 2, Issue 36
Submitted by: uwvax!geowhiz!karsh <[e-mail]> (Bruce Karsh)



#!/bin/sh
#
# This is a release of my wirewrap program.  It has been used
# to make several boards here, and seems to be pretty reliable.
# It was written on a Masscomp MC500, but I don't think there
# are any serious machine dependencies in it.  (But then again,
# I'm often suprised by how easy it is to inadvertantly write
# machine dependent code.)
#
# I'd like to hear some bug reports and success stories.  I will
# try to send out bug fixes as quickly as I can.
#
# As usual, unpack all parts by running through sh, then run make.
#
# Unix Wirewrap Source Code:
# cnvtnum.c    gettoken.c    getwired.c    getwirelen.c    header1.c
# header2.c    initialize.c    insertname.c    insertx.c    main.c
# mywrite.c    mywrite2.c    namecmp.c    namecmp2.c    output1.c
# output2.c    output3.c    readin.c    setptr.c    setrowandcol.c
# sort1.c        sort2.c        test.c
#
# .h files:
#   wirewrap.h
#
# Documentation:
#   wirewrap.1 README PACKINGLIST
#
# Unix wirewrap makefile:
#   Makefile
#
# Test Data:
#   autocal
#
# Example listing:
#   autocal.listing
#
# ----
# Bruce Karsh
# U. Wisc. Dept. Geology and Geophysics
# 1215 W Dayton, Madison, WI 53706
# [phone]
# {ihnp4,seismo}!uwvax!geowhiz!karsh
#
echo 'Start of wirewrap program, part 02 of 02:'
echo 'x - Makefile'
sed 's/^X//' > Makefile << '/'
Xwirewrap:     initialize.o readin.o main.o setptr.o setrowandcol.o \
X              sort1.o getwired.o output3.o getwirelen.o \
X              insertx.o output1.o mywrite.o header1.o sort2.o \
X              output2.o header2.o mywrite2.o \
X              test.o cnvtnum.o namecmp.o insertname.o gettoken.o \
X              namecmp2.o
X    cc -o wirewrap initialize.o readin.o main.o setptr.o \
X              setrowandcol.o sort1.o getwired.o output3.o \
X              getwirelen.o output1.o insertx.o mywrite.o \
X              header1.o sort2.o output2.o header2.o mywrite2.o \
X              test.o cnvtnum.o namecmp.o gettoken.o \
X              insertname.o namecmp2.o -lm
X
Xclean:
X    rm -f *.o
X
Xpackage:
X    packmail -hREADME -t'wirewrap program' `/bin/cat PACKINGLIST`
X
Xgettoken.o: wirewrap.h
Xgetwired.o: wirewrap.h
Xgetwirelen.o: wirewrap.h
Xinitialize.o: wirewrap.h
Xinsertname.o: wirewrap.h
Xmain.o: wirewrap.h
Xmywrite.o: wirewrap.h
Xmywrite2.o: wirewrap.h
Xnamecmp.o: wirewrap.h
Xnamecmp2.o: wirewrap.h
Xoutput1.o: wirewrap.h
Xoutput2.o: wirewrap.h
Xoutput3.o: wirewrap.h
Xreadin.o: wirewrap.h
Xsetptr.o: wirewrap.h
Xsetrowandcol.o: wirewrap.h
Xsort1.o: wirewrap.h
Xsort2.o: wirewrap.h
Xtest.o: wirewrap.h
/
echo 'x - PACKINGLIST'
sed 's/^X//' > PACKINGLIST << '/'
XMakefile
XPACKINGLIST
XREADME
Xautocal
Xautocal.listing
Xcnvtnum.c
Xgettoken.c
Xgetwired.c
Xgetwirelen.c
Xheader1.c
Xheader2.c
Xinitialize.c
Xinsertname.c
Xinsertx.c
Xmain.c
Xmywrite.c
Xmywrite2.c
Xnamecmp.c
Xnamecmp2.c
Xoutput1.c
Xoutput2.c
Xoutput3.c
Xreadin.c
Xsetptr.c
Xsetrowandcol.c
Xsort1.c
Xsort2.c
Xtest.c
Xwirewrap.1
Xwirewrap.h
/
echo 'x - README'
sed 's/^X//' > README << '/'
XThis is a release of my wirewrap program.  It has been used
Xto make several boards here, and seems to be pretty reliable.
XIt was written on a Masscomp MC500, but I don't think there
Xare any serious machine dependencies in it.  (But then again,
XI'm often suprised by how easy it is to inadvertantly write
Xmachine dependent code.)
X
XI'd like to hear some bug reports and success stories.  I will
Xtry to send out bug fixes as quickly as I can.
X
XAs usual, unpack all parts by running through sh, then run make.
X
XUnix Wirewrap Source Code:
Xcnvtnum.c    gettoken.c    getwired.c    getwirelen.c    header1.c
Xheader2.c    initialize.c    insertname.c    insertx.c    main.c
Xmywrite.c    mywrite2.c    namecmp.c    namecmp2.c    output1.c
Xoutput2.c    output3.c    readin.c    setptr.c    setrowandcol.c
Xsort1.c        sort2.c        test.c
X
X.h files:
X  wirewrap.h
X
XDocumentation:
X  wirewrap.1 README PACKINGLIST
X
XUnix wirewrap makefile:
X  Makefile
X
XTest Data:
X  autocal
X
XExample listing:
X  autocal.listing
X
X----
XBruce Karsh
XU. Wisc. Dept. Geology and Geophysics
X1215 W Dayton, Madison, WI 53706
X(608) 262-1697
X{ihnp4,seismo}!uwvax!geowhiz!karsh
/
echo 'x - autocal'
sed 's/^X//' > autocal << '/'
X/*
X**  Auto calibration circuitry for UW Digital recording packages.
X*/
X:chip    I/O-edge    1a    80    2    56    1    4
X    .    .    .    GAP4    .    .    .    .
X    10SEC    .    .    .    .    .    .    SKEY-
X    .    .    .    .    .    .    .    .
X    .    .    .    TST+    .    .    .    .
X
X    .    .    .    .    .    .    .    g
X    .    .    .    .    .    .    .    .
X    bgld-    .    bcal+    .    .    .    .    .
X    .    .    .    PD3    .    .    .    .
X    .    .    .    .    .    .    .    .
X    .    .    .    .    .    .    .    .
X
X:chip    UPI/O    10a    1    1    37    53    4
X    Q
X
X:chip    RUN.FF1    8c    14    3    53    41    4
X    .    .    .    .    .    .    .
X    jamrun+    .    .    .    .    .    .
X
X:chip    RUN.FF2    2e    16    3    35    5    4
X    .    .    .    .    RON+    .    .    .
X    .    .    .    .    .    .    .    .
X
X:chip    Buffer.4050    2g    16    3    17    5    4
X    .    .    .    .    .    .    .    .
X    .    .    cal+    bcal+    .    gld-    bgld-    .
X
X:chip    count.4020    2h    16    3    8    5    4
X    .    q13    stop+    .    .    .    .    -
X    .    clk/2    calrun-    .    .    q10    .    +
X
X:chip    runff.4013    3g    14    3    17    11    4
X    calrun-    .    10SEC    g    jamrun-    stop+    -
X    stop+    calena+    g    Q    jamrun+    jamrun-    +
X
X:chip    or.4071    3h    14    3    8    11    4
X    mp    acal    cal+    seqi    calrun-    seqm    -
X    seqm    ap    apms    calena+    TST+    RON+    +
X
X:chip    and.4081    4g    14    3    17    17    4
X    SKEY-    TST+    gld-    mp    TST+    PD3    -
X    jamrun+    apms    acal    ap    q10    q13    +
X
X:chip    xor.4030    4h    14    3    8    17    4
X    seq4    seq12    seql    seqn    seql    seq6    -
X    seq1    seqn    seqm    clk    GAP4    g    +
X
X:chip    shift.4015    5g    16    3    17    23    4
X    clk    seq8    .    .    seq1    q13    seqi    -
X    clk    seq4    .    seq6    .    q13    seq4    +
X
X:chip    shift.4015    5h    16    3    8    23    4
X    clk    .    .    .    .    q13    seq8    -
X    clk    seq12    .    .    .    q13    seq12    +
X
X:chip    syncff.4013    6h    14    3    8    29    4
X    clk/2    clk/2-    clk    calrun-    clk/2-    g    -
X    g    g    g    g    .    .    +
X
X:SPECIAL
X    +    -
/
echo 'x - cnvtnum.c'
sed 's/^X//' > cnvtnum.c << '/'
X#include <ctype.h>
Xchar *cnvtnump; /* Pointer to next character to process. */
Xint cnvtnumv;   /* 1 if valid number, 0 otherwise. */
X/*************************************/
X/*  cnvtnum - convert ascii to int.  */
X/*  Works like atoi() except that it */
X/*  leaves the externel variables set*/
X/*  to help in error recovery.       */
X/*************************************/
Xcnvtnum(str)
Xchar *str;
X{
Xint sign=1;
Xint result=0;
Xcnvtnump = str;
Xcnvtnumv=0;
X
X/* Skip leading blanks. */
X
Xwhile(*cnvtnump == ' ' || *cnvtnump == '\t')cnvtnump++;
X
X/* Pick up leading sign. */
X
Xif(*cnvtnump == '+')
X  {
X  sign = 1;
X  *cnvtnump++;
X  }
Xelse if(*cnvtnump == '-')
X  {
X  sign = -1;
X  *cnvtnump++;
X  }
X
X/* Pick up digits. */
X
Xwhile(isdigit(*cnvtnump))
X  {
X  result=10*result+ (*cnvtnump-'0');
X  cnvtnump++;
X  cnvtnumv=1;
X  }
X
Xreturn(sign*result);
X}
/
echo 'x - gettoken.c'
sed 's/^X//' > gettoken.c << '/'
X#include <ctype.h>
X#include <stdio.h>
X#include "wirewrap.h"
X/*
X** gettoken - return a whitespace delimited token.
X**            Tokens are truncated at 79 characters.
X**          Return code is zero if a token is
X**          returned, otherwise an end of file
X**          was reached and -1 is returned.
X*/
Xgettoken(token)
Xchar *token;
X{
Xchar chr;
Xint tokenptr;
Xstatic int firsttime=1;
Xstatic int nextchr;
Xint comment;
Xtokenptr=0;
Xtoken[tokenptr]=0;
Xcomment=0;
X
X/* If first time through, get a look-ahead character. */
X
Xif(firsttime == 1)
X  {
X  nextchr=getchar();
X  firsttime=0;
X  }
X
Xfor(;;)
X  {
X  /* Get a character from the input. */
X
X  if(nextchr == EOF)
X    chr=EOF;
X  else
X    {
X    chr=nextchr;
X    nextchr=getchar();
X    }
X
X  /* Test if start of a comment. */
X
X  if(chr == '/' && nextchr == '*')
X    {
X    nextchr = getchar();
X    comment = 1;
X    continue;
X    }
X
X  /* Test if end of a comment. */
X
X  if(chr == '*' && nextchr == '/' && comment == 1)
X    {
X    nextchr=getchar();
X    comment=0;
X    continue;
X    }
X
X  /* Test if EOF within a comment. */
X
X  if(chr == EOF && comment == 1)break;
X
X  /* Test if a newline char within a comment. */
X
X  if(chr == '\n' && comment == 1)
X    {
X    inputline++;
X    continue;
X    }
X
X  /* Test if any other character within a comment. */
X
X  if(comment == 1)continue;
X
X  /* Process end of file. */
X
X  if(chr == EOF)break;
X
X  /* Process white space character. */
X
X  if(isspace(chr))
X    {
X
X    /* Process new line character. */
X    if(chr == '\n')
X      {
X      if(tokenptr != 0)
X
X        /* Process new line character which terminates a token */
X
X        ungetc(chr,stdin);
X      else
X
X        /* Process a new line character which does not terminate a token */
X
X        inputline++;
X      }
X
X  /* Process any white space character that terminates a token */
X
X    if(tokenptr != 0) return(0);
X
X  /* Process a white space character that doesn't terminate a token */
X
X    else continue;
X    }
X  else
X
X  /* Process a non white space charater */
X
X    if(tokenptr<79)
X      {
X
X      /* Process a non white space charater before the 79'th char of a token */
X
X      token[tokenptr]=chr;
X      tokenptr++;
X      token[tokenptr]=0;
X      }
X    else
X
X      /* Process a non white space character after the 79'th char of a token */
X
X      continue;
X  }
X
X/* Process end of file */
X
Xif(tokenptr==0)return(-1);else return(0);
X}
/
echo 'x - getwired.c'
sed 's/^X//' > getwired.c << '/'
X/**********************************************
X*  getwired - do the wire routing.            *
X*                          *
X*    When getwired is called, the signal list *
X*  is sorted in order by signalname.  This    *
X*  routine connects adjacent pins with the    *
X*  same signal name together.  Pins are conn- *
X*  nected together with either top to top     *
X*  wraps or bottom to bottom wraps everywhere.*
X*  The last wrap may really be wrapped as a   *
X*  top to bottom wrap if there is an odd num- *
X*  ber of pins in the string.  But it is still*
X*  represented as a top to top wrap.          *
X**********************************************/
X
X#include "wirewrap.h"
X
Xgetwired()
X{
Xint indexlo,indexhi,count,i;
Xchar currentsignal[NAMELENGTH];
Xindexhi = 0;
Xwhile(indexhi < nextfree)
X  {
X  indexlo = indexhi;
X  indexhi = indexhi + 1;
X  for(i=0;i<NAMELENGTH;i++)
X    currentsignal[i] = pinarray[indexlo].signalname->signalname[i];
X  while((indexhi < nextfree) &&
X         !namecmp(pinarray[indexhi].signalname->signalname,currentsignal)
X        )indexhi++;
X  if(namecmp(currentsignal,NULLSIGNAL))
X    {
X    count = indexlo;
X    while(count < indexhi-1)
X      {
X      pinarray[count].inner = count+1;
X      pinarray[count+1].inner = count;
X      count = count + 2;
X      }
X    count = indexlo + 1;
X    while(count < indexhi-1)
X      {
X      pinarray[count].outer = count+1;
X      pinarray[count+1].outer = count;
X      count = count + 2;
X      }
X    }
X  }
X}
/
echo 'x - getwirelen.c'
sed 's/^X//' > getwirelen.c << '/'
X#define sqr(a) ( (a)*(a) )
X#include <math.h>
X#include "wirewrap.h"
Xdouble getwirelength(row1,col1,row2,col2)
Xint row1,col1,row2,col2;
X{
Xdouble wlength;
X
X/* Compute straight line distance. */
X
Xwlength = .1 * sqrt((double) sqr(row1-row2)+sqr(col1-col2));
X
X/* Apply linear regression coefficients */
X
Xwlength = wlength * lengthfactor + pinpart;
X
X/* Round up to the nearest larger .5 inch */
X
Xwlength = wlength * 2 + 1;
Xwlength = (int) wlength;
Xwlength = wlength/2.0;
X
X/* Make sure that it is at least as long as the minimum length. */
X
Xif(wlength < minlength) wlength = minlength;
Xreturn(wlength);
X}
/
echo 'x - header1.c'
sed 's/^X//' > header1.c << '/'
Xheader1()
X{
Xchar outline[80];
X
Xoutline[0]=0;
Xinsertx("chip",outline,10);
Xinsertx("pin",outline,23);
Xinsertx("chip",outline,28);
Xprintf("%s\n",outline);
Xoutline[0]=0;
Xinsertx("name",outline,10);
Xinsertx("num",outline,23);
Xinsertx("position",outline,28);
Xinsertx("row col",outline,42);
Xprintf("%s\n",outline);
X}
/
echo 'x - header2.c'
sed 's/^X//' > header2.c << '/'
Xheader2()
X{
Xchar outline[80];
Xoutline[0]=0;
Xinsertx("signal",outline,1);
Xinsertx("pin",outline,14);
Xinsertx("inner wire",outline,18);
Xinsertx("outer wire",outline,39);
Xprintf("%s\n",outline);
Xoutline[0]=0;
Xinsertx("name ",outline,1);
Xinsertx("num",outline,14);
Xprintf("%s\n",outline);
X}
/
echo 'x - initialize.c'
sed 's/^X//' > initialize.c << '/'
X/*******************************************
X* initialize - initialize global variables *
X*******************************************/
X
X#include "wirewrap.h"
X
Xinitialize()
X{
Xchipleader = 0;
Xsiglistleader = 0;
Xnextfree = 0;
Xlinenum = 67;
Xinputline=1;
X}
/
echo 'x - insertname.c'
sed 's/^X//' > insertname.c << '/'
X#include "wirewrap.h"
Xinsertname(from,to,pos)
Xchar *from, *to;
Xint pos;
X{
Xchar *p;
Xint l;
X
X/* Pad with trailing blanks. */
X
Xl=strlen(to);
Xwhile(l<(pos-1))
X  {
X  to[l]=' ';
X  l++;
X  }
Xto[l]=0;
X
X/* Append the from string to the to string. */
X
Xl=pos-1;
Xfor(p=from; p-from < NAMELENGTH; p++)
X  {
X  to[l] = *p;
X  l++;
X  }
Xto[l]=0;
X}
/
echo 'x - insertx.c'
sed 's/^X//' > insertx.c << '/'
Xinsertx(from,to,pos)
Xchar *from, *to;
Xint pos;
X{
Xchar *p;
Xint l;
X
X/* Pad with trailing blanks. */
X
Xl=strlen(to);
Xwhile(l<(pos-1))
X  {
X  to[l]=' ';
X  l++;
X  }
Xto[l]=0;
X
X/* Append the from string to the to string. */
X
Xl=pos-1;
Xfor(p=from; *p != 0; p++)
X  {
X  to[l] = *p;
X  l++;
X  }
Xto[l]=0;
X}
/
echo 'x - main.c'
sed 's/^X//' > main.c << '/'
X#include "wirewrap.h"
Xmain()
X{
Xinitialize();
Xreadin();    /* Read the input file. */
X
X#ifdef DEBUG
X  printf("Dump of pin array after inputting data\n");
X  test();
X#endif
X
Xsort1();                 /* Sort by signal name. */
X
X#ifdef DEBUG
X  printf("Dump of pin array after sort by signal name\n");
X  test();
X#endif
X
Xgetwired();              /* Wire the pins togther. */
X
X#ifdef DEBUG
X  printf("Dump of pin array after doing the wiring.\n");
X  test();
X#endif
X
Xoutput1();              /* Output the first printout. (Chip side view) */
X
Xsort2();                /* Sort by (row,col). */
X
X#ifdef DEBUG
X  printf("Dump of pin array after sorting by (row,col)\n");
X  test();
X#endif
X
Xoutput2();             /* Output the second printout. (Pin side view) */
X
Xoutput3();             /* Output the third printout. (Wire lengths) */
X}
/
echo 'x - mywrite.c'
sed 's/^X//' > mywrite.c << '/'
X#include "wirewrap.h"
X
Xmywrite(outline)
Xchar *outline;
X{
Xif(linenum > 60)
X  {
X  printf("");
X  header1();
X  linenum=3;
X  }
X  printf("%s\n",outline);
X  linenum++;
X}
/
echo 'x - mywrite2.c'
sed 's/^X//' > mywrite2.c << '/'
X#include "wirewrap.h"
X
Xmywrite2(outline)
Xchar *outline;
X{
Xif(linenum > 60)
X  {
X  printf("");
X  header2();
X  linenum=3;
X  }
X  printf("%s\n",outline);
X  linenum++;
X}
/
echo 'x - namecmp.c'
sed 's/^X//' > namecmp.c << '/'
X/*
X** namecmp - compare two names.  Works like strcmp()
X*/
X#include "wirewrap.h"
Xnamecmp(a,b)
Xchar a[NAMELENGTH],b[NAMELENGTH];
X{
Xint i;
Xfor(i=0;i<NAMELENGTH;i++)
X  {
X  if(a[i]<b[i])return(-1);
X  else if (a[i]>b[i])return(1);
X  }
Xreturn(0);
X}
/
echo 'x - namecmp2.c'
sed 's/^X//' > namecmp2.c << '/'
X/*
X** namecmp2 - compare two names.  Works like strcmp()
X**            This is the same as namecmp except that
X**          namecmp2 ignores case.
X*/
X#include "wirewrap.h"
Xnamecmp2(a,b)
Xchar a[NAMELENGTH],b[NAMELENGTH];
X{
Xint i;
Xfor(i=0;i<NAMELENGTH;i++)
X  {
X  if(tolower(a[i])<tolower(b[i]))return(-1);
X  else if (tolower(a[i])>tolower(b[i]))return(1);
X  }
Xreturn(0);
X}
/
echo 'x - output1.c'
sed 's/^X//' > output1.c << '/'
X#include "wirewrap.h"
Xoutput1()
X{
Xchar currentsig[12],outline[80], sig[12], wrap, newstring[80];
Xint count, i;
X
Xcurrentsig[0] = 0;
Xcount = 0;
Xoutline[0] = 0;
Xwhile(count < nextfree)
X  {
X  for(i=0;i<12;i++)sig[i] = pinarray[count].signalname->signalname[i];
X  if(namecmp(sig,currentsig))
X    {
X    insertname(sig,outline,1);
X    if((pinarray[count].signalname->special) != 0)
X      insertx("Special",outline,2+NAMELENGTH);
X    mywrite(outline);
X    outline[0]=0;
X    for(i=0;i<12;i++)currentsig[i]=sig[i];
X    wrap='T';
X    }
X  if(wrap == 'T')wrap='B'; else wrap='T';
X  newstring[0]=0;
X  insertname(pinarray[count].mychip->name,outline,10);
X  sprintf(newstring,"%d",pinarray[count].pinnum);
X  insertx(newstring,outline,12+NAMELENGTH);
X  insertname(pinarray[count].mychip->position,outline,17+NAMELENGTH);
X  sprintf(newstring,"(%d,%d)",pinarray[count].row, pinarray[count].col);
X  insertx(newstring,outline,30+NAMELENGTH);
X  if(namecmp(sig,NULLSIGNAL) && (!pinarray[count].signalname->special))
X    insertx(wrap,outline,39+NAMELENGTH);
X  mywrite(outline);
X  outline[0] = 0;
X  count++;
X  }
X}
/
echo 'x - output2.c'
sed 's/^X//' > output2.c << '/'
X#include "wirewrap.h"
X
Xoutput2()
X{
Xint oldrow,oldcol,runflag,count,already,specialsig;
Xint innerptr,innerwrap,outerptr,outerwrap;
Xchar tempstr[80],outline[80];
Xdouble wlength,getwirelength();
Xprintf("");
Xheader2();
Xoldrow = -100;
Xoldcol = -100;
Xlinenum = 3;
Xrunflag = 0;
Xfor(count=0;count<nextfree;count++)
X  {
X  outline[0]=0;
X  if((pinarray[count].row == oldrow) &&
X   (pinarray[count].col == (oldcol + 1)))
X    runflag = 1;
X  else
X    {
X    if(runflag != 0)
X      {
X      mywrite2(" ");
X      runflag=0;
X      }
X    }
X  oldrow = pinarray[count].row;
X  oldcol = pinarray[count].col;
X
X  /* SET UP THE SIGNAL NAME AND PIN NUMBER */
X
X  insertname(pinarray[count].signalname->signalname,outline,1);
X  sprintf(tempstr,"%d",pinarray[count].pinnum);
X  insertx(tempstr,outline,14);
X
X  /* FIGURE SOME STUFF OUT FOR THE INNER WRAP */
X
X  innerptr = pinarray[count].inner;
X  innerwrap = (pinarray[count].inner != -1);
X  if(innerwrap)
X    already = (pinarray[count].inner < count);
X  else
X    already = 0;
X  specialsig = pinarray[count].signalname->special;
X
X  /* SET UP LENGTH OF INNER WIRE */
X
X  if(specialsig)
X    insertx("SPEC",outline,18);
X  if(already && (! specialsig))
X    insertx("TEST",outline,18);
X  if(innerwrap && (! already) && (! specialsig))
X    {
X    wlength=getwirelength(pinarray[count].row,pinarray[count].col,
X                  pinarray[innerptr].row,pinarray[innerptr].col);
X    wlength = (double) ( (int) (wlength * 10) ) / 10;
X    sprintf(tempstr,"%.1f",wlength);
X    insertx(tempstr,outline,18);
X    }
X
X  /* SET UP ROW1 AND COL1 */
X
X  sprintf(tempstr,"%d",pinarray[count].row);
X  insertx(tempstr,outline,23);
X  insertx(",",outline,strlen(outline)+1);
X  sprintf(tempstr,"%d",pinarray[count].col);
X  insertx(tempstr,outline,strlen(outline)+1);
X
X  /* SET UP ROW2 AND COL2 */
X
X  if((!specialsig) && innerwrap)
X    {
X    insertx(" ",outline,strlen(outline)+1);
X    sprintf(tempstr,"%d",pinarray[innerptr].row);
X    insertx(tempstr,outline,strlen(outline)+1);
X    insertx(",",outline,strlen(outline)+1);
X    sprintf(tempstr,"%d",pinarray[innerptr].col);
X    insertx(tempstr,outline,strlen(outline)+1);
X    }
X
X  /* FIGURE SOME STUFF OUT FOR THE OUTER WRAP */
X
X  outerptr = pinarray[count].outer;
X  outerwrap =(pinarray[count].outer != -1);
X  if(outerwrap)
X    already=(pinarray[count].outer < count);
X  else
X    already=0;
X  specialsig = pinarray[count].signalname->special;
X
X  /* SET UP LENGTH OF OUTER WIRE */
X
X  if(specialsig)
X    insertx("SPEC",outline,39);
X  if(already && (!specialsig))
X    insertx("TEST",outline,39);
X  if(outerwrap && (!already) && (!specialsig))
X    {
X    wlength=getwirelength(pinarray[count].row,pinarray[count].col,
X                  pinarray[outerptr].row,pinarray[outerptr].col);
X    wlength = (double) ( (int) (wlength * 10) ) / 10;
X    sprintf(tempstr,"%.1f",wlength);
X    insertx(tempstr,outline,39);
X    }
X
X  /* SET UP ROW1 AND COL1 */
X
X  sprintf(tempstr,"%d",pinarray[count].row);
X  insertx(tempstr,outline,44);
X  insertx(",",outline,strlen(outline)+1);
X  sprintf(tempstr,"%d",pinarray[count].col);
X  insertx(tempstr,outline,strlen(outline)+1);
X
X  /* SET UP ROW2 AND COL2 */
X
X  if((!specialsig) && outerwrap)
X    {
X    insertx(" ",outline,strlen(outline)+1);
X    sprintf(tempstr,"%d",pinarray[outerptr].row);
X    insertx(tempstr,outline,strlen(outline)+1);
X    insertx(",",outline,strlen(outline)+1);
X    sprintf(tempstr,"%d",pinarray[outerptr].col);
X    insertx(tempstr,outline,strlen(outline)+1);
X    }
X
X  /* SET UP EMPTY/FULL FLAG */
X
X  if((!specialsig) && outerwrap)
X    {
X    insertx(" ",outline,strlen(outline)+1);
X    if(pinarray[outerptr].inner == -1)
X      insertx("E",outline,strlen(outline)+1);
X    else
X      insertx("F",outline,strlen(outline)+1);
X    }
X  mywrite2(outline);
X  }
X}
/
echo 'x - output3.c'
sed 's/^X//' > output3.c << '/'
X#include "wirewrap.h"
X
Xoutput3()
X{
Xdouble wirelength,getwirelength();
Xint longctr, i, len, total, ctr[21];
X
X/* Zero out counters */
X
X        longctr = 0;
X        for(i=2;i<=20;i++)ctr[i]=0;
X
X/* Print heading. */
X
X        printf("\014");
X        printf(" WIRE LENGTH SUMMARY\n");
X        printf(" -------------------\n");
X        printf("\n");
X        printf(" Wire   Number\n");
X        printf("Length   Used\n");
X
X/* Wire counting loop. */
X
X        for(i=0; i<nextfree;i++)
X        {
X
X        /* Count inner wire length*/
X
X                if( (pinarray[i].inner != -1) &&
X                (!pinarray[i].signalname->special) )
X                  {
X                  wirelength=getwirelength(pinarray[i].row,pinarray[i].col,
X                                pinarray[pinarray[i].inner].row,
X                                pinarray[pinarray[i].inner].col);
X                  len=wirelength / 0.5 + 0.1;
X                  if(len > 20)
X                    longctr++;
X                  else
X                    ctr[len]++;
X                  }
X
X        /* Count outer wire length*/
X
X                if( (pinarray[i].outer != -1 ) &&
X                (!pinarray[i].signalname->special) )
X                  {
X                  wirelength=getwirelength(pinarray[i].row,pinarray[i].col,
X                                pinarray[pinarray[i].outer].row,
X                                pinarray[pinarray[i].outer].col);
X                  len=wirelength / 0.5 + 0.1;
X                  if(len > 20)
X                    longctr++;
X                  else
X                    ctr[len]++;
X                  }
X        }
X
X        /* Only count each wire once. */
X                for(i=2;i<=20;i++)ctr[i]=ctr[i]/2;
X                longctr=longctr/2;
X
X        /* Make listing. */
X
X                for(i=2;i<=20;i++)
X                  {
X                  if(ctr[i] > 0)
X                     {
X             printf("%-9.1f %d\n",(.5*i),ctr[i]);
X                     }
X                  }
X        if(longctr > 0)
X          {
X          printf("> 10.0 %d\n",longctr);
X          }
X
X        /* Total up how many wires used. */
X
X        total=0;
X        for(i=2;i<=20;i++)total+=ctr[i];
X        total += longctr;
X        printf("Total number of wires used: %d\n",total);
X}
/
echo 'x - setrowandcol.c'
sed 's/^X//' > setrowandcol.c << '/'
X/*********************************************************/
X/*                                                       */
X/* setrowandcol: sets up the row and column field of the */
X/* pin list entry based on the pin orientation, width,   */
X/* pincount and (row1,col1).                             */
X/*                                                       */
X/*********************************************************/
X
X#include "wirewrap.h"
X
Xsetrowandcol(thispin)
Xstruct pin *thispin;
X{
Xint width,row1,col1,pinsrow,pincount;
X/*
X** Pick up width, (row1,col1), and pincount for this chip.
X*/
Xwidth = (thispin -> mychip) -> width;
Xrow1 = (thispin -> mychip) -> row1;
Xcol1 = (thispin -> mychip) -> col1;
Xpincount = (thispin -> mychip) -> pincount;
X/*
X** Process SIPs (single inline packages).  These are entered as
X** having a width of zero.  All other chips are assumed to be
X** DIPs (dual inline packages).
X** An n pin SIP has n pins per row.  An n pin DIP has n/2 pins per row.
X*/
Xif(width == 0)
X  pinsrow = pincount;
Xelse
X  pinsrow = pincount/2;
X/*
X** Following is the calculation of row and column numbers for each
X** of the four orientations.
X*/
Xswitch ((thispin -> mychip) -> orientation)
X  {
X  case 1: if(thispin -> pinnum > pinsrow)
X             {
X             thispin -> row = row1 + width;
X             thispin -> col = col1 + pincount - thispin -> pinnum;
X             }
X           else
X             {
X             thispin -> row = row1;
X             thispin -> col = col1 + thispin -> pinnum - 1;
X             }
X           break;
X  case 2 : if(thispin -> pinnum > pinsrow)
X             {
X             thispin -> row = row1 + pincount - thispin -> pinnum;
X             thispin -> col = col1 - width;
X             }
X           else
X             {
X             thispin -> row = row1 + thispin -> pinnum - 1;
X             thispin -> col = col1;
X             }
X           break;
X  case 3 : if(thispin -> pinnum > pinsrow)
X             {
X             thispin -> row = row1 - width;
X             thispin -> col = col1 - pincount + thispin -> pinnum;
X             }
X           else
X             {
X             thispin -> row = row1;
X             thispin -> col = col1 - thispin -> pinnum + 1;
X             }
X           break;
X  case 4 : if(thispin -> pinnum > pinsrow)
X             {
X             thispin -> row = row1 - pincount + thispin -> pinnum;
X             thispin -> col = col1 + width;
X             }
X           else
X             {
X             thispin -> row = row1 - thispin -> pinnum + 1;
X             thispin -> col = col1;
X             }
X  }
X}
/
echo 'x - sort1.c'
sed 's/^X//' > sort1.c << '/'
X/*******************************************************
X*  Batcher's method sort by signalname.               *
X*  Reference: Knuth Sorting & Searching, Section 5.2.2 *
X*******************************************************/
X
X#include "wirewrap.h"
X
Xsort1()
X{
Xstruct pin tempin;
Xint p,q,r,d,n,i,j,m;
X
X/*Find the 'middle' of the array.*/
Xn = nextfree;
Xi = 1;
Xj = 2;
Xwhile(j < n)
X  {
X  i = j;
X  j = j+j;
X  }
Xm = i;  /*m is the middle of the array*/
X
X/* Batcher's method*/
Xp = m;
Xwhile(p > 0)
X  {
X  q = m;
X  r = 0;
X  d =p;
X  for(;;)
X    {
X    for(i= 0;i < n-d;i++)
X      {
X      if ( (i&p) == r)
X        if(namecmp(pinarray[i].signalname->signalname,
X           pinarray[i+d].signalname->signalname)>0)
X          {
X          tempin = pinarray[i+d];
X          pinarray[i+d] = pinarray[i];
X          pinarray[i] = tempin;
X          }
X      }
X      if(p != q)
X        {
X        d = q - p;
X        q = q/2;
X        r = p;
X        }
X      else
X        break;
X    }
X  p = p/2;
X  }
X}
/
echo 'x - sort2.c'
sed 's/^X//' > sort2.c << '/'
X/*******************************************************
X*  Batcher's method sort by signalname.               *
X*  Reference: Knuth Sorting & Searching, Section 5.2.2 *
X*******************************************************/
X
X#include "wirewrap.h"
X
Xsort2()
X{
Xstruct pin tempin;
Xint p,q,r,d,n,i,j,m;
Xint a,b,innera,innerb,outera,outerb;
X
X/*Find the 'middle' of the array.*/
Xn = nextfree;
Xi = 1;
Xj = 2;
Xwhile(j < n)
X  {
X  i = j;
X  j = j+j;
X  }
Xm = i;  /*m is the middle of the array*/
X
X/* Batcher's method*/
Xp = m;
Xwhile(p > 0)
X  {
X  q = m;
X  r = 0;
X  d =p;
X  for(;;)
X    {
X    for(i= 0;i < n-d;i++)
X      {
X      if ( (i&p) == r)
X        if(   (pinarray[i].row >  pinarray[i+d].row)
X          || ((pinarray[i].row == pinarray[i+d].row)
X          &&  (pinarray[i].col >  pinarray[i+d].col)))
X          {
X          /* First decide which two to swap. */
X          a=i;
X          b=i+d;
X          /* Then decide which ones reference them. */
X          innera = pinarray[a].inner;
X          outera = pinarray[a].outer;
X          innerb=pinarray[b].inner;
X          outerb=pinarray[b].outer;
X          /* Update those. */
X          if(innera != -1)pinarray[innera].inner=b;
X          if(outera != -1)pinarray[outera].outer=b;
X          if(innerb != -1)pinarray[innerb].inner=a;
X          if(outerb != -1)pinarray[outerb].outer=a;
X          /* Now make the swap. */
X          tempin = pinarray[b];
X          pinarray[b] = pinarray[a];
X          pinarray[a] = tempin;
X          }
X      }
X      if(p != q)
X        {
X        d = q - p;
X        q = q/2;
X        r = p;
X        }
X      else
X        break;
X    }
X  p = p/2;
X  }
X}
/
echo 'x - test.c'
sed 's/^X//' > test.c << '/'
X#include "wirewrap.h"
X#ifdef DEBUG
X
Xtest()
X{
Xint i;
Xfor(i=0; i<nextfree;i++)
X  {
X  printf("Printing pin %d\n",i);
X  printf(" Location: (%d,%d) Inner: %d Outer: %d %s\n",pinarray[i].row,
X         pinarray[i].col, pinarray[i].inner, pinarray[i].outer,
X         pinarray[i].signalname->signalname);
X  }
X}
X#endif
/
echo 'x - wirewrap.h'
sed 's/^X//' > wirewrap.h << '/'
X/***********************************************************/
X/*                                                         */
X/*  wirewrap: Wirewrap PC board Routing and documentation  */
X/*            generation system                            */
X/*                                                         */
X/***********************************************************/
X
X#include <stdio.h>
X#define minlength 1.5
X#define pinpart 0.626
X#define lengthfactor 1.01674
X#define numpins 1500     /* Maximum number of pins program can handle */
X#define NAMELENGTH 12    /* Number of chars in a signal name, chip name,
X                            or a chip position. */
X/* Following token definitions must be at least NAMELENGTH bytes long */
X#define NULLSIGNAL    ".            "
X#define CHIPTOKEN     ":CHIP        "
X#define SPECIALTOKEN  ":SPECIAL     "
X
X/* Important structures used throughout the program */
X
Xstruct signallist           /* One entry for every signal */
X  {
X  char signalname[NAMELENGTH];
X  struct signallist *succ;
X  char special;
X  }*siglistleader;
X
Xstruct chip                /* One entry for every chip */
X  {
X  char name[NAMELENGTH];
X  char position[NAMELENGTH];
X  unsigned int pincount, width, row1, col1, orientation;
X  struct chip *succ;
X  }*chipleader;
X
Xstruct pin                  /* One entry for every pin */
X  {
X  struct signallist *signalname;
X  struct chip *mychip;
X  unsigned int pinnum;
X  unsigned int row,col;
X  int inner,outer;
X  }*pinptr;
X
X/* Global variables */
X
Xstruct pin pinarray[numpins];  /* Used pin list */
Xint nextfree;                  /* Index of next free entry in the pin list */
Xint linenum;                   /* Line number within the page that the output
X                                  listing is at */
Xint inputline;               /* Line number in the input file. */
X/* #define DEBUG  /* Turns on extra debugging output. */
/
echo 'Part 02 of wirewrap program complete.'
exit