/*
** subtest_bw(test_list, status, ch)
**
** test auto left margin (bw)
*/
static void
subtest_bw(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (over_strike) {
/* test (bw) */
ptext("\n(bw) should ");
i = char_count;
ptextln("not be set.");
for (j = i; j < columns; j++)
put_str("\b");
put_str("@@@");
put_crlf();
sprintf(temp, "(bw) Auto-left-margin is %s in the data base",
auto_left_margin ? "true" : "false");
ptextln(temp);
} else {
/* test (bw) */
ptextln("(bw) should not be set.");
for (i = 12; i < columns; i++)
put_str("\b");
if (delete_character) {
for (i = 0; i < 4; i++)
tc_putp(delete_character);
} else {
put_str(" ");
}
put_crlf();
sprintf(temp, "(bw) Auto-left-margin is %s in the data base",
auto_left_margin ? "true" : "false");
ptextln(temp);
}
generic_done_message(t, state, ch);
}
/*
** subtest_rmam(test_list, status, ch)
**
** test exit automatic margins mode (rmam)
*/
static void
subtest_rmam(
struct test_list *t,
int *state,
int *ch)
{
int j;
if (!exit_am_mode) {
ptext("(rmam) not present. ");
} else if (!can_go_home) {
ptext("(rmam) not tested, no way to home cursor. ");
} else if (over_strike) {
put_clear();
go_home();
tc_putp(exit_am_mode);
ptext("\n(rmam) will reset (am)");
go_home();
for (j = 0; j < columns; j++)
put_this(' ');
ptext("(rmam) will not reset (am)");
go_home();
put_newlines(2);
} else {
put_clear();
go_home();
tc_putp(exit_am_mode);
ptext("\n(rmam) will reset (am)");
go_home();
for (j = 0; j < columns; j++)
put_this(' ');
ptext("(rmam) will not reset (am) ");
go_home();
put_str(" ");
go_home();
put_newlines(2);
}
ptext("Exit-automatic-margins ");
generic_done_message(t, state, ch);
}
/*
** subtest_smam(test_list, status, ch)
**
** test enter automatic margins mode (smam)
*/
static void
subtest_smam(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!enter_am_mode) {
ptext("(smam) not present. ");
} else if (!can_go_home) {
ptext("(smam) not tested, no way to home cursor. ");
} else if (over_strike) {
put_clear();
go_home();
tc_putp(enter_am_mode);
ptext("\n(smam) will ");
i = char_count;
ptext("not set (am)");
go_home();
for (j = -i; j < columns; j++)
put_this(' ');
put_str("@@@");
put_newlines(2);
} else {
put_clear();
go_home();
tc_putp(enter_am_mode);
ptext("\n(smam) will not set (am)");
go_home();
for (j = 0; j < columns; j++)
put_this(' ');
ptext("(smam) will set (am) ");
go_home();
put_str(" ");
put_newlines(2);
}
ptext("Enter-automatic-margins ");
generic_done_message(t, state, ch);
}
/*
** crum_ll(test_list, status, ch)
**
** (ll) test Last line
*/
static void
crum_ll(
struct test_list *t,
int *state,
int *ch)
{
/*
(ll) may be simulated with (cup). Don't complain if (cup) is present.
*/
if (cursor_to_ll) {
put_clear();
put_str("This line could be anywhere.");
tc_putp(cursor_to_ll);
ptext("This line should be on the bottom");
go_home();
put_crlf();
} else
if (cursor_address) {
return;
} else {
ptextln("(ll) Move to last line is not defined. ");
}
generic_done_message(t, state, ch);
}
int main(void)
{
/* *************************************************************************
Create Window
********************************************************************** */
wwB = 1000;
wid = pageb(100, 0, 900, wwB, "B-mode");
start();
Bx_ini = 100; By_ini = 100;
/**************************************************************************
Input Serial No.
********************************************************************** */
//printf("input beginning and end of #serial\n");
//scanf("%d %d", &iseq1);
iseq1 = 101;
printf("iseq1 = %d \n", iseq1);
printf("*******************************\n");
printf("* start analysing *\n");
printf("*******************************\n");
/* *************************************************************************
Reading Parameters from File
********************************************************************** */
start:;
if ((fin = fopen("./ssd6500.coe", "r")) == NULL){
fprintf(stderr, "cannot open dpman1M.coe\n");
exit(1);
}
icfile = 0;
while (icfile == 0){
fscanf(fin, "%d %s %d %d %s %d %f %d %d %d %d",
&islct00, name, &iseq, &nfhead, fname, &iage, &rryy, &icnt, &ip_s, &ip_d,
&anabt);
if (iseq == iseq1) icfile = 1;
if (islct00 == 9){ fclose(fin); exit(0); }
}
fclose(fin);
rmaxdh = 1e-6*icnt;
printf("islct00 = %d\n", islct00);
printf("Name of subject = %s\n", name);
printf("Serial number = %d\n", iseq);
printf("Age of subject = %d years old\n", iage);
printf("Maximal velocity range = %f m/s\n", rryy);
printf("Systolic & Diastolic blood pressure = %d, %d mmHg\n", ip_s, ip_d);
/* *************************************************************************
Read Raw Data from File
********************************************************************** */
sprintf(fall, "%s%s.rfa", fhead[nfhead], fname);
printf("File name = %s\n", fall);
if ((fin = fopen(fall, "rb")) == NULL){
printf("cannot open file: %s\n", fall);
exit(1);
}
fseek(fin, 480L, SEEK_SET);
//fread(buf,sizeof(char),480,fin);
fread(&fdat, sizeof(float), 1, fin); /* 送信周波数 [MHz] */
printf("f0 = %f Hz\n", f0 = 1e6*fdat);
fread(&fdat, sizeof(float), 1, fin); /* Burst波数 */
fread(&usdat, sizeof(unsigned short), 1, fin);
npb = usdat;
fread(&fdat, sizeof(float), 1, fin); /* PRF [kHz] */
printf("PRF = %f Hz\n", 1e3*fdat);
fread(&fdat, sizeof(float), 1, fin); /* 受信サンプリング周波数 [MHz] */
printf("fs = %f Hz\n", fs = 1e6*fdat);
fread(&fdat, sizeof(float), 1, fin); /* ビーム間隔 [mm] */
printf("beam interval = %f mm\n", elp = fdat);
fread(&usdat, sizeof(unsigned short), 1, fin); /* ビーム数 */
printf("number of beams = %d\n", nposi = usdat);
fread(&usdat, sizeof(unsigned short), 1, fin); /* ROI上端深さ(point)=0 */
printf("record offset = %d\n", usdat);
fread(&usdat, sizeof(unsigned short), 1, fin); /* ビーム数当たりサンプル数 */
printf("number of samples per line = %d\n", ncount = usdat);
fread(&usdat, sizeof(unsigned short), 1, fin); /* 開始ビーム番号 */
fread(&usdat, sizeof(unsigned short), 1, fin); /* 終了ビーム番号 */
fread(&usdat, sizeof(unsigned short), 1, fin); /* フォーカス段数 */
for (i = 0; i<7; ++i) fread(&fdat, sizeof(float), 1, fin); /* フォーカス位置設定 */
for (i = 0; i<4; ++i)
fread(&usdat, sizeof(unsigned short), 1, fin); /* フォーカス音圧設定 */
fread(&fdat, sizeof(float), 1, fin); /* ステア角 [degree] */
printf("steering angle: %f\n", fdat);
fread(&fdat, sizeof(float), 1, fin); /* フレームレート [Hz] */
printf("frame rate = %f Hz\n", PRF2 = fdat);
fread(&fdat, sizeof(float), 1, fin); /* スケールファクター */
fread(&uldat, sizeof(unsigned long), 1, fin); /* フレーム数 */
printf("number of frames = %d\n", nframe = uldat);
fread(&usdat, sizeof(unsigned short), 1, fin); /* データ情報 */
fread(&fdat, sizeof(float), 1, fin); /* 受信周波数 [MHz] */
//printf("receiving frequency: %f MHz\n",fdat);
for (i = 0; i<14; ++i) fread(&cdat, sizeof(char), 1, fin); /* 未使用 */
for (i = 0; i<4; ++i) fread(&usdat, sizeof(unsigned short), 1, fin); /* 諸設定 */
for (i = 0; i<16; ++i) fread(&cdat, sizeof(char), 1, fin); /* Sweepファイル名 */
fread(&usdat, sizeof(unsigned short), 1, fin); /* bit resolution */
fread(&usdat, sizeof(unsigned short), 1, fin); /* 波形種別 */
fread(&usdat, sizeof(unsigned short), 1, fin); /* 波形関数 */
fread(&fdat, sizeof(float), 1, fin); /* 振幅補正 */
fread(&usdat, sizeof(unsigned short), 1, fin); /* データ数 */
fread(&fdat, sizeof(float), 1, fin); /* 比帯域 */
//fread(&fdat,sizeof(float),1,fin); /* Flat比率 */
//fread(&fdat,sizeof(float),1,fin); /* 送信波形 台 */
for (i = 0; i<8; ++i) fread(&cdat, sizeof(char), 1, fin); /* スペア */
fread(&fdat, sizeof(float), 1, fin); /* 送信サンプル周波数 [MHz] */
fread(&usdat, sizeof(unsigned short), 1, fin); /* Ex-PHDのon/off */
fread(&usdat, sizeof(unsigned short), 1, fin); /* B FE-Gain上限 */
fread(&usdat, sizeof(unsigned short), 1, fin); /* B FE-Gainの下限 */
fread(&usdat, sizeof(unsigned short), 1, fin); /* B-Gain */
fread(&usdat, sizeof(unsigned short), 1, fin); /* 送信回数 */
printf("number of transmissions per line: %d\n", usdat);
fread(&usdat, sizeof(unsigned short), 1, fin); /* アライメント */
fread(&usdat, sizeof(unsigned short), 1, fin); /* プレーン識別番号 */
fread(&usdat, sizeof(unsigned short), 1, fin); /* 空間コンパウンド識別番号 */
printf("spatial compound: %d\n", usdat);
fread(&fdat, sizeof(float), 1, fin); /* 音響パワー */
fread(&usdat, sizeof(unsigned short), 1, fin); /* Interm Frame */
fread(&fdat, sizeof(float), 1, fin); /* Interm Inverval */
fread(&usdat, sizeof(unsigned short), 1, fin); /* エラスト識別番号 */
fread(&usdat, sizeof(unsigned short), 1, fin); /* RFビット位置 */
for (i = 0; i<4; ++i) fread(&cdat, sizeof(char), 1, fin);
//fread(&uldat,sizeof(unsigned long),1,fin);
/*printf("number of data = %d bytes\n",uldat);*/
/*printf("%d bytes\n",4*4+4*ncount*nposi*nframe);*/
fseek(fin, 996L, SEEK_SET); //932
// loading RF data
tcnt = (4 + ncount)*nposi*nframe;
raw_dat = (int *)malloc((size_t)(4 * tcnt));
fread(raw_dat, sizeof(int), tcnt, fin);
printf("raw size = %f\n", sizeof(raw_dat) / sizeof(int));
// loading physio data (ECG)
fread(&idcnt, sizeof(int), 1, fin);
icnt = (idcnt & 0x3FFFC00) >> 6;
printf("icnt = %d\n", icnt);
for (i = 0; i<3; ++i) fread(&idcnt, sizeof(int), 1, fin);
for (i = 0; i<icnt; ++i){
fread(&emin, sizeof(unsigned short), 1, fin);
fread(&emax, sizeof(unsigned short), 1, fin);
fread(&pmin, sizeof(unsigned short), 1, fin);
fread(&pmax, sizeof(unsigned short), 1, fin);
fread(&plmin, sizeof(unsigned short), 1, fin);
fread(&plmax, sizeof(unsigned short), 1, fin);
for (j = 0; j<18; ++j) fread(&idcnt, sizeof(unsigned short), 1, fin);
idcnt = PRF2*i / 1000.;
ecg[i] = emax;
pcg[i] = plmax;
}
fclose(fin);
fin = fopen("./ecg.dat", "w");
for (i = 0; i<icnt; ++i) fprintf(fin, "%f\n", ecg[i]);
fclose(fin);
/*fin=fopen("./pcg.dat","w");
for(i=0;i<icnt;++i) fprintf(fin,"%f\n",pcg[i]);
fclose(fin);*/
for (i = 0; i<nframe; ++i){
for (j = 0; j<nposi; ++j){
ihof[j][i] = (4 + ncount)*j + (4 + ncount)*nposi*i;
}
}
nfr_low = nframe;
printf("interval of beams = %f mm\n", elp);
dadd = 4 * 2 * elp / 0.15;
/* Post ECG */
for (i = 0; i<nframe; ++i){
MpF = (int)(1000 / PRF2*i);
ecgmax = ecg[MpF];
ecg[i] = ecgmax;
}
fin = fopen("./ecg2.dat", "w");
for (i = 0; i<nframe; ++i) fprintf(fin, "%f\n", ecg[i]);
fclose(fin);
/* *************************************************************************
Setting Parameters (Temporal)
********************************************************************** */
if (aux_flg == 0) iaux = 5;
if (aux_flg == 1) iaux = 6;
f0i = f0;
ifs = (int)(fs / 1e6);
nspc = 1;
if (SPAv == 1) nspc = 1;
/* *************************************************************************
Setting Parameters
********************************************************************** */
heartrate = 100;
p_s = (float)ip_s;
p_d = (float)ip_d;
icgain = 4000000;
idltx = 10; /* nwv wavelength (default:4x) */
idltx2 = 10;
deltad = c0 / (fs*2.0);
lp2s = (int)(2.0 / f0*fs);
lp2q = (int)(2.0 / f0*fs); /* cut off frequency in quadrature demodulation */
//f0=5.5*1e+6;
/* *************************************************************************
Memory Allocation
********************************************************************** */
if (ncount >= nframe){
dmy = (float *)malloc((size_t)(8 * (ncount + 1)));
sgn = (float *)malloc((size_t)(8 * (ncount + 1)));
}
if (nframe>ncount){
dmy = (float *)malloc((size_t)(8 * (nframe + 1)));
sgn = (float *)malloc((size_t)(8 * (nframe + 1)));
}
/* *************************************************************************
Read ECG, PCG, AUX
********************************************************************** */
ecgbias = 0.0; icnt = 0;
for (i = 0; i<nframe / 2; ++i){
ecgbias = ecgbias + ecg[i];
++icnt;
}
for (i = 0; i<nframe; ++i) ecg[i] = ecg[i] - ecgbias / (float)icnt;
ecgmax = 0.0;
for (i = 0; i<nframe / 2; ++i){
if (fabs(ecg[i])>ecgmax) ecgmax = fabs(ecg[i]);
}
pcgbias = 0.0; icnt = 0;
for (i = 0; i<nframe / 2; ++i){
pcgbias = pcgbias + pcg[i];
++icnt;
}
for (i = 0; i<nframe; ++i) pcg[i] = pcg[i] - pcgbias / (float)icnt;
pcgmax = 0.0;
for (i = 0; i<nframe / 2; ++i){
if (fabs(pcg[i])>pcgmax) pcgmax = fabs(pcg[i]);
}
/* ****************************************************************************
Detect Timing of R-wave
************************************************************************* */
nbeat = 0; beat = 0.0;
ilevel = 0.6*ecgmax;
period = 1.0 / (heartrate / 60.0);
for (j = 0; j<maxfrm; ++j){
if (j == 0) ii1 = 0;
if (j >= 1) ii1 = track0[j - 1] + (int)(PRF2*period);
if (ii1>nframe) break;
for (i = ii1 + 1; i<nframe; ++i){
if (ecg[i] >= ilevel){
track0[j] = i;
nbeat = nbeat + 1;
break;
}
if (i == nframe - 1) break;
}
if (track0[j]<0){
nbeat = nbeat - 1;
break;
}
if (track0[j] == 0) break;
for (i = 0; i <= j - 1; ++i){
beat = beat + (float)(track0[i + 1] - track0[i]);
}
beat = beat / (float)(j + 1);
}
tbeat = beat / fs * 1000;
/*for(i=0;i<nbeat;++i){
rr=ecg[track0[i]];
for(j>track0[i]-(int)(0.01*PRF2);j<track0[i]+(int)(0.01*PRF2);++j){
if(j>=0 && j<nframe && fabs(ecg[j])>rr){
rr=fabs(ecg[j]);
icnt=j;
}
}
track0[i]=j;
}*/
for (i = 0; i<nbeat; ++i){
printf("track0(%d) = %d\n", i, track0[i]);
}
//nbeat=2;
//track0[0]=0; track0[1]=nframe;
/* *************************************************************************
Setting Parameters
********************************************************************** */
ifrm1 = 0;
ifrm2 = nframe;
if (nbeat == 0){
ifrm1 = 0;
ifrm2 = nframe;
}
if (nbeat>0){
ifrm1 = track0[0] - (int)(0.2*PRF2);
if (ifrm1<0) ifrm1 = 0;
ifrm2 = nframe;
}
printf("ifrm1, ifrm2 = %d, %d\n", ifrm1, ifrm2);
if (ifrm1<0 || ifrm2>nframe || ifrm1>ifrm2) exit(0);
/* *************************************************************************
Display B-mode Image
********************************************************************** */
rmaxz = 0.0;
for (i = 0;i < nposi;++i){
for (j = 0; j < ncount; ++j) {
dmy[j] = pow((float)raw_dat[ihof[i][track0[0]] + j + 4], 2);
}
wint2s(wary, lp2s);
ndmy = ncount;
lpfs(wary, dmy, sgn, lp2s, ndmy);
for (j = 0; j<ncount; ++j){
sgn[j] = sqrt(sgn[j]);
if (fabs(sgn[j])>rmaxz) rmaxz = fabs(sgn[j]);
}
}
rwb = dadd / 8.;
nwb = (int)rwb;
/* 直交検波 */
for (i = 0; i<nposi; ++i){
for (j = 0; j<ncount; ++j){
dmy[j] = pow((float)raw_dat[ihof[i][track0[0]] + j + 1], 2);
}
wint2s(wary, lp2s);
ndmy = ncount;
lpfs(wary, dmy, sgn, lp2s, ndmy);
for (j = 0; j<ncount; ++j) sgn[j] = sqrt(sgn[j]);
for (j = 0; j<ncount; ++j){
ic = 49 + (int)(100.*(20.*log10((sgn[j] + 1e-4) / rmaxz) + B_gain) / B_gain);
if (ic<49) ic = 49;
if (ic>148) ic = 148;
ic = (ic - 49) * 255 / 99;
gscolor = gscol256(ic, ic, ic);
for (k = 0;k < (int)(izoom_B / (mpp / deltad) + 1);++k) {
gsline(Bx_ini + (int)(izoom_B*rwb*i),
By_ini + (int)(izoom_B*j*deltad / mpp) + k,
Bx_ini + (int)(izoom_B*rwb*(i + 1)),
By_ini + (int)(izoom_B*j*deltad / mpp) + k,
gscolor);
}
}
}
gscolor = gscol256(0, 0, 0);
gsline(Bx_ini - 15, By_ini, Bx_ini - 15,
By_ini + (int)(izoom_B*ncount*deltad / mpp), gscolor);
for (i = 0;i<ncount;i = i + (int)(5 * mpp / deltad)) {
gsline(Bx_ini - 15, By_ini + (int)(izoom_B*i*deltad / mpp),
Bx_ini - 10, By_ini + (int)(izoom_B*i*deltad / mpp), gscolor);
}
for (i = 0;i<ncount / 5;i = i + (int)(5 * mpp / deltad)) {
gsline(Bx_ini - 15, By_ini + (int)(5.*izoom_B*i*deltad / mpp),
Bx_ini - 5, By_ini + (int)(5.*izoom_B*i*deltad / mpp), gscolor);
}
gsline(Bx_ini, By_ini - 15, Bx_ini + (int)(izoom_B*rwb*nposi), By_ini - 15, gscolor);
for (i = 0;i<(int)(rwb*nposi / 10.) + 1;++i) {
gsline(Bx_ini + izoom_B * 10 * i, By_ini - 15,
Bx_ini + izoom_B * 10 * i, By_ini - 5, gscolor);
}
sprintf(buf, "%4d %56s", iseq, fall);
ptext(10, By_ini - 65, strlen(buf), buf);
sprintf(buf, "age:%2d BP: %3d/%3d", iage, ip_s, ip_d);
ptext(10, By_ini - 50, strlen(buf), buf);
sprintf(buf, "mkdirhier ./images/%s", fname);
//system(buf);
/*sprintf(buf,"import -window 0x%x -crop %dx%d+%d+%d -silent ./images/%s/Bmode.gif",
wid,(int)(izoom_B*rwb*nposi),
(int)(izoom_B*ncount*deltad/mpp),
Bx_ini,wwB-By_ini+60,fname);*/
sprintf(buf, "import -window 0x%x -silent ./images/%s/Bmode.gif", wid, fname);
//system(buf);
/* *************************************************************************
Setting Tracking Position by Tracing B-mode (itrace=1)
********************************************************************** */
if (itrace == 1){
gscolor = gscol256(0,0,255);
for (i = 0; i<nposi; ++i) ipeakflg[i] = 0;
cursorpos(0, 0);
trackingpoint_top();
cursorpos(0, 0);
for (i = 0; i<nposi0; ++i) ipeakflg[i] = 0;
trackingpoint_bot();
///* Save Peak Position */
//fin = fopen("./tmp/peaks", "w");
//for (i = 0; i<nposi; ++i)
// fprintf(fin, "%d %d %d %d\n", ipeak11[i], ipeak22[i], ipeak33[i], ipeak44[i]);
//fclose(fin);
}
if (itrace == 0){
sprintf(buf, "./tmp/peaks.%d", iseq1);
fin = fopen(buf, "r");
for (i = 0; i<nposi; ++i){
fscanf(fin, "%d %d %d %d", &ip1, &ip2, &ip3, &ip4);
ipeak11[i] = ip1; ipeak22[i] = ip2; ipeak33[i] = ip3; ipeak44[i] = ip4;
}
fclose(fin);
}
if (DispTr == 1){
gscolor = gscol256(255,0,0);
for (i = 0; i<nposi; ++i){
gscolor = gscol256(0,0,0);
for (k = 0; k<(int)(izoom_B / (mpp / deltad) + 1); ++k)
gsline(Bx_ini + (int)(izoom_B*rwb*i),
By_ini - (int)(izoom_B*ipeak33[i] * deltad / mpp) - k,
Bx_ini + (int)(izoom_B*rwb*(i + 1)),
By_ini - (int)(izoom_B*ipeak33[i] * deltad / mpp) - k, gscolor);
}
}
for (i = 0; i<nposi; ++i){
if (ipeak44[i] - ipeak33[i]<4 * idltx2) ipeak44[i] = ipeak33[i] + 4 * idltx2;
}
Sleep(1);
gscolor = gscol256(0,0,0);
if (ipause == 1){
printf("Input 0 if ready to go next.\n");
scanf("%d", &iflg);
}
/* *************************************************************************
Clear Window
********************************************************************** */
eraseg();
/* *************************************************************************
Estimation of Displacements
********************************************************************** */
ifrm1 = track0[anabt]; ifrm2 = track0[anabt + 2]; dsh = 1;
for (i = 0; i<nDFT; ++i) han_w[i] = 0.5 - 0.5*cos(rad*i / (float)nDFT);
sprintf(buf, "mkdirhier ./images/%s/Mmode", fname);
//system(buf);
//sprintf(buf, "./ddmax_%s.dat", fname);
sprintf(buf, "./ddmax.dat", fname);
fin = fopen(buf, "w");
for (iiposi = 0; iiposi<nposi; ++iiposi){
ddmax = 0.0;
eraseg();
sprintf(buf, "%4d %56s", iseq, fall);
ptext(100, wwB + 10, strlen(buf), buf);
sprintf(buf, "age:%2d, BP: %3d/%3d, vel. max: %5.1f mm/s, dd max: %6.1f um, beam position: %2d",
iage, ip_s, ip_d, 1e3*rryy, 1e6*rmaxdh, iiposi + 1);
ptext(100, wwB + 22, strlen(buf), buf);
if (aux_flg == 0)
sprintf(buf, "max. & bias of ECG: %7.1f, %7.1f, max. PCG: %7.1f",
ecgmax, ecgbias / PRF2, pcgmax);
if (aux_flg == 1)
sprintf(buf, "max & bias of ECG: %7.1f, %7.1f, max. PULSE: %7.1f",
ecgmax, ecgbias / PRF2, pcgmax);
ptext(100, wwB + 34, strlen(buf), buf);
/* *************************************************************************
Setting Tracking Position and Number of Tracking Points
********************************************************************** */
ndep[iiposi] = 2;
/* *************************************************************************
Display M-mode Image
********************************************************************** */
lp2s = (int)(2.0 / f0*fs);
Mx_ini = 50; My_ini = 800;
ry0 = nframe / 200.;
iy0 = (int)ry0;
if (iy0<1) iy0 = 1;
for (i = 0; i<200; ++i){
for (j = 0; j<ncount; ++j)
dmy[j] = pow((float)raw_dat[ihof[iiposi][(int)(ry0*i)] + j], 2);
wint2s(wary, lp2s);
ndmy = ncount;
lpfs(wary, dmy, sgn, lp2s, ndmy);
for (j = 0; j<ncount; ++j)
sgn[j] = sqrt(sgn[j]);
for (j = 0; j<ncount; j = j + (int)(mpp / deltad / izoom_M)){
ic = 49 + (int)(100.*((20.*log10(sgn[j] / rmaxz) + B_gain) / B_gain));
if (ic<49) ic = 49;
if (ic>148) ic = 148;
ic = (ic - 49) * 255 / 99;
gscolor = gscol256(ic, ic, ic);
for (k = -1; k <= 1; ++k)
gsline(Mx_ini + (int)(izoom_M*j*deltad / mpp), My_ini - 3 * i - k,
Mx_ini + (int)(izoom_M*j*deltad / mpp), My_ini - 3 * (i + 1) - k, gscolor);
}
}
gscolor = gscol256(0, 0, 0);
gsline(Mx_ini, My_ini + 15,
Mx_ini + (int)(izoom_M*ncount*deltad / mpp), My_ini + 15, gscolor);
for (i = 0; i < ncount; i = i + (int)(5 * mpp / deltad)) {
gsline(Mx_ini + (int)(izoom_M*i*deltad / mpp), My_ini + 15,
Mx_ini + (int)(izoom_M*i*deltad / mpp), My_ini + 10, gscolor);
}
for (i = 0; i < ncount / 5; i = i + (int)(5 * mpp / deltad)) {
gsline(Mx_ini + (int)(5.*izoom_M*i*deltad / mpp), My_ini + 15,
Mx_ini + (int)(5.*izoom_M*i*deltad / mpp), My_ini + 5, gscolor);
}
gsline(Mx_ini + (int)(izoom_M*ncount*deltad / mpp) + 10, My_ini,
Mx_ini + (int)(izoom_M*ncount*deltad / mpp) + 10, My_ini - 600, gscolor);
for (i = 0; i < (int)(2.*nframe / PRF2) + 1; ++i) {
gsline(Mx_ini + (int)(izoom_M*ncount*deltad / mpp) + 10,
My_ini - (int)(300.*PRF2 / nframe*i),
Mx_ini + (int)(izoom_M*ncount*deltad / mpp) + 5,
My_ini - (int)(300.*PRF2 / nframe*i), gscolor);
}
/* *************************************************************************
Frame for Displaying Signals
********************************************************************** */
for (i = 0; i<4; ++i){
gsrect(Mx_ini + (int)(izoom_M*ncount*deltad / mpp) + 20 + 100 * i,
My_ini + 15,
Mx_ini + (int)(izoom_M*ncount*deltad / mpp) + 110 + 100 * i,
My_ini - 615, RGB(255, 255, 255), RGB(0, 0, 0));
}
for (i = 0; i<4; ++i){
for (j = 0; j<2; ++j){
for (k = 0; k<3; ++k){
gsline(Mx_ini + (int)(izoom_M*ncount*deltad / mpp) + 30 + 35 * k + 100 * i,
My_ini + 15 - 622 * j,
Mx_ini + (int)(izoom_M*ncount*deltad / mpp) + 30 + 35 * k + 100 * i,
My_ini + 15 - 8 - 622 * j, gscolor);
}
}
}
for (i = 0; i<4; ++i){
gsline_d(Mx_ini + (int)(izoom_M*ncount*deltad / mpp) + 20 + 45 + 100 * i, My_ini,
Mx_ini + (int)(izoom_M*ncount*deltad / mpp) + 20 + 45 + 100 * i,
My_ini - 600, gscolor);
}
for (i = 0; i<4; ++i){
for (j = 0; j<2; ++j){
for (k = 0; k<(int)(2.*(ifrm2 - ifrm1) / PRF2) + 1; ++k){
gsline(Mx_ini + (int)(izoom_M*ncount*deltad / mpp) + 20 + 100 * i + 82 * j,
My_ini - (int)(300.*PRF2 / (ifrm2 - ifrm1)*k),
Mx_ini + (int)(izoom_M*ncount*deltad / mpp) + 20 + 8 + 100 * i + 82 * j,
My_ini - (int)(300.*PRF2 / (ifrm2 - ifrm1)*k), gscolor);
}
}
}
/* *************************************************************************
Display ECG
********************************************************************** */
ry0 = 600. / nframe; rx0 = 35. / ecgmax;
for (i = 0; i<nframe - 2; ++i){
nx0 = (int)(izoom_M*ncount*deltad / mpp) + 20 + 45;
gsline(Mx_ini + nx0 - (int)(rx0*ecg[i]),
My_ini - (int)(ry0*i),
Mx_ini + nx0 - (int)(rx0*ecg[i + 1]),
My_ini - (int)(ry0*(i + 1)), gscolor);
}
/* *************************************************************************
Display Timing of R-wave
********************************************************************** */
if (nbeat != 0){
nbeat2 = nbeat;
for (i = 0; i<nbeat; ++i){
if (track0[i]>0){
nbeat1 = i;
break;
}
}
for (i = 0; i<nbeat; ++i){
if (track0[i]>nframe){
nbeat2 = i - 1;
break;
}
}
if (nbeat1 == 0) nbeat1 = 0;
if (nbeat2 == 0) nbeat2 = 0;
gscolor = gscol256(255, 0, 0);
nx0 = (int)(izoom_M*ncount*deltad / mpp);
for (i = nbeat1; i<nbeat2; ++i){
gsline_d(Mx_ini, My_ini - (int)(ry0*track0[i]),
Mx_ini + nx0, My_ini - (int)(ry0*track0[i]), gscolor);
}
nx0 = (int)(izoom_M*ncount*deltad / mpp) + 30;
for (i = 0; i<4; ++i){
for (j = nbeat1; j<nbeat2; ++j){
gsline_d(Mx_ini + nx0 + 100 * i, My_ini - (int)(ry0*track0[j]),
Mx_ini + nx0 + 70 + 100 * i, My_ini - (int)(ry0*track0[j]), gscolor);
}
}
gscolor = gscol256(0, 0, 0);
}
/* *************************************************************************
Display PCG
********************************************************************** */
/*ry0=600./nframe; rx0=35./pcgmax;
for(i=0;i<nframe-1;++i){
nx0=(int)(izoom_M*ncount*deltad/mpp)+20+145;
gsline(Mx_ini+nx0-(int)(rx0*pcg[i]),
My_ini+(int)(ry0*i),
Mx_ini+nx0-(int)(rx0*pcg[i+1]),
My_ini+(int)(ry0*(i+1)));
}*/
/* *************************************************************************
Start of Loop for Frame for Displacement Estimation
********************************************************************** */
for (idcnt = 0; idcnt<ndep[iiposi]; ++idcnt){
disp[idcnt][ifrm1] = 0.0;
dd[ifrm1] = 0.0;
}
ip1 = 0; ip2 = ncount;
for (ifrm = ifrm1; ifrm<ifrm2; ++ifrm){
/* Quadrature Demodulation */
czeros = cmplx(0.0, 0.0);
for (i = -1; i<2; ++i){
if (iiposi + i>-1 && iiposi + i<nposi){
/* For Previous Frame */
if (ifrm == ifrm1){
for (j = ip1; j<ip2; ++j){
qdr_p[j][i + 1] = 0.0; qdi_p[j][i + 1] = 0.0; icnt = 0;
for (k = -nDFT / 2; k < nDFT / 2; ++k) {
if (j + k >= 0 && j + k<ncount){
qdr_p[j][i + 1] = qdr_p[j][i + 1] + han_w[k + nDFT / 2] *
cos(nfrq*rad*(k + nDFT / 2) / (float)nDFT)*
(float)raw_dat[ihof[iiposi + i][ifrm] + j + k];
qdi_p[j][i + 1] = qdi_p[j][i + 1] - han_w[k + nDFT / 2] *
sin(nfrq*rad*(k + nDFT / 2) / (float)nDFT)*
(float)raw_dat[ihof[iiposi + i][ifrm] + j + k];
++icnt;
}
}
qdr_p[j][i + 1] = qdr_p[j][i + 1] / (float)icnt;
qdi_p[j][i + 1] = qdi_p[j][i + 1] / (float)icnt;
}
}
/* For Post-Frame */
for (j = ip1; j<ip2; ++j){
qdr_f[j][i + 1] = 0.0; qdi_f[j][i + 1] = 0.0; icnt = 0;
for (k = -nDFT / 2; k<nDFT / 2; ++k){
if (j + k >= 0 && j + k<ncount){
qdr_f[j][i + 1] = qdr_f[j][i + 1] + han_w[k + nDFT / 2] *
cos(nfrq*rad*(k + nDFT / 2) / (float)nDFT)*
(float)raw_dat[ihof[iiposi + i][ifrm + 1] + j + k];
qdi_f[j][i + 1] = qdi_f[j][i + 1] - han_w[k + nDFT / 2] *
sin(nfrq*rad*(k + nDFT / 2) / (float)nDFT)*
(float)raw_dat[ihof[iiposi + i][ifrm + 1] + j + k];
++icnt;
}
}
qdr_f[j][i + 1] = qdr_f[j][i + 1] / (float)icnt;
qdi_f[j][i + 1] = qdi_f[j][i + 1] / (float)icnt;
}
}
}
/* Start of Loop of Depth for Displacement Estimation */
for (idcnt = 0; idcnt<ndep[iiposi]; ++idcnt){
if (ifrm == ifrm1){
if (idcnt == 0) peak0[idcnt] = ipeak11[iiposi];
if (idcnt == 1) peak0[idcnt] = ipeak22[iiposi];
}
xpeak0[idcnt] = (float)peak0[idcnt];
// velocity estimation
crr0 = czeros; crr1 = czeros;
for (ispc = -nspc; ispc<nspc + 1; ++ispc){
if (iiposi + ispc >= 0 && iiposi + ispc<nposi){
for (i = 0; i <= 2 * idltx; ++i){
if (i + peak0[idcnt] >= 0 && i + peak0[idcnt]<ncount){
rr = qdr_p[i + peak0[idcnt]][ispc + 1];
ri = qdi_p[i + peak0[idcnt]][ispc + 1];
cdmyp = cmplx(rr, ri);
rr = qdr_f[i + peak0[idcnt]][ispc + 1];
ri = qdi_f[i + peak0[idcnt]][ispc + 1];
cdmy = cmplx(rr, ri);
ctemp = conjg(cdmyp);
crr0 = cadd(crr0, cmul(cdmy, ctemp));
}
}
}
}
vel_p[idcnt] = vel[idcnt];
if (ifrm == ifrm1) vel_p[idcnt] = 0.0;
vel[idcnt] = -0.5*c0*atan2(crr0.i, crr0.r) / rad / f0;
disp[idcnt][ifrm + 1] = disp[idcnt][ifrm] + vel[idcnt];
if (idcnt == 0){
xpeak0[idcnt] = ipeak11[iiposi] + disp[idcnt][ifrm + 1] / deltad;
}
if (idcnt == 1){
xpeak0[idcnt] = ipeak22[iiposi] + disp[idcnt][ifrm + 1] / deltad;
}
peak0[idcnt] = (int)xpeak0[idcnt];
}
dd[ifrm + 1] = disp[1][ifrm + 1] - disp[0][ifrm + 1];
ry0 = 600. / nframe;
for (idcnt = 0; idcnt<ndep[iiposi]; ++idcnt){
/* Display Tracked Position */
gscolor = gscol256(255, 0, 0);
if (ifrm >= ifrm1 && ifrm<ifrm2)
gsline(Mx_ini + (int)(izoom_M*peak0[idcnt] * deltad / mpp),
My_ini - (int)(ry0*ifrm),
Mx_ini + (int)(izoom_M*peak0[idcnt] * deltad / mpp),
My_ini - (int)(ry0*(ifrm + 1)), gscolor);
gscolor = gscol256(255, 255, 255);
gsline(Mx_ini + 1 + (int)(izoom_M*peak0[idcnt] * deltad / mpp),
My_ini - (int)(ry0*ifrm),
Mx_ini + 1 + (int)(izoom_M*peak0[idcnt] * deltad / mpp),
My_ini - (int)(ry0*(ifrm + 1)), gscolor);
gscolor = gscol256(0, 0, 0);
/* Display Velocity */
rx0 = 35. / rryy;
if (idcnt == 0) nx0 = (int)(izoom_M*ncount*deltad / mpp) + 20 + 145;
if (idcnt == 1) nx0 = (int)(izoom_M*ncount*deltad / mpp) + 20 + 245;
if (ifrm > ifrm1 && ifrm < ifrm2 - 1) {
gsline(Mx_ini + nx0 + (int)(rx0*vel_p[idcnt] * PRF2),
My_ini - (int)(ry0*ifrm),
Mx_ini + nx0 + (int)(rx0*vel[idcnt] * PRF2),
My_ini - (int)(ry0*(ifrm + 1)), gscolor);
}
}
/* Display Change in Diameter */
rx0 = 35. / rmaxdh;
nx0 = (int)(izoom_M*ncount*deltad / mpp) + 20 + 345;
if (ifrm >= ifrm1 && ifrm<ifrm2 - 1){
gsline(Mx_ini + nx0 - (int)(rx0*dd[ifrm]),
My_ini - (int)(ry0*ifrm),
Mx_ini + nx0 - (int)(rx0*dd[ifrm + 1]),
My_ini - (int)(ry0*(ifrm + 1)), gscolor);
}
for (i = 0; i<3; ++i){
for (j = 0; j<ncount; ++j){
qdr_p[j][i] = qdr_f[j][i]; qdi_p[j][i] = qdi_f[j][i];
}
}
if (ddmax>dd[ifrm + 1])
ddmax = dd[ifrm + 1];
} // end of loop of frame
sprintf(buf, "import -window 0x%x -silent ./images/%s/Mmode/pos%d.gif", wid, fname, iiposi);
//system(buf);
fprintf(fin, "%d %f\n", iiposi, ddmax*1e+6);
} // end of loop of beam position
fclose(fin);
/* *************************************************************************
Terminate Program
********************************************************************** */
free(raw_dat); free(sgn); free(dmy);
end();
printf("INPUT 0 for termination of program.\n");
scanf("%d", &iflg);
printf("*******************************\n");
printf("* normally terminated *\n");
printf("*******************************\n");
}
int
depchkReportErrors(depckl_t *a_dck)
{
char *packageName;
char *zonenames;
char msgbuf[4096];
int err;
int i;
int numzones = 0;
/* entry assertions */
assert(a_dck != (depckl_t *)NULL);
/* entry debugging info */
echoDebug(DBG_DEPCHK_ENTRY);
zonenames = (char *)NULL;
/* go through dependency table, collect, collapse, report errors */
for (i = 0; a_dck[i].name != (char *)NULL; i++) {
int j;
depckError_t *erc;
if (zonenames != (char *)NULL) {
free(zonenames);
zonenames = (char *)NULL;
}
erc = a_dck[i].record;
if (erc->er_numEntries == 0) {
continue;
}
for (j = 0; j < erc->er_numEntries; j++) {
int k;
depckErrorRecord_t *eir;
if (zonenames != (char *)NULL) {
free(zonenames);
zonenames = (char *)NULL;
}
eir = &erc->er_theEntries[j];
packageName = eir->ier_packageName;
for (k = 0; k < eir->ier_numZones; k++) {
int err;
err = collectError(&numzones, &zonenames,
packageName, a_dck, i, eir, k);
if (err != 0) {
if (zonenames != (char *)NULL) {
free(zonenames);
zonenames = (char *)NULL;
}
return (err);
}
}
if (a_dck[i].ignore_values == (char *)NULL) {
continue;
}
if (a_dck[i].err_msg == (char **)NULL) {
(void) snprintf(msgbuf, sizeof (msgbuf),
ERR_DEPENDENCY_IGNORED, a_dck[i].name,
packageName,
numzones == 1 ? "zone" : "zones",
zonenames ? zonenames : "?");
} else {
/* LINTED variable format specifier to ... */
(void) snprintf(msgbuf, sizeof (msgbuf),
*a_dck[i].err_msg, "package",
packageName,
numzones == 1 ? "zone" : "zones",
zonenames ? zonenames : "??");
}
if (a_dck[i].depcklFunc != NULL) {
/* call check function */
err = (a_dck[i].depcklFunc)(msgbuf,
packageName);
echoDebug(DBG_DEPCHK_REPORT_ERROR,
a_dck[i].ignore_values, err,
packageName, msgbuf);
if (err != 0) {
if (zonenames != (char *)NULL) {
free(zonenames);
zonenames = (char *)NULL;
}
return (err);
}
} else {
/* no check function - just report message */
echoDebug(DBG_DEPCHK_IGNORE_ERROR,
a_dck[i].ignore_values, packageName,
msgbuf);
ptext(stderr, "\\n%s", msgbuf);
}
}
}
if (zonenames != (char *)NULL) {
free(zonenames);
zonenames = (char *)NULL;
}
return (0);
}
/*
** subtest_hts(test_list, status, ch)
**
** (ht) and set tabs with (hts)
*/
static void
subtest_hts(
struct test_list *t,
int *state,
int *ch)
{
int tabat; /* the tab spacing we end up with */
int i;
tabat = init_tabs;
if (set_tab) {
ptext("Tabs set with (hts)");
put_crlf();
for (i = 1; i < columns; i++) {
if (i % 8 == 1) {
tc_putp(set_tab);
}
putchp(' ');
}
tabat = 8;
} else {
sprintf(temp, "(hts) Set-tabs not defined. (it) Initial-tabs at %d", init_tabs);
ptext(temp);
}
go_home();
put_newlines(2);
if (tabat <= 0) {
tabat = 8;
}
for (i = tabat; i < columns; i += tabat) {
putchp('\t');
putchp('T');
}
go_home();
put_newlines(3);
for (i = 1; i < columns; i++) {
putchp('.');
}
go_home();
put_newlines(3);
for (i = tabat; i < columns; i += tabat) {
putchp('\t');
putchp('T');
}
go_home();
put_newlines(4);
putchp('.');
for (i = 2; i < columns; i++) {
if (i % tabat == 1) {
putchp('T');
} else {
putchp('.');
}
}
go_home();
put_newlines(5);
if (set_tab) {
ptextln("If the last two lines are not the same then (hts) has failed.");
} else
if (init_tabs > 0) {
ptextln("If the last two lines are not the same then (it) is wrong.");
} else {
ptextln("If the last two lines are the same then maybe you do have tabs and (it) should be changed.");
}
generic_done_message(t, state, ch);
}
void
reset_init(void)
{ /* send the reset and init strings */
int i;
ptext("Terminal reset");
i = char_count;
put_name(reset_1string, " (rs1)");
put_name(reset_2string, " (rs2)");
/* run the reset file */
if (reset_file && reset_file[0]) {
FILE *fp;
int ch;
can_test("rf", FLAG_TESTED);
if ((fp = fopen(reset_file, "r"))) { /* send the reset file */
sprintf(temp, " (rf) %s", reset_file);
ptextln(temp);
while (1) {
ch = getc(fp);
if (ch == EOF)
break;
put_this(ch);
}
fclose(fp);
} else {
sprintf(temp, "\nCannot open reset file (rf) %s", reset_file);
ptextln(temp);
}
}
put_name(reset_3string, " (rs3)");
if (i != char_count) {
put_crlf();
}
ptext(" init");
put_name(init_1string, " (is1)");
put_name(init_2string, " (is2)");
if (set_tab && clear_all_tabs && init_tabs != 8) {
put_crlf();
tc_putp(clear_all_tabs);
for (char_count = 0; char_count < columns; char_count++) {
put_this(' ');
if ((char_count & 7) == 7) {
tc_putp(set_tab);
}
}
put_cr();
}
/* run the initialization file */
if (init_file && init_file[0]) {
FILE *fp;
int ch;
can_test("if", FLAG_TESTED);
if ((fp = fopen(init_file, "r"))) { /* send the init file */
sprintf(temp, " (if) %s", init_file);
ptextln(temp);
while (1) {
ch = getc(fp);
if (ch == EOF)
break;
put_this(ch);
}
fclose(fp);
} else {
sprintf(temp, "\nCannot open init file (if) %s", init_file);
ptextln(temp);
}
}
if (init_prog) {
can_test("iprog", FLAG_TESTED);
(void) system(init_prog);
}
put_name(init_3string, " (is3)");
fflush(stdout);
}
/*
** menu_prompt()
**
** Print the menu prompt string.
*/
void
menu_prompt(void)
{
ptext(&prompt_string[1]);
}
void
scan_init(char *fn)
{ /* read the scan mode key definitions */
char *s, *sl;
FILE *fp;
int ch, i, j;
unsigned len;
char home[512];
if ((str = getenv("HOME")))
strcpy(home, str);
else
home[0] = '\0';
fp = NULL;
if ((str = getenv("KEYBOARD"))) {
if (!(fp = fopen(str, "r")) && home[0]) {
sprintf(temp, "%s/.scan.%s", home, str);
fp = fopen(temp, "r");
}
}
if (!fp) {
sprintf(temp, ".scan.%s", fn);
fp = fopen(temp, "r");
}
if (!fp && home[0]) {
sprintf(temp, "%s/.scan.%s", home, fn);
fp = fopen(temp, "r");
}
if (!fp) {
ptext("Unable to open scanfile: ");
ptextln(temp);
bye_kids(EXIT_FAILURE);
return;
}
/*
scan file format:
<down value> <up value> <name>
values are in hex. <name> may be any string of characters
*/
scan_up = (char **) malloc(sizeof(char *) * MAX_SCAN);
scan_down = (char **) malloc(sizeof(char *) * MAX_SCAN);
scan_name = (char **) malloc(sizeof(char *) * MAX_SCAN);
scan_tested = (unsigned *) malloc(sizeof(unsigned *) * MAX_SCAN);
scan_length = (unsigned *) malloc(sizeof(unsigned *) * MAX_SCAN);
scan_value = (unsigned *) malloc(sizeof(unsigned *) * MAX_SCAN);
scan_up[0] = scan_down[0] = scan_name[0] = (char *) 0;
str = (char *) malloc(4096); /* buffer space */
sl = str + 4000; /* an upper limit */
scan_max = 1;
for (i = 0;;) {
for (s = str; (ch = getc(fp)) != EOF;) {
if (ch == '\n' || ch == '\r')
break;
*s++ = (char) ch;
}
*s++ = '\0';
if (ch == EOF)
break;
if (*str == '#' || *str == '\0')
continue;
scan_down[i] = smash();
scan_blanks();
scan_up[i] = smash();
scan_blanks();
scan_name[i] = str;
scan_length[i] = strlen(scan_down[i]);
len = strlen(scan_up[i]) + scan_length[i];
if (len > scan_max)
scan_max = len;
scan_value[i] = UChar(scan_name[i][0]);
if (scan_name[i][1]) /* multi-character name */
for (j = 0; scan_special[j].name; j++) {
if (!strcmp(scan_name[i], scan_special[j].name)) {
scan_value[i] = scan_special[j].type;
break;
}
}
i++;
if (str > sl) {
str = (char *) malloc(4096);
sl = str + 4000;
} else
str = s;
}
fclose(fp);
#ifdef notdef
for (i = 0; scan_down[i]; i++) {
put_str(hex_expand_to(scan_down[i], 3));
put_str(hex_expand_to(scan_up[i], 3));
put_str(" ");
put_str(scan_name[i]);
put_crlf();
}
(void) wait_here();
#endif
}
void AGOSEngine_PN::pobjd(int n, int m) {
if (n > getptr(51))
error("Object out of range");
ptext(ftext(getlong(27), n * _dataBase[47] + m));
}
void AGOSEngine_PN::plocd(int n, int m) {
if (n > getptr(53))
error("Location out of range");
ptext(ftext(getlong(21), n * _dataBase[48] + m));
}
void AGOSEngine_PN::pmesd(int n) {
ptext(ftext(getlong(24), n));
}
/*
* This returns the correct package instance based on how many packages are
* already installed. If there are none (npkgs == 0), it just returns the
* package abbreviation. Otherwise, it interacts with the user (or reads the
* admin file) to determine if we should overwrite an instance which is
* already installed, or possibly install a new instance of this package
*/
char *
getinst(int *updatingExisting, struct pkginfo *info, int npkgs,
boolean_t a_preinstallCheck)
{
char *inst;
char *sameinst;
int i;
int nsamearch;
int samearch;
/* entry debugging info */
same_pkg = 0;
/*
* If this is the first instance of the package, it's called the by
* the package abbreviation.
*/
if (npkgs == 0) {
return (pkgabrv);
}
/*
* this package is already installed; determine how to handle the
* new instance of the package to install
*/
if (ADM(instance, "newonly") || ADM(instance, "quit")) {
/*
* new instance is required, or quit if not new
*/
msgtext = MSG_NEWONLY;
if (a_preinstallCheck == B_FALSE) {
ptext(stderr, msgtext, pkgabrv);
} else {
(void) fprintf(stdout, "install-new-only=true\n");
(void) fprintf(stdout, "ckinstance=4\n");
}
quit(4);
}
/*
* package already installed and new instance not required
* see if updating the same instance of the package
*/
samearch = nsamearch = 0;
sameinst = NULL;
for (i = 0; i < npkgs; i++) {
if (strcmp(info[i].arch, pkgarch) == 0) {
samearch = i;
nsamearch++;
if (strcmp(info[i].version, pkgvers) == 0) {
sameinst = info[i].pkginst;
}
}
}
if (sameinst) {
/* same instance of package */
if (a_preinstallCheck == B_FALSE) {
ptext(stderr, MSG_SAME);
} else {
(void) fprintf(stdout, "install-same-instance=true\n");
(void) fprintf(stdout, "ckinstance=0\n");
}
inst = sameinst; /* can't be overwriting a pre-svr4 package */
same_pkg++;
(*updatingExisting)++;
return (inst);
}
if (ADM(instance, "overwrite")) {
/* not the same instance of the package */
if (npkgs == 1) {
samearch = 0; /* use only package we know about */
} else if (nsamearch != 1) {
/*
* more than one instance of the same ARCH is already
* installed on this machine
*/
msgtext = MSG_OVERWRITE;
if (a_preinstallCheck == B_FALSE) {
ptext(stderr, msgtext);
} else {
(void) fprintf(stdout,
"install-ovewrite=true\n");
(void) fprintf(stdout, "ckinstance=4\n");
}
quit(4);
}
inst = info[samearch].pkginst;
if (info[samearch].status == PI_PRESVR4) {
opresvr4++; /* overwriting a pre-svr4 package */
}
(*updatingExisting)++;
return (inst);
}
if (ADM(instance, "unique")) {
if (maxinst <= npkgs) {
/* too many instances */
msgtext = MSG_UNIQ1;
if (a_preinstallCheck == B_FALSE) {
ptext(stderr, msgtext, pkgabrv);
} else {
(void) fprintf(stdout,
"install-too-many-instances=true\n");
(void) fprintf(stdout, "ckinstance=4\n");
}
quit(4);
}
inst = nextinst();
return (inst);
}
if (a_preinstallCheck == B_FALSE) {
if (echoGetFlag() == B_FALSE) {
msgtext = MSG_NOINTERACT;
ptext(stderr, msgtext);
quit(5);
}
} else {
(void) fprintf(stdout, "install-new-instance=true\n");
(void) fprintf(stdout, "ckinstance=1\n");
}
inst = prompt(info, npkgs);
if (strcmp(inst, "new") == 0) {
inst = nextinst();
return (inst);
}
(*updatingExisting)++;
/* see if this instance is presvr4 */
for (i = 0; i < npkgs; i++) {
if (strcmp(inst, info[i].pkginst) == 0) {
if (info[i].status == PI_PRESVR4) {
opresvr4++;
}
break;
}
}
return (inst);
}
/*
** Check part of the layout for design rule errors.
*/
area_check ()
{
struct x_lst *p, *pn;
register int act_layer;
for (act_layer = 0; act_layer < NR_lay; act_layer++) {
prelist[act_layer] = NULL;
y_root[act_layer] = NULL;
checklist[act_layer] = NULL;
checkp[act_layer] = NULL;
}
/*
** Find all edges in the area of interest.
**
** Enlarge search window a bit: this ensures
** that no false errors will occur on the edges
** of the check area. Errors found within the enlarged
** window but outside the check area are not reported.
*/
piwl = xlc - EXT_WINDOW;
piwr = xrc + EXT_WINDOW;
piwb = ybc - EXT_WINDOW;
piwt = ytc + EXT_WINDOW;
ptext ("*** prechecking ***");
CHECK_FLAG = TRUE;
/* Call the display routine.
** Trapezoids are redirected (check_flag = TRUE)
*/
for (act_layer = 0; act_layer < NR_lay; act_layer++) {
templist = NULL;
disp_mask_quad (act_layer, piwl, piwr, piwb, piwt);
dis_term (act_layer, piwl, piwr, piwb, piwt);
draw_inst_window (act_layer, piwl, piwr, piwb, piwt);
dis_s_term (act_layer, piwl, piwr, piwb, piwt);
/* make true edges for this mask layer */
if (prelist[act_layer] != NULL) {
make_true_edges (act_layer);
}
}
CHECK_FLAG = FALSE;
/* no errors found so far */
count = 0;
ptext ("*** checking ***");
for (act_layer = 0; act_layer < NR_lay; act_layer++) {
if (checklist[act_layer] != NULL)
do_internal_check (act_layer);
for (p = checklist[act_layer]; p != NULL; p = pn) {
pn = p -> next;
FREE (p);
}
for (p = worklist; p != NULL; p = pn) {
pn = p -> next;
FREE (p);
}
}
if (count)
ptext ("Errors found! (single layer check)");
else
ptext ("No errors found. (single layer check)");
return;
}
static int
found_exit(char *keybuf, int hx, int cc)
{ /* return true if the user wants to exit */
int j;
char *s;
if (scan_mode) {
if (*keybuf == '\0') {
return TRUE;
}
} else {
int k;
/* break is a special case */
if (*keybuf == '\0') {
fresh_line();
tty_set();
ptext("Hit X to exit: ");
if (wait_here() == 'X') {
return TRUE;
}
keys_tested(0, 1, hx);
tty_raw(cc, char_mask);
return FALSE;
}
/* is this the end? */
for (k = 0; (j = (keybuf[k] & STRIP_PARITY)); k++) {
if (end_funky(j)) {
return TRUE;
}
}
j = TRUE; /* does he need an updated list? */
for (k = 0; keybuf[k]; k++) {
j &= (keybuf[k] & STRIP_PARITY) == '?';
}
if (j || end_state == '?') {
keys_tested(0, 1, hx);
tty_raw(cc, char_mask);
end_state = 0;
return FALSE;
}
}
put_cr();
if (hx) {
s = hex_expand_to(keybuf, 10);
} else {
s = expand_to(keybuf, 10);
}
sprintf(temp, "%s Unknown", s);
put_str(temp);
for (j = 0; j < MAX_FK_UNK; j++) {
if (j == funk) {
fk_length[funk] = expand_chars;
if ((fk_unknown[funk] = (char *) malloc(strlen(s) + 1))) {
strcpy(fk_unknown[funk++], s);
}
break;
}
if (fk_length[j] == expand_chars) {
if (!strcmp(fk_unknown[j], s)) {
break;
}
}
}
return FALSE;
}
/* Write a cell to the database.
** There are three possibilities:
** 1. It was a totally new cell which isn't known by
** the database yet. The key is NULL.
** 2. The cell was read from the database and is
** written back now. We have a key.
** 3. The cell was read from the database but we want
** to store it as a different cell (new name).
** We have a key but it belongs to its present name.
** We need a new key to store it as a new cell.
**
** 1. Ask a new key using dmCreateCellkey().
** We can write it using that key and from that moment
** on it will be like we had read it previously
** (we have written it using its key).
** 2. We can just write it, using its key.
** (as often as we like).
** 3. We need an extra key to store it as a
** different (new) cell. We ask a key using
** dmCreateCellkey(). Then we can write it using
** this key, but our workspace will still be related
** to the old cell. So after this write we have
** to give our new key back (using check_in).
*/
wrte_cell () {
static char *ask_str[3]; /* static for redraw */
char *strsave ();
char hulpstr[DM_MAXNAME + 1];
char rem_path[MAXCHAR];
char qstr[100];
char *newcell;
int choice;
int exist;
DM_CELL * save_key;
int isnewname;
if (rmode) {
ptext ("No write, you are in read only mode!");
return;
}
save_key = NULL;
upd_boundb ();
if (xltb == xrtb || ybtb == yttb) {
ptext ("Don't you ever try to write an empty cell again!");
return;
}
ask_str[0] = "-cancel-";
if (!ckey && cirname[0] != '\0') {
ask_str[1] = "other name";
ask_str[2] = &cirname[0];
ptext ("Under which name do you wanna write this cell?");
}
else {
ask_str[1] = "new name";
ask_str[2] = cellstr;
ptext ("Do you wanna write this cell under a new name?");
}
if ((choice = ask ((ckey || cirname[0] != '\0') ? 3 : 2, ask_str, -1)) == 0)
{
ptext("");
return;
}
isnewname = 0;
if (choice == 1 || (choice == 2 && !ckey)) {
if (choice == 1) {
if (ask_name ("cellname: ", hulpstr, TRUE) == -1)
return;
}
else {
strcpy (hulpstr, ask_str[2]);
}
isnewname = 1;
if(strcmp(hulpstr,"res") == 0 ||
strcmp(hulpstr,"cap") == 0 ||
strcmp(hulpstr,"nenh") == 0 ||
strcmp(hulpstr,"penh") == 0)
{
sprintf (qstr, "Name '%s' is a nelsis primitive: really use this name?", hulpstr);
ptext (qstr);
if (ask (2, yes_no, -1) != 0)
{
sprintf (qstr, "Cell '%s' was NOT written", hulpstr);
ptext (qstr);
return;
}
}
if ((newcell = strsave (hulpstr)) == NULL)
return;
if ((exist = (int) dmGetMetaDesignData (EXISTCELL, dmproject,
newcell, LAYOUT)) != 0) {
if (exist == 1) { /* cell already exists */
sprintf (qstr, "Cell '%s' already exists: wanna overwrite?", newcell);
ptext (qstr);
if (ask (2, yes_no, -1) != 0) {
sprintf (qstr, "Cell '%s' was not written", newcell);
ptext (qstr);
return;
}
}
else {
sprintf (qstr, "Cell '%s' was not written", newcell);
ptext (qstr);
return;
}
}
/*
** cell does not yet exist
*/
save_key = ckey;
if (!(ckey = dmCheckOut (dmproject, newcell, WORKING,
DONTCARE, LAYOUT, UPDATE))) {
ckey = save_key; /* undo */
return;
}
}
else {
newcell = cellstr;
}
#ifndef ANNOTATE
if (!(outp_boxfl (ckey) && outp_mcfl (ckey) &&
outp_term (ckey) && outp_bbox (ckey))) {
#else
if (!(outp_boxfl (ckey) && outp_mcfl (ckey) && outp_term (ckey)
&& outp_bbox (ckey) && outp_comment (ckey))) {
#endif
/*
** Files were not written properly so if a new key
** was obtained to write under a new name, it must
** be checked in using the quit mode.
*/
if (checked == TRUE) {
#ifdef NELSIS_REL4
sprintf (rem_path, "%s/chk_mod.ck", dmproject -> DMPath);
#else
sprintf (rem_path, "%s/chk_mod.ck", dmproject -> dmpath);
#endif
unlink (rem_path);
checked = FALSE;
}
if (choice == 1) {
dmCheckIn (ckey, QUIT);
ckey = save_key;
}
return;
}
if (isnewname) {
if (save_key != NULL) {
/*
** Write existing cell under new name:
** case 3 (see comments above).
*/
/* PATRICK: now the cell which is being edited is using the last saved name */
if (dmCheckIn (ckey, CONTINUE) == -1) {
ptext ("Not accepted! (recursive)");
dmCheckIn (ckey, QUIT);
ckey = NULL;
return;
}
if (dmCheckIn (save_key, QUIT) == -1) {
ptext ("Not accepted! (recursive)");
save_key = NULL;
return;
}
cellstr = newcell;
}
else {
/*
** Write a totally new cell, hold key:
** case 1 (see comments above).
*/
if (dmCheckIn (ckey, CONTINUE) == -1) {
ptext ("Not accepted! (recursive)");
dmCheckIn (ckey, QUIT);
ckey = NULL;
return;
}
ASSERT (cellstr == NULL);
cellstr = newcell;
}
save_check (newcell);
}
else {
/*
** Write existing cell, hold key.
*/
if (dmCheckIn (ckey, CONTINUE) == -1)
ptext ("Not checked in! This should never happen!");
save_check (cellstr);
}
sprintf (qstr, "Cell '%s' written", newcell);
ptext (qstr);
dirty = FALSE;
}
static
save_check (cell_name)
char *cell_name;
{
char check_path[MAXCHAR];
char new_path[MAXCHAR];
if (checked == TRUE) {
#ifdef NELSIS_REL4
sprintf (check_path, "%s/chk_mod.ck", dmproject -> DMPath);
sprintf (new_path, "%s/%s.ck", dmproject -> DMPath, cell_name);
#else
sprintf (check_path, "%s/chk_mod.ck", dmproject -> dmpath);
sprintf (new_path, "%s/%s.ck", dmproject -> dmpath, cell_name);
#endif
link (check_path, new_path);
unlink (check_path);
checked = FALSE;
}
}
static DM_STREAM * dm_boxfp;
static DM_STREAM * dm_norfp;
/* PATRICK: added key as argument instead of global to write routines */
outp_boxfl (key)
DM_CELL *key;
{
int store ();
struct obj_node *window;
register int lay;
if (!(dm_boxfp = dmOpenStream (key, "box", "w"))) {
return (FALSE);
}
if (!(dm_norfp = dmOpenStream (key, "nor", "w"))) {
return (FALSE);
}
gbox.dx = 0L;
gbox.dy = 0L;
gbox.nx = 0L;
gbox.ny = 0L;
/*
** We store all trapezoids as polygons
** with either 3 or 4 corner points.
*/
gnor_ini.elmt = POLY_NOR;
gnor_ini.dx = 0L;
gnor_ini.dy = 0L;
gnor_ini.nx = 0L;
gnor_ini.ny = 0L;
MALLOC (window, struct obj_node);
for (lay = 0; lay < NR_lay; ++lay) {
gbox.layer_no = lay;
gnor_ini.layer_no = lay;
window -> ll_x1 = quad_root[lay] -> quadrant[0] - 1;
window -> ll_y1 = quad_root[lay] -> quadrant[1] - 1;
window -> ll_x2 = quad_root[lay] -> quadrant[2] + 1;
window -> ll_y2 = quad_root[lay] -> quadrant[3] + 1;
quad_search (quad_root[lay], window, store);
}
FREE (window);
dmCloseStream (dm_boxfp, COMPLETE);
dmCloseStream (dm_norfp, COMPLETE);
return (TRUE);
}
outp_mcfl (key)
DM_CELL *key;
{
DM_STREAM * dmfp;
register INST * ip;
Coor bxl, bxr, byb, byt;
if (!(dmfp = dmOpenStream (key, "mc", "w"))) {
return (FALSE);
}
for (ip = inst_root; ip; ip = ip -> next) {
inst_window (ip, &bxl, &bxr, &byb, &byt);
gmc.bxl = (long) bxl / QUAD_LAMBDA;
gmc.bxr = (long) bxr / QUAD_LAMBDA;
gmc.byb = (long) byb / QUAD_LAMBDA;
gmc.byt = (long) byt / QUAD_LAMBDA;
if (strlen (ip -> inst_name) == 0)
strcpy (gmc.inst_name, ".");
else
strcpy (gmc.inst_name, ip -> inst_name);
strcpy (gmc.cell_name, ip -> templ -> cell_name);
gmc.imported = ip -> imported;
gmc.mtx[0] = (long) ip -> tr[0];
gmc.mtx[1] = (long) ip -> tr[1];
gmc.mtx[2] = (long) ip -> tr[2] / QUAD_LAMBDA;
gmc.mtx[3] = (long) ip -> tr[3];
gmc.mtx[4] = (long) ip -> tr[4];
gmc.mtx[5] = (long) ip -> tr[5] / QUAD_LAMBDA;
gmc.nx = (long) ip -> nx;
gmc.dx = (long) ip -> dx / QUAD_LAMBDA;
gmc.ny = (long) ip -> ny;
gmc.dy = (long) ip -> dy / QUAD_LAMBDA;
dmPutDesignData (dmfp, GEO_MC);
}
dmCloseStream (dmfp, COMPLETE);
return (TRUE);
}
outp_term (key)
DM_CELL *key;
{
DM_STREAM * dmfp;
register int i;
register TERM * tp;
Coor bxl, bxr, byb, byt;
if (!(dmfp = dmOpenStream (key, "term", "w"))) {
return (FALSE);
}
for (i = 0; i < NR_lay; ++i) {
gterm.layer_no = i;
for (tp = term[i]; tp; tp = tp -> nxttm) {
gterm.xl = (long) tp -> xl / QUAD_LAMBDA;
gterm.xr = (long) tp -> xr / QUAD_LAMBDA;
gterm.yb = (long) tp -> yb / QUAD_LAMBDA;
gterm.yt = (long) tp -> yt / QUAD_LAMBDA;
strcpy (gterm.term_name, tp -> tmname);
gterm.nx = (long) tp -> nx;
gterm.dx = (long) tp -> dx / QUAD_LAMBDA;
gterm.ny = (long) tp -> ny;
gterm.dy = (long) tp -> dy / QUAD_LAMBDA;
term_win (tp, &bxl, &bxr, &byb, &byt);
gterm.bxl = (long) bxl / QUAD_LAMBDA;
gterm.bxr = (long) bxr / QUAD_LAMBDA;
gterm.byb = (long) byb / QUAD_LAMBDA;
gterm.byt = (long) byt / QUAD_LAMBDA;
dmPutDesignData (dmfp, GEO_TERM);
}
}
dmCloseStream (dmfp, COMPLETE);
return (TRUE);
}
outp_bbox (key)
DM_CELL *key;
{
DM_STREAM * dmfp;
if (!(dmfp = dmOpenStream (key, "info", "w"))) {
return (FALSE);
}
ginfo.bxl = (long) xltb / QUAD_LAMBDA;
ginfo.bxr = (long) xrtb / QUAD_LAMBDA;
ginfo.byb = (long) ybtb / QUAD_LAMBDA;
ginfo.byt = (long) yttb / QUAD_LAMBDA;
dmPutDesignData (dmfp, GEO_INFO);
ginfo.bxl = (long) xlmb / QUAD_LAMBDA;
ginfo.bxr = (long) xrmb / QUAD_LAMBDA;
ginfo.byb = (long) ybmb / QUAD_LAMBDA;
ginfo.byt = (long) ytmb / QUAD_LAMBDA;
dmPutDesignData (dmfp, GEO_INFO);
ginfo.bxl = (long) xlbb / QUAD_LAMBDA;
ginfo.bxr = (long) xrbb / QUAD_LAMBDA;
ginfo.byb = (long) ybbb / QUAD_LAMBDA;
ginfo.byt = (long) ytbb / QUAD_LAMBDA;
dmPutDesignData (dmfp, GEO_INFO);
/*
* patrick: put one more info: the total bounding box WITHOUT
* the image
*/
if(ImageMode == TRUE && xlim != xrim && ybim != ytim)
{
ginfo.bxl = (long) xlim / QUAD_LAMBDA;
ginfo.bxr = (long) xrim / QUAD_LAMBDA;
ginfo.byb = (long) ybim / QUAD_LAMBDA;
ginfo.byt = (long) ytim / QUAD_LAMBDA;
dmPutDesignData (dmfp, GEO_INFO);
}
dmCloseStream (dmfp, COMPLETE);
return (TRUE);
}
/*
** Store trapezoid p in the data base.
** INPUT: pointer to trapezoid p.
*/
store (p)
struct obj_node *p;
{
Coor line[8];
int i;
if (!p -> leftside && !p -> rightside) {
/*
** this is a rectangle
*/
if (!(p -> ll_x1 % QUAD_LAMBDA || p -> ll_y1 % QUAD_LAMBDA ||
p -> ll_x2 % QUAD_LAMBDA || p -> ll_y2 % QUAD_LAMBDA)) {
gbox.xl = (long) p -> ll_x1 / QUAD_LAMBDA;
gbox.xr = (long) p -> ll_x2 / QUAD_LAMBDA;
gbox.yb = (long) p -> ll_y1 / QUAD_LAMBDA;
gbox.yt = (long) p -> ll_y2 / QUAD_LAMBDA;
gbox.bxl = gbox.xl;
gbox.bxr = gbox.xr;
gbox.byb = gbox.yb;
gbox.byt = gbox.yt;
dmPutDesignData (dm_boxfp, GEO_BOX);
return;
}
}
line[0] = p -> ll_x1;
line[1] = p -> ll_y1;
line[2] = p -> ll_x2;
line[3] = p -> ll_y2;
while (line[0] % QUAD_LAMBDA)
--line[0];
while (line[1] % QUAD_LAMBDA)
--line[1];
while (line[2] % QUAD_LAMBDA)
++line[2];
while (line[3] % QUAD_LAMBDA)
++line[3];
gnor_ini.bxl = (long) line[0] / QUAD_LAMBDA;
gnor_ini.byb = (long) line[1] / QUAD_LAMBDA;
gnor_ini.bxr = (long) line[2] / QUAD_LAMBDA;
gnor_ini.byt = (long) line[3] / QUAD_LAMBDA;
gnor_ini.r_bxl = gnor_ini.bxl;
gnor_ini.r_byb = gnor_ini.byb;
gnor_ini.r_bxr = gnor_ini.bxr;
gnor_ini.r_byt = gnor_ini.byt;
/*
** Convert trapezoid to polygon.
*/
if (trap_to_poly (line, p) == -1) {
ptext ("Illegal trapezoid!");
return;
}
if (line[0] == line[2] || line[4] == line[6]) {
/*
** trapezoid is a triangle
*/
gnor_ini.no_xy = 3;
if (line[0] == line[2]) {
/*
** First two points are identical.
** Eliminate second point and shift others back.
*/
line[2] = line[4];
line[3] = line[5];
line[4] = line[6];
line[5] = line[7];
}
}
else {
gnor_ini.no_xy = 4;
}
dmPutDesignData (dm_norfp, GEO_NOR_INI);
/*
** Store xy-pairs of polygon.
*/
for (i = 0; i < (2 * (int) gnor_ini.no_xy); i = i + 2) {
gnor_xy.x = (double) line[i] / (double) QUAD_LAMBDA;
gnor_xy.y = (double) line[i + 1] / (double) QUAD_LAMBDA;
dmPutDesignData (dm_norfp, GEO_NOR_XY);
}
}
/*
** crum_move(test_list, status, ch)
**
** (*) test all cursor move commands
*/
static void
crum_move(
struct test_list *t,
int *state,
int *ch)
{
char buf[80];
int n;
switch (n = (t->flags & 15)) {
case 0:
sprintf(buf, " (cr) (nel) (cub1)%s",
cursor_home ? " (home)" : (cursor_up ? " (cuu1)" : ""));
break;
case 1:
sprintf(buf, "%s%s%s%s", cursor_left ? " (cub1)" : "",
cursor_down ? " (cud1)" : "", cursor_right ? " (cuf1)" : "",
cursor_up ? " (cuu1)" : "");
if (buf[0] == '\0') {
ptext(" (cub1) (cud1) (cuf1) (cuu1) not defined.");
}
break;
case 2:
sprintf(buf, "%s%s%s%s", parm_left_cursor ? " (cub)" : "",
parm_down_cursor ? " (cud)" : "",
parm_right_cursor ? " (cuf)" : "",
parm_up_cursor ? " (cuu)" : "");
if (buf[0] == '\0') {
ptext(" (cub) (cud) (cuf) (cuu) not defined.");
}
break;
case 3:
sprintf(buf, "%s%s", row_address ? " (vpa)" : "",
column_address ? " (hpa)" : "");
if (buf[0] == '\0') {
ptext(" (vpa) (hpa) not defined.");
}
break;
case 4:
if (!cursor_address) {
ptext(" (cup) not defined. ");
generic_done_message(t, state, ch);
return;
}
strcpy(buf, " (cup)");
break;
}
if (buf[0] == '\0') {
put_str(" Done. ");
} else {
can_test(buf, FLAG_TESTED);
strcpy(crum_text[n], &buf[2]);
crum_text[n][strlen(buf) - 3] = '\0';
display_it(1 << n, buf);
}
*ch = wait_here();
if (*ch != 'r') {
put_clear();
}
}
/*
** curses_setup(exec_name)
**
** Startup ncurses
*/
void
curses_setup(
char *exec_name)
{
int status;
static TERMTYPE term;
char tty_filename[2048];
tty_init();
/**
See if the terminal is in the terminfo data base. This call has
two useful benefits, 1) it returns the filename of the terminfo entry,
and 2) it searches only terminfo's. This allows us to abort before
ncurses starts scanning the termcap file.
**/
if ((status = _nc_read_entry(tty_basename, tty_filename, &term)) == 0) {
const TERMTYPE *fallback = _nc_fallback(tty_basename);
if (fallback) {
term = *fallback;
sprintf(tty_filename, "(fallback)%s", tty_basename);
status = 1;
} else {
fprintf(stderr, "Terminal not found: TERM=%s\n", tty_basename);
show_usage(exec_name);
exit(1);
}
}
if (status == -1) {
fprintf(stderr, "Terminfo database is inaccessible\n");
exit(1);
}
/**
This call will load the terminfo data base and set the cur-term
variable. Only terminals that actually exist will get here so its
OK to ignore errors. This is a good thing since ncurses does not
permit (os) or (gn) to be set.
**/
setupterm(tty_basename, 1, &status);
/**
Get the current terminal definitions. This must be done before
getting the baudrate.
**/
_nc_get_curterm(&cur_term->Nttyb);
tty_baud_rate = baudrate();
tty_cps = (tty_baud_rate << 1) / tty_frame_size;
/* set up the defaults */
replace_mode = TRUE;
scan_mode = 0;
char_count = 0;
select_delay_type = debug_level = 0;
char_mask = (meta_on && meta_on[0] == '\0') ? ALLOW_PARITY : STRIP_PARITY;
/* Don't change the XON/XOFF modes yet. */
select_xon_xoff = initial_stty_query(TTY_XON_XOFF) ? 1 : needs_xon_xoff;
fflush(stdout); /* flush any output */
tty_set();
go_home(); /* set can_go_home */
put_clear(); /* set can_clear_screen */
if (send_reset_init) {
reset_init();
}
/*
I assume that the reset and init strings may not have the correct
pads. (Because that part of the test comes much later.) Because
of this, I allow the terminal some time to catch up.
*/
fflush(stdout); /* waste some time */
sleep(1); /* waste more time */
charset_can_test();
can_test("lines cols cr nxon rf if iprog rmp smcup rmcup", FLAG_CAN_TEST);
edit_init(); /* initialize the edit data base */
if (send_reset_init && enter_ca_mode) {
tc_putp(enter_ca_mode);
put_clear(); /* just in case we switched pages */
}
put_crlf();
ptext("Using terminfo from: ");
ptextln(tty_filename);
put_crlf();
if (tty_can_sync == SYNC_NEEDED) {
verify_time();
}
display_basic();
}
void
quit(int retcode)
{
/* disable interrupts */
(void) signal(SIGINT, SIG_IGN);
(void) signal(SIGHUP, SIG_IGN);
/* process return code if not quit(99) */
if (retcode != 99) {
if ((retcode % 10) == 0) {
if (failflag) {
retcode += 1;
} else if (warnflag) {
retcode += 2;
}
}
if (ireboot) {
retcode = (retcode % 10) + 20;
}
if (dreboot) {
retcode = (retcode % 10) + 10;
}
}
/* if set remove dstream temporary directory */
if (dstreamTempDir != (char *)NULL) {
echoDebug(DBG_REMOVING_DSTREAM_TMPDIR, dstreamTempDir);
(void) rrmdir(dstreamTempDir);
dstreamTempDir = (char *)NULL;
}
/* If we're in dryrun mode, write out the dryrun file(s). */
if (in_dryrun_mode()) {
char exit_msg[200];
set_dr_info(EXITCODE, retcode);
if (failflag || warnflag) {
set_dr_exitmsg(msgtext);
} else {
/* LINTED variable format specified */
(void) snprintf(exit_msg, sizeof (exit_msg),
qreason(1, retcode, installStarted,
includeZonename),
(pkginst ? pkginst : "unknown"),
zoneName);
set_dr_exitmsg(exit_msg);
}
write_dryrun_file(extlist);
ptext(stderr, MSG_DRYRUN_DONE);
ptext(stderr, MSG_NOCHANGE);
if (tmpdir[0] != NULL)
(void) rrmdir(tmpdir);
} else {
/* fix bug #1082589 that deletes root file */
if (tmpdir[0] != NULL) {
(void) rrmdir(tmpdir);
}
/* send mail to appropriate user list */
mailmsg(retcode);
/* display message about this installation */
quitmsg(retcode);
}
/*
* In the event that this quit() was called prior to completion of
* the task, do an unlockinst() just in case.
*/
unlockinst();
/* Unmount anything that's our responsibility. */
(void) unmount_client();
/*
* No need to umount device since calling process
* was responsible for original mount
*/
if (!updatingExistingPackage) {
if (!installStarted && pkgloc[0]) {
/*
* install not yet started; if package install
* location is defined, remove the package.
*/
echoDebug(DBG_QUIT_REMOVING_PKGDIR, pkgloc);
(void) chdir("/");
if (pkgloc[0]) {
(void) rrmdir(pkgloc);
}
}
} else {
if (!installStarted) {
/*
* If we haven't started, but have already done
* the <PKGINST>/install directory rename, then
* remove the new <PKGINST>/install directory
* and rename <PKGINST>/install.save back to
* <PKGINST>/install.
*/
if (pkgloc_sav[0] && !access(pkgloc_sav, F_OK)) {
if (pkgloc[0] && !access(pkgloc, F_OK))
(void) rrmdir(pkgloc);
if (rename(pkgloc_sav, pkgloc) == -1) {
progerr(ERR_PACKAGEBINREN,
pkgloc_sav, pkgloc);
}
}
} else {
if (pkgloc_sav[0] && !access(pkgloc_sav, F_OK)) {
echoDebug(DBG_QUIT_REMOVING_PKGSAV, pkgloc_sav);
(void) rrmdir(pkgloc_sav);
}
}
}
/*
* pkginst can be null if an administration setting doesn't all
* the package to be installed. Make sure pkginst exeists before
* updating the DB
*/
if (dparts > 0)
ds_skiptoend(pkgdev.cdevice);
(void) ds_close(1);
/* Free the filesystem table. */
fs_tab_free();
/* Free the package information lists. */
pinfo_free();
/* Free all stragglers. */
bl_free(BL_ALL);
(void) pathdup(NULL);
/* Free regfiles. */
regfiles_free();
/* final exit debugging message */
echoDebug(DBG_EXIT_WITH_CODE, retcode);
exit(retcode);
/*NOTREACHED*/
}
void
quit(int retcode)
{
/* disable interrupts */
(void) signal(SIGINT, SIG_IGN);
(void) signal(SIGHUP, SIG_IGN);
/* process return code if not quit(99) */
if (retcode != 99) {
if (ckreturnFunc != (ckreturnFunc_t *)NULL) {
(ckreturnFunc)(retcode);
}
if (failflag) {
retcode = 1;
} else if (warnflag) {
retcode = 2;
} else if (intrflag) {
retcode = 3;
} else if (admnflag) {
retcode = 4;
} else if (nullflag) {
retcode = 5;
} else {
retcode = 0;
}
if (ireboot) {
retcode += 20;
}
if (doreboot) {
retcode += 10;
}
}
if (doreboot || ireboot) {
ptext(stderr, gettext(MSG_REBOOT));
}
if (pkgdev.mount) {
(void) chdir("/");
(void) pkgumount(&pkgdev);
}
/* if set remove zone temporary directory */
if (zoneTempDir != (char *)NULL) {
echoDebug(DBG_REMOVING_ZONE_TMPDIR, zoneTempDir);
(void) rrmdir(zoneTempDir);
zoneTempDir = (char *)NULL;
}
/*
* issue final exit message depending on number of packages left
* to process
*/
if (npkgs == 1) {
echo(MSG_1_PKG_NOT_PROCESSED);
} else if (npkgs) {
echo(MSG_N_PKGS_NOT_PROCESSED, npkgs);
}
/* call intf_reloc function if registered */
if (intfRelocFunc != (intfRelocFunc_t *)NULL) {
(intfRelocFunc)();
}
/* if a zone list exists, unlock all zones */
if (zoneList != (zoneList_t)NULL) {
(void) z_unlock_zones(zoneList, ZLOCKS_ALL);
} else {
(void) z_unlock_this_zone(ZLOCKS_ALL);
}
/* final exit debugging message */
echoDebug(DBG_EXIT_WITH_CODE, retcode);
exit(retcode);
/* NOTREACHED */
}
/*
** probe_enq_ok()
**
** does the terminal do enq/ack handshaking?
*/
static void
probe_enq_ok(void)
{
int tc, len, ulen;
put_str("Testing ENQ/ACK, standby...");
fflush(stdout);
can_test("u8 u9", FLAG_TESTED);
#ifdef user9
tty_ENQ = user9 ? user9 : "\005";
#else
tty_ENQ = "\005";
#endif
tc_putp(tty_ENQ);
event_start(TIME_SYNC); /* start the timer */
read_key(tty_ACK, TTY_ACK_SIZE - 1);
if (event_time(TIME_SYNC) > 400000 || tty_ACK[0] == '\0') {
/* These characters came from the user. Sigh. */
tty_can_sync = SYNC_FAILED;
ptext("\nThis program expects the ENQ sequence to be");
ptext(" answered with the ACK character. This will help");
ptext(" the program reestablish synchronization when");
ptextln(" the terminal is overrun with data.");
ptext("\nENQ sequence from (u9): ");
putln(expand(tty_ENQ));
ptext("ACK received: ");
putln(expand(tty_ACK));
#ifdef user8
len = user8 ? strlen(user8) : 0;
#else
len = 0;
#endif
sprintf(temp, "Length of ACK %d. Expected length of ACK %d.",
(int) strlen(tty_ACK), len);
ptextln(temp);
#ifdef user8
if (len) {
temp[0] = user8[len - 1];
temp[1] = '\0';
ptext("Terminating character found in (u8): ");
putln(expand(temp));
}
#endif
return;
}
tty_can_sync = SYNC_TESTED;
if ((len = strlen(tty_ACK)) == 1) {
/* single character acknowledge string */
ACK_terminator = tty_ACK[0];
ACK_length = 4096;
return;
}
tc = tty_ACK[len - 1];
#ifdef user8
if (user8) {
ulen = strlen(user8);
if (tc == user8[ulen - 1]) {
/* ANSI style acknowledge string */
ACK_terminator = tc;
ACK_length = 4096;
return;
}
}
#endif
/* fixed length acknowledge string */
ACK_length = len;
ACK_terminator = -2;
}
/*
** subtest_xenl(test_list, status, ch)
**
** (xenl) eat newline glitch
*/
static void
subtest_xenl(
struct test_list *t,
int *state,
int *ch)
{
int i, j, k;
if (over_strike) {
/* test (xenl) on overstrike terminals */
if (!can_go_home || !can_clear_screen) {
ptextln("(xenl) Newline-glitch not tested, can't home cursor and clear.");
generic_done_message(t, state, ch);
return;
}
put_clear();
/*
this test must be done in raw mode. Otherwise UNIX will
translate CR to CRLF.
*/
if (stty_query(TTY_OUT_TRANS))
tty_raw(1, char_mask);
ptext("\nreset (xenl). Does ");
i = char_count;
put_str("not ignore CR, does ");
k = char_count;
put_str("not ignore LF");
go_home();
for (j = 0; j < columns; j++)
put_this(' ');
put_cr();
for (j = 0; j < i; j++)
putchp(' ');
put_str("@@@\n@@");
go_home();
for (j = 0; j < columns; j++)
put_this(' ');
put_lf();
for (j = 0; j < k; j++)
putchp(' ');
put_str("@@@\r@@");
tty_set();
go_home();
put_newlines(4);
sprintf(temp, "(xenl) Newline-glitch is %s in the data base",
eat_newline_glitch ? "true" : "false");
ptextln(temp);
} else {
/* test (xenl) when (os) is reset */
if (!can_go_home) {
ptextln("(xenl) Newline-glitch not tested, can't home cursor");
generic_done_message(t, state, ch);
return;
}
/* (xenl) test */
put_clear();
/*
this test must be done in raw mode. Otherwise
UNIX will translate CR to CRLF.
*/
if (stty_query(TTY_OUT_TRANS))
tty_raw(1, char_mask);
for (j = 0; j < columns; j++)
put_this(' ');
put_cr();
ptext("(xenl) should be set. Does not ignore CR");
go_home();
put_crlf();
for (j = 0; j < columns; j++)
put_this(' ');
put_lf(); /* test (cud1) */
ptext("(xenl) should be set. Ignores (cud1)");
go_home();
put_newlines(3);
if (scroll_forward && cursor_down &&
strcmp(scroll_forward, cursor_down)) {
for (j = 0; j < columns; j++)
put_this(' ');
put_ind(); /* test (ind) */
ptext("(xenl) should be set. Ignores (ind)");
go_home();
put_newlines(5);
}
tty_set();
ptextln("If you don't see text above telling you to set it, (xenl) should be false");
sprintf(temp, "(xenl) Newline-glitch is %s in the data base",
eat_newline_glitch ? "true" : "false");
ptextln(temp);
}
generic_done_message(t, state, ch);
}
int
rckrunlevel(void)
{
struct utmpx utmpx;
struct utmpx *putmpx;
char ans[MAX_INPUT];
char *pt;
char *rstates;
int n;
char *uxstate;
if (ADM(runlevel, "nocheck")) {
return (0);
}
pt = getenv("RSTATES");
if (pt == NULL) {
return (0);
}
utmpx.ut_type = RUN_LVL;
putmpx = getutxid(&utmpx);
if (putmpx == NULL) {
progerr(ERR_RUNSTATE);
return (99);
}
uxstate = strtok(&putmpx->ut_line[10], " \t\n");
rstates = qstrdup(pt);
if ((pt = strtok(pt, " \t\n, ")) == NULL)
return (0); /* no list is no list */
do {
if (strcmp(pt, uxstate) == 0) {
free(rstates);
return (0);
}
} while (pt = strtok(NULL, " \t\n, "));
if (preremoveCheck == B_FALSE) {
msgtext = MSG_PKGREMOVE_RUNLEVEL;
ptext(stderr, msgtext, uxstate);
} else {
(void) fprintf(stdout, "runlevel=%s", uxstate);
}
pt = strtok(rstates, " \t\n, ");
do {
if (preremoveCheck == B_FALSE) {
ptext(stderr, "\\t%s", pt);
} else {
(void) fprintf(stdout, ":%s", pt);
}
} while (pt = strtok(NULL, " \t\n, "));
if (preremoveCheck == B_TRUE) {
(void) fprintf(stdout, "\n");
}
free(rstates);
if (ADM(runlevel, "quit")) {
return (4);
}
if (echoGetFlag() == B_FALSE) {
return (5);
}
msgtext = NULL;
n = ckyorn(ans, NULL, NULL, HLP_PKGREMOVE_RUNLEVEL,
ASK_PKGREMOVE_CONTINUE);
if (n != 0) {
return (n);
}
if (strchr("yY", *ans) == NULL) {
return (3);
}
return (0);
}
