int thxgatrs(char * comp) {
char *o_ptr;
char out_str[255];
int atr = 0;
char fname[256];
FILE *fp = NULL;
strcpy_s(fname,comp);
strcat_s(fname,".atr");
FILE* pFile;
#ifdef WIN32
fopen_s(&pFile, fname, "r");
#else
pFile = fopen(fname,"r");
#endif
if (pFile == NULL)
return(-1);
do {curr_char = getc(fp);} while (curr_char == '\n');
o_ptr = out_str;
scan_blanks(fp);
TCO(nEOF,EOF);
goto exit;
nEOF: for (;;) {
TA(nA);
continue;
nA: TN(nN);
continue;
nN: TC(nus,'_');
continue;
nus: break;
}
*o_ptr = '\0';
if (strcmp(out_str,"MUST_RUN") == 0 ||
strcmp(out_str,"Must_run") == 0 ||
strcmp(out_str,"must_run") == 0)
atr = TRUE;
else
atr = FALSE;
scan_blanks(fp);
exit: fclose(fp);
return(atr);
}
int thxscan(FILE *fp, cnxt_ent *cnxt_tab, proc_ent *proc_tab,
label_ent *label_tab, char file_name[10],
int *label_cp, int* proc_cp, int* cnxt_cp)
{
char *o_ptr;
char out_str[255];
char fname[256];
char out_num[5];
int i, IIPlen, ret_code;
int proc_cnt;
int proc_start = 0;
int proc_hold, proc_last;
int label_count, proc_count, cnxt_count;
proc_ent *curr_proc;
cnxt_ent *curr_cnxt;
int label_ct;
unsigned cnxt_open, eq_arrow;
IIP *IIP_ptr;
FILE *fp2;
label_count = *label_cp;
proc_count = *proc_cp;
cnxt_count = *cnxt_cp;
proc_hold = proc_count;
ret_code = 0;
do {curr_char = getc(fp);} while (curr_char == '\n');
netloop:
cnxt_open = FALSE;
o_ptr = out_str;
scan_blanks(fp);
TCO(nEOF,EOF);
printf("End of Network Definition\n");
goto exit;
nEOF: TCO(NQ,'\'');
strcpy(label_tab[label_count].label," ");
strcpy(label_tab[label_count].file, file_name);
label_tab[label_count].cnxt_ptr = &cnxt_tab[cnxt_count];
label_tab[label_count].proc_ptr = &proc_tab[proc_count];
label_tab[label_count].ent_type = 'L';
printf("Scanning Main Network\n");
proc_start = proc_count;
proc_tab[proc_count].proc_name[0] = '\0';
label_count++;
label_tab[label_count].label[0] = '\0';
goto TQ;
NQ: if (scan_sym(fp, o_ptr) != 0) {
printf("Name error\n");
ret_code = 4;
goto exit; }
scan_blanks(fp);
TCO(ncol,':');
strcpy(label_tab[label_count].label,out_str);
strcpy(label_tab[label_count].file, file_name);
label_tab[label_count].cnxt_ptr = &cnxt_tab[cnxt_count];
label_tab[label_count].proc_ptr = &proc_tab[proc_count];
label_tab[label_count].ent_type = 'L';
printf("Scanning Network: %s\n",out_str);
proc_start = proc_count;
label_count++;
label_tab[label_count].label[0] = '\0';
scan_blanks(fp);
loop:
o_ptr = out_str;
scan_blanks(fp);
TCO(X1,'\'');
TQ:
TCO(tbsl,EOF);
printf("EOF encountered within quoted string\n");
ret_code = 4;
goto exit;
tbsl: TCO(copy,'\'');
TC(NQ2,'\'');
goto TQ;
copy: CC;
goto TQ;
NQ2: IIPlen = o_ptr - out_str;
strcpy(cnxt_tab[cnxt_count].upstream_name,"!");
IIP_ptr = (IIP *)malloc(IIPlen + sizeof(IIP_ptr -> IIP_len));
IIP_ptr -> IIP_len = IIPlen;
memcpy(IIP_ptr -> datapart, out_str, IIPlen);
cnxt_tab[cnxt_count].gen.IIPptr = IIP_ptr;
scan_blanks(fp);
goto tArrow;
X1: if (scan_sym(fp, o_ptr) != 0) {
printf("Name error\n");
ret_code = 4;
goto exit; }
scan_blanks(fp);
goto topen;
ncol: strcpy(label_tab[label_count].label," ");
strcpy(label_tab[label_count].file, file_name);
label_tab[label_count].cnxt_ptr = &cnxt_tab[cnxt_count];
label_tab[label_count].proc_ptr = &proc_tab[proc_count];
label_tab[label_count].ent_type = 'L';
proc_start = proc_count;
label_count++;
label_tab[label_count].label[0] = '\0';
topen: if (cnxt_open) {
strcpy(cnxt_tab[cnxt_count].downstream_name,out_str);
cnxt_open = FALSE;
curr_cnxt = &cnxt_tab[cnxt_count];
if (curr_cnxt -> upstream_name[0] != '!')
printf(" Connection: %s %s[%d] -> %s[%d] %s\n",
curr_cnxt -> upstream_name,
curr_cnxt -> upstream_port_name,
curr_cnxt -> upstream_elem_no,
curr_cnxt -> downstream_port_name,
curr_cnxt -> downstream_elem_no,
curr_cnxt -> downstream_name);
else {
printf(" IIP: -> %s[%d] %s\n",
curr_cnxt -> downstream_port_name,
curr_cnxt -> downstream_elem_no,
curr_cnxt -> downstream_name);
IIP_ptr = curr_cnxt -> gen.IIPptr;
printf(" \'");
for (i = 0; i < IIP_ptr -> IIP_len; i++)
printf("%c",IIP_ptr -> datapart[i]);
printf("\'\n");
}
cnxt_count++;
}
else {
TCO(NIP,'=');
TCO(NIP,'>');
scan_blanks(fp);
strcpy(cnxt_tab[cnxt_count].upstream_name, "*");
strcpy(cnxt_tab[cnxt_count].upstream_port_name,out_str);
cnxt_tab[cnxt_count].upstream_elem_no = 0;
goto ncap;
}
/* look up in proc list for subnet */
NIP: i = proc_start;
while (proc_tab[i].proc_name[0] != '\0') {
if (strcmp(proc_tab[i].proc_name,out_str) == 0) break;
i++;
}
proc_cnt = i;
if (proc_tab[proc_cnt].proc_name[0] == '\0') {
strcpy(proc_tab[proc_cnt].proc_name,out_str);
proc_tab[proc_cnt].trace = 0;
proc_tab[proc_cnt + 1].proc_name[0] = '\0';
proc_count = proc_cnt;
}
TCO(NB1,'(');
scan_blanks(fp);
o_ptr = proc_tab[proc_cnt].comp_name;
Y1: TA(NA2);
goto Y1;
NA2: TN(NN2);
goto Y1;
NN2: *o_ptr = '\0';
scan_blanks(fp);
TCO(NB1,')');
curr_proc = &proc_tab[proc_cnt];
printf(" Process: %s (%s)\n",curr_proc -> proc_name,
curr_proc -> comp_name);
NB1: scan_blanks(fp);
TCO(NQ1,'?');
proc_tab[proc_cnt].trace = 1;
NQ1: scan_blanks(fp);
TCO(NSC1,';');
cnxt_tab[cnxt_count].upstream_name[0] = '\0';
cnxt_count++;
proc_count++;
proc_count++;
label_count++;
goto netloop;
NSC1: TCO(NC1,',');
goto loop;
NC1: strcpy(cnxt_tab[cnxt_count].upstream_name,out_str);
o_ptr = out_str;
X2: TC(X2a,'*'); /* automatic port */
*o_ptr = '\0';
goto is_inport;
X2a: if (scan_sym(fp, o_ptr) != 0) {
printf("Upstream port name error for %s\n",
cnxt_tab[cnxt_count].upstream_name);
ret_code = 4;
goto exit; }
is_inport:
strcpy(cnxt_tab[cnxt_count].upstream_port_name,out_str);
scan_blanks(fp);
cnxt_tab[cnxt_count].upstream_elem_no = 0;
TCO(tArrow,'[');
o_ptr = out_num;
GNx: TN(NNx);
goto GNx;
NNx: TCO(elemerr,']');
*o_ptr = '\0';
cnxt_tab[cnxt_count].upstream_elem_no = atoi(out_num);
scan_blanks(fp);
tArrow: eq_arrow = FALSE;
TCO(tEq,'-');
goto tGr;
tEq: TCO(nArrow,'=');
eq_arrow = TRUE;
tGr: TCO(nArrow,'>');
cnxt_tab[cnxt_count].capacity = -1;
scan_blanks(fp);
TCO(ncap,'(');
o_ptr = out_num;
GNz: TN(NNz);
goto GNz;
NNz: TCO(caperr,')');
*o_ptr = '\0';
cnxt_tab[cnxt_count].capacity = atoi(out_num);
scan_blanks(fp);
goto ncap;
caperr: printf("Capacity error\n");
ret_code = 4;
goto exit;
ncap: cnxt_tab[cnxt_count].downstream_elem_no = 0;
/* Scan off downstream port name */
o_ptr = out_str;
TC(Y2a,'*'); /* automatic port */
*o_ptr = '\0';
goto is_outport;
Y2a: if (scan_sym(fp, o_ptr) != 0) {
printf("Downstream port name error for %s %s\n",
cnxt_tab[cnxt_count].upstream_name,
cnxt_tab[cnxt_count].upstream_port_name);
ret_code = 4;
goto exit; }
is_outport:
strcpy(cnxt_tab[cnxt_count].downstream_port_name,out_str);
strcpy(cnxt_tab[cnxt_count].downstream_name, "*"); /* ext. conn */
cnxt_open = TRUE;
scan_blanks(fp);
TCO(CSC2,'[');
o_ptr = out_num;
GNy: TN(NNy);
goto GNy;
NNy: TCO(elemerr,']');
*o_ptr = '\0';
cnxt_tab[cnxt_count].downstream_elem_no = atoi(out_num);
CSC2: scan_blanks(fp);
TCO(NSC2,';');
if (!eq_arrow)
printf("Port name %s not an external port\n", out_str);
curr_cnxt = &cnxt_tab[cnxt_count];
if (curr_cnxt -> upstream_name[0] != '!')
printf(" Connection: %s %s[%d] -> %s[%d] %s\n",
curr_cnxt -> upstream_name,
curr_cnxt -> upstream_port_name,
curr_cnxt -> upstream_elem_no,
curr_cnxt -> downstream_port_name,
curr_cnxt -> downstream_elem_no,
curr_cnxt -> downstream_name);
else {
printf(" IIP: -> %s[%d] %s\n",
curr_cnxt -> downstream_port_name,
curr_cnxt -> downstream_elem_no,
curr_cnxt -> downstream_name);
IIP_ptr = curr_cnxt -> gen.IIPptr;
printf(" \'");
for (i = 0; i < IIP_ptr -> IIP_len; i++)
printf("%c",IIP_ptr -> datapart[i]);
printf("\'\n");
}
cnxt_count++;
cnxt_tab[cnxt_count].upstream_name[0] = '\0';
cnxt_count++;
proc_count++;
proc_count++;
label_count++;
goto netloop;
NSC2: TCO(loop,',');
if (!eq_arrow)
printf("Port name %s not an external port\n", out_str);
curr_cnxt = &cnxt_tab[cnxt_count];
if (curr_cnxt -> upstream_name[0] != '!')
printf(" Connection: %s %s[%d] -> %s[%d] %s\n",
curr_cnxt -> upstream_name,
curr_cnxt -> upstream_port_name,
curr_cnxt -> upstream_elem_no,
curr_cnxt -> downstream_port_name,
curr_cnxt -> downstream_elem_no,
curr_cnxt -> downstream_name);
else {
printf(" IIP: -> %s[%d] %s\n",
curr_cnxt -> downstream_port_name,
curr_cnxt -> downstream_elem_no,
curr_cnxt -> downstream_name);
IIP_ptr = curr_cnxt -> gen.IIPptr;
printf(" \'");
for (i = 0; i < IIP_ptr -> IIP_len; i++)
printf("%c",IIP_ptr -> datapart[i]);
printf("\'\n");
}
cnxt_count++;
cnxt_open = FALSE;
goto loop;
elemerr: printf("Port element error\n");
ret_code = 4;
goto exit;
nArrow: printf("No arrow found\n");
ret_code = 4;
exit:
if (fclose(fp) != 0) {
printf("Close error\n");
if (ret_code == 0)
ret_code = 2;
}
if (ret_code > 0) {
printf("Scan error\n");
return(ret_code);
}
proc_last = proc_count;
for (i = proc_hold; i < proc_last; i++) {
curr_proc = &proc_tab[i];
if (curr_proc -> proc_name[0] == '\0') continue;
label_ct = find_label(label_tab, curr_proc -> comp_name, file_name, label_count);
curr_proc -> composite = (label_ct > 0);
if (curr_proc -> composite)
curr_proc -> label_count = label_ct;
else {
strcpy(fname, curr_proc -> comp_name);
if ((fp2 = fopen(strcat(fname, ".net"),"r"))
!= NULL) {
label_ct = label_count;
strcpy(fname, curr_proc -> comp_name);
thxscan(fp2, cnxt_tab, proc_tab, label_tab, fname,
&label_count, &proc_count, &cnxt_count);
fclose(fp2);
curr_proc -> composite = TRUE;
curr_proc -> label_count = label_ct;
}
else {
curr_proc -> must_run =
(thxgatrs(curr_proc -> comp_name) > 0);
curr_proc -> composite = FALSE;
curr_proc -> faddr = 0;
}
}
}
*label_cp = label_count;
*proc_cp = proc_count;
*cnxt_cp = cnxt_count;
printf("Scan finished\n");
return (ret_code);
}
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
}
int thxscan(FILE *fp, label_ent *label_tab, char file_name[10])
{
char *o_ptr;
char out_str[255];
//char fname[256];
char out_num[8];
size_t i, IIPlen, ret_code;
char upstream_name[255];
char upstream_port_name[255];
int upstream_elem_no;
char procname[255];
proc_ent *proc_curr;
// proc_ent *proc_new;
// proc_ent *proc_find;
cnxt_ent *cnxt_tab;
cnxt_ent *cnxt_curr;
cnxt_ent *cnxt_new;
cnxt_ent *cnxt_hold;
// label_ent *label_new;
//int label_ct;
bool eq_arrow;
IIP *IIP_ptr;
char buffer[100];
while (true) {
if (NULL == fgets(buffer, 100, fp))
goto finish;
if (0 == strcmp(buffer, "INPORT") || 0 == strcmp(buffer, "OUTPORT"))
continue;
ret_code = 0;
curr_char = getc(fp);
proc_tab = 0;
cnxt_tab = 0;
label_curr = label_tab;
strcpy_s(label_curr->label, " ");
strcpy_s(label_curr->file, file_name);
label_curr->ent_type = 'L';
IIPlen = -1;
out_num[0] = '\0';
cnxt_hold = 0;
scan_blanks(fp);
netloop:
TCO(X0, '\'');
goto Xs; // quote found - scan off rest of IIP
X0:
if (scan_sym(fp, out_str) != 0) { // this could be a network label or a process name...
printf("Name error\n");
ret_code = 4;
goto exit;
}
TCO(X2, ':');
strcpy_s(label_curr->label, out_str); // it was a label
printf("Scanning Network: %s\n", out_str);
scan_blanks(fp);
bigloop:
cnxt_hold = 0;
IIPlen = -1;
TCO(X1, '\'');
Xs:
o_ptr = out_str;
goto get_rest_of_IIP;
X1:
if (scan_sym(fp, out_str) != 0) { // this must be a process name...
printf("Name error\n");
ret_code = 4;
goto exit;
}
X2:
strcpy_s(procname, out_str);
printf("Procname: %s\n", procname);
if (cnxt_hold != 0) {
strcpy_s(cnxt_hold->downstream_name, procname);
cnxt_hold = 0;
}
proc_curr = find_or_build_proc(procname);
if (4 == scan_blanks(fp))
goto bigloop;
goto X3;
get_rest_of_IIP:
TCO(tbsl, EOF);
printf("EOF encountered within quoted string\n");
ret_code = 4;
goto exit;
tbsl:
TCO(tbq, '\\');
CC;
goto get_rest_of_IIP;
tbq:
TCO(copy, '\'');
goto NQ2;
copy:
CC;
goto get_rest_of_IIP;
NQ2:
*o_ptr = '\0';
IIPlen = static_cast<int>(o_ptr - out_str);
IIP_ptr = (IIP *)malloc(IIPlen + 1);
memcpy(IIP_ptr->datapart, out_str, IIPlen);
IIP_ptr->datapart[IIPlen] = '\0';
printf("IIP: %s\n", IIP_ptr->datapart);
scan_blanks(fp);
//IIPlen = -1;
goto tArrow;
// scan off process name with optional component name
X3:
TCO(NB1, '(');
scan_blanks(fp);
TCO(rest_of_comp, ')');
goto NN2;
rest_of_comp:
TCO(NQ6, '"'); // this says that comp name may be surrounded by double quotes (not included in comp_name)
NQ6:
o_ptr = comp_name; // if no data between brackets, comp_name will not be modified...
TB1:
TCO(NQ7, '"');
scan_blanks(fp);
NQ7:
TCO(NB2, ')');
goto NN2;
NB2:
CC;
goto TB1;
NN2:
*o_ptr = '\0';
if (strlen(comp_name) > 0) {
strcpy_s(proc_curr->comp_name, comp_name);
printf("Comp name: %s\n", comp_name);
}
NB1:
// comp scanned off, if any
strcpy_s(upstream_name, procname); // in case this proc is the upstream of another arrow
if (4 == scan_blanks(fp))
goto bigloop;
TCO(NQ1, '?');
proc_curr->trace = 1;
if (4 == scan_blanks(fp))
goto bigloop;
NQ1:
TCO(tsc, EOF);
eof_found = TRUE;
goto nxtnet;
tsc:
TCO(tcom, ';');
scan_blanks(fp);
nxtnet:
// this is a fudge because multiple nets are not currently supported
IIPlen = -1;
TCO(nextnet, EOF);
goto exit;
tcom:
IIPlen = -1;
TCO(not_com, ',');
scan_blanks(fp);
goto bigloop;
not_com:
o_ptr = out_str;
TC(outport, '*'); /* automatic port */
*o_ptr = '\0';
goto GUy;
outport:
if (scan_sym(fp, out_str) != 0) {
printf("Name error\n");
ret_code = 4;
goto exit;
}
GUy:
scan_blanks(fp);
strcpy_s(upstream_port_name, out_str);
printf("Upstream port: %s\n", out_str);
upstream_elem_no = 0;
TCO(tArrow, '[');
o_ptr = out_num;
GNx:
TN(NNx);
goto GNx;
NNx:
TCO(elemerr, ']');
*o_ptr = '\0';
upstream_elem_no = atoi(out_num);
tArrow:
scan_blanks(fp);
eq_arrow = FALSE;
TCO(tEq, '-');
goto tGr;
tEq:
TCO(nArrow, '=');
eq_arrow = TRUE;
tGr:
TCO(nArrow, '>');
printf("Arrow\n");
cnxt_new = (cnxt_ent *)malloc(sizeof(cnxt_ent));
cnxt_new->succ = 0;
cnxt_new->dropOldest = false;
if (cnxt_tab == 0) {
cnxt_tab = cnxt_new;
label_curr->cnxt_ptr = cnxt_tab;
cnxt_curr = cnxt_tab;
}
else {
cnxt_curr->succ = cnxt_new;
cnxt_curr = cnxt_new;
}
cnxt_hold = cnxt_new;
if (IIPlen != -1) {
strcpy_s(cnxt_hold->upstream_name, "!");
cnxt_hold->upstream_port_name[0] = '\0';
cnxt_hold->gen.IIPptr = IIP_ptr;
}
else {
strcpy_s(cnxt_hold->upstream_name, upstream_name);
strcpy_s(cnxt_hold->upstream_port_name, upstream_port_name);
cnxt_hold->upstream_elem_no = upstream_elem_no;
}
cnxt_hold->capacity = -1;
scan_blanks(fp);
TCO(ncap, '(');
o_ptr = out_num;
GNz:
TN(NNz);
goto GNz;
NNz:
TCO(caperr, ')');
*o_ptr = '\0';
cnxt_hold->capacity = atoi(out_num);
scan_blanks(fp);
goto ncap;
caperr:
printf("Capacity error\n");
ret_code = 4;
goto exit;
ncap:
cnxt_hold->downstream_elem_no = 0;
/* Scan off downstream port name */
o_ptr = out_str;
TC(Y2a, '*'); /* automatic port */
*o_ptr = '\0';
strcpy_s(cnxt_hold->downstream_port_name, out_str); /* ext. conn */
goto is_outport;
Y2a:
if (scan_sym(fp, out_str) != 0) {
printf("Downstream port name error for %s %s\n",
cnxt_hold->upstream_name,
cnxt_hold->upstream_port_name);
ret_code = 4;
goto exit;
}
strcpy_s(cnxt_hold->downstream_port_name, out_str);
is_outport:
printf("Downstream port: %s\n", cnxt_hold->downstream_port_name);
scan_blanks(fp);
TCO(X1, '[');
o_ptr = out_num;
GNy:
TN(NNy);
goto GNy;
NNy:
TCO(elemerr, ']');
*o_ptr = '\0';
cnxt_hold->downstream_elem_no = atoi(out_num);
//cnxt_hold = 0;
scan_blanks(fp);
goto X1;
nextnet:
scan_blanks(fp);
if (eof_found) {
label_curr->succ = 0; // temporary fix as we are only generating one network for now
goto exit;
}
goto netloop;
elemerr:
printf("Port element error\n");
ret_code = 4;
goto exit;
nArrow:
printf("No arrow found\n");
ret_code = 4;
exit:
printf("\nSummary:\n");
proc_curr = proc_tab;
while (proc_curr != 0) {
printf(" Process: %s (%s)\n", proc_curr->proc_name,
proc_curr->comp_name);
proc_curr = proc_curr->succ;
}
cnxt_hold = cnxt_tab;
while (cnxt_hold != 0) {
char up[200];
char down[200];
char elem[20];
if (cnxt_hold->upstream_name[0] != '!') {
strcpy_s(up, cnxt_hold->upstream_port_name);
if (up[0] != '*') {
strcat_s(up, "[");
_itoa_s(cnxt_hold->upstream_elem_no, elem, 10);
strcat_s(up, elem);
strcat_s(up, "]");
}
strcpy_s(down, cnxt_hold->downstream_port_name);
if (down[0] != '*') {
strcat_s(down, "[");
_itoa_s(cnxt_hold->downstream_elem_no, elem, 10);
strcat_s(down, elem);
strcat_s(down, "]");
}
printf(" Connection: %s %s -> %s %s\n",
cnxt_hold->upstream_name,
up,
down,
cnxt_hold->downstream_name);
}
else {
strcpy_s(down, cnxt_hold->downstream_port_name);
if (down[0] != '*') {
strcat_s(down, "[");
_itoa_s(cnxt_hold->downstream_elem_no, elem, 10);
strcat_s(down, elem);
strcat_s(down, "]");
}
printf(" IIP: -> %s %s\n",
down,
cnxt_hold->downstream_name);
IIP_ptr = cnxt_hold->gen.IIPptr;
printf(" \'");
auto j = strlen(IIP_ptr->datapart);
for (i = 0; i < j; i++)
printf("%c", IIP_ptr->datapart[i]);
printf("\'\n");
}
cnxt_hold = cnxt_hold->succ;
}
}
finish:
if (fclose(fp) != 0) {
printf("Close error\n");
if (ret_code == 0)
ret_code = 2;
}
if (ret_code > 0) {
// printf("Scan error\n");
return(ret_code);
}
// printf("Scan finished\n");
return (ret_code);
}
