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 main(int argc, char *argv[]) {
cnxt_ent *cnxt_ptr;
proc_ent *proc_ptr;
label_ent *label_tab, *label_ptr;
char gen_area[200];
//char gen_comp_area[200];
char * gen_ptr;
FILE *fp, *fpo = 0;
IIP *IIPptr;
int proc_count, cnxt_count, iip_count;
int label_count = 0;
int proc_ct = 0;
char fname[256];
char file_name[10];
struct modent {
char name[32 + 1];
} modents[400];
int modentnas = 0;
int res = 0;
if (argc != 2) {
printf("You forgot to enter the file name\n");
res = 8; goto retn;;
}
strcpy(fname, argv[1]);
strcat(fname, ".fbp");
#ifdef WIN32
errno_t err;
if ((err = fopen_s(&fp, fname, "r")) != 0) {
#else
if ((f = fopen(fname, "r")) == NULL) {
#endif
fprintf(stderr, "Cannot open file %s!\n", fname);
res = 8; goto retn;
}
//char target[255];
char sep[2];
#ifdef _WIN32
strcpy(sep, "\\");
#else
strcpy(sep, "/");
#endif
//strcpy(home, getenv("HOMEDRIVE"));
//strcat(home, getenv("HOMEPATH"));
char myPath[_MAX_PATH + 1];
GetModuleFileName(NULL, myPath, _MAX_PATH);
char * pch;
pch = strrchr(myPath, sep[0]);
*pch = 0;
pch = strrchr(myPath, sep[0]);
*pch = 0;
//strcpy(fname, myPath);
strcat(myPath, sep);
strcat(myPath, "Thxgen");
strcat(myPath, sep);
strcat(myPath, fname);
pch = strrchr(myPath, '.');
*pch = 0;
strcpy(fname, myPath);
strcat(fname, ".cpp");
//FILE** pFile;
#ifdef WIN32
if ((err = fopen_s(&fpo, fname, "w")) != 0) {
#else
if ((fpo = fopen(fname, "w")) == NULL) {
#endif
printf("Cannot open Output Network: %s\n", fname);
res = 8; goto retn;
}
printf("Creating Output Network: %s\n", fname);
label_tab = (label_ent *)malloc(sizeof(label_ent));
label_tab->succ = 0;
strcpy(file_name, "\0");
if (thxscan(fp, label_tab, file_name) != 0) {
printf("Scan error\n");
res = 8; goto retn;
}
gen_ptr = gen_area;
strcpy(gen_ptr, "/* Generated Code */\n\n");
fputs(gen_area, fpo);
//gen_ptr = gen_area;
//strcpy(gen_ptr, "#include \"stdafx.h\"\n");
//fputs(gen_area,fpo);
gen_ptr = gen_area;
strcpy(gen_ptr, "#include \"thxdef.h\"\n");
fputs(gen_area, fpo);
/*
gen_ptr = gen_area;
strcpy(gen_ptr, "#include \"thxanch.h\"\n");
fputs(gen_area,fpo);
gen_ptr = gen_area;
strcpy(gen_ptr, "#include \"thxscan.h\"\n");
fputs(gen_area,fpo);
*/
gen_ptr = gen_area;
strcpy(gen_ptr, "#include <stdio.h>\n");
fputs(gen_area, fpo);
gen_ptr = gen_area;
strcpy(gen_ptr, "#define FILE struct _iobuf\n");
fputs(gen_area, fpo);
gen_ptr = gen_area;
strcpy(gen_ptr,
"void CppFBP(label_ent * label_blk, bool dynam, FILE * fp, bool timereq);\n");
fputs(gen_area, fpo);
//gen_ptr = gen_area;
//strcpy(gen_ptr, "bool NO_TRACE = false; bool TRACE = true;\n");
//fputs(gen_area,fpo);
proc_count = 0;
iip_count = 0;
cnxt_count = 0;
char comp_name_end[20];
label_ptr = label_tab;
while (label_ptr != 0) {
proc_ptr = label_ptr->proc_ptr;
while (proc_ptr != 0) {
if (proc_ptr->comp_name[0] == '\0')
comp_name_end[0] = '\0';
else {
auto j = strlen(proc_ptr->comp_name) - 1;
auto k = j;
while (j >= 0) {
if (proc_ptr->comp_name[j] == '/')
break;
j--;
}
memcpy(comp_name_end, &proc_ptr->comp_name[j + 1], k - j);
comp_name_end[k - j] = '\0';
}
auto m = -1;
for (int i = 0; i < modentnas; i++) {
if (strcmp(comp_name_end, modents[i].name) == 0) {
m = i;
break;
}
}
if (m == -1) {
strcpy(modents[modentnas].name, comp_name_end);
m = modentnas;
modentnas++;
if (!proc_ptr->composite) {
gen_ptr = gen_area;
strcpy(gen_ptr, "THRCOMP ");
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, comp_name_end);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, "(anchor anch);\n");
fputs(gen_area, fpo);
}
}
gen_ptr = gen_area;
strcpy(gen_ptr, "proc_ent P");
gen_ptr = strchr(gen_ptr, '\0');
_itoa(proc_count, gen_ptr, 10);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, " = {");
gen_ptr = strchr(gen_ptr, '\0');
if (proc_count == 0) {
strcpy(gen_ptr, "0");
}
else {
strcpy(gen_ptr, "&P");
gen_ptr = strchr(gen_ptr, '\0');
int i = proc_count - 1;
_itoa(i, gen_ptr, 10);
}
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, ", \"");
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, proc_ptr->proc_name);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, "\", \"");
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, proc_ptr->comp_name);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, "\", ");
gen_ptr = strchr(gen_ptr, '\0');
//if (!proc_ptr -> composite) {
// strcpy(gen_ptr, "(int ( PASCAL*)(anchor anch))");
//gen_ptr = strchr(gen_ptr,'\0');
strcpy(gen_ptr, comp_name_end);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, ", 0, 0,");
gen_ptr = strchr(gen_ptr, '\0');
//}
//else {
//strcpy(gen_ptr, "0, 0, 0, ");
//gen_ptr = strchr(gen_ptr,'\0');
// strcpy(gen_ptr, proc_ptr -> comp_name);
// gen_ptr = strchr(gen_ptr,'\0');
// strcpy(gen_ptr, " 0, 0,");
// gen_ptr = strchr(gen_ptr,'\0');
//}
if (proc_ptr->trace)
strcpy(gen_ptr, " TRACE, "); // trace
else
strcpy(gen_ptr, " !TRACE, "); // no trace
gen_ptr = strchr(gen_ptr, '\0');
//_itoa(proc_ptr -> composite, gen_ptr, 10);
strcpy(gen_ptr, " !COMPOS"); // no compos
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, "};\n");
proc_count++;
fputs(gen_area, fpo);
proc_ptr = proc_ptr->succ;
}
cnxt_ptr = label_ptr->cnxt_ptr;
while (cnxt_ptr != 0) {
if (cnxt_ptr->upstream_name[0] == '!') {
gen_ptr = gen_area;
strcpy(gen_ptr, "IIP I");
gen_ptr = strchr(gen_ptr, '\0');
_itoa(iip_count, gen_ptr, 10);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, " = {");
gen_ptr = strchr(gen_ptr, '\0');
IIPptr = cnxt_ptr->gen.IIPptr;
strcpy(gen_ptr, "\"");
gen_ptr = strchr(gen_ptr, '\0');
auto j = strlen(IIPptr->datapart);
for (auto i = decltype(j) {0}; i < j; i++) {
if (IIPptr->datapart[i] == '\\')
strcpy(gen_ptr, "\\\\");
else
if (IIPptr->datapart[i] == '\'')
strcpy(gen_ptr, "\\\'");
else
if (IIPptr->datapart[i] == '\"')
strcpy(gen_ptr, "\\\"");
else
if (IIPptr->datapart[i] == '\?')
strcpy(gen_ptr, "\\\?");
else {
*gen_ptr = IIPptr->datapart[i];
gen_ptr++;
*gen_ptr = '\0';
}
gen_ptr = strchr(gen_ptr, '\0');
}
strcpy(gen_ptr, "\"};\n");
fputs(gen_area, fpo);
}
gen_ptr = gen_area;
strcpy(gen_ptr, "cnxt_ent C");
gen_ptr = strchr(gen_ptr, '\0');
_itoa(cnxt_count, gen_ptr, 10);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, " = {");
gen_ptr = strchr(gen_ptr, '\0');
if (cnxt_count == 0) {
strcpy(gen_ptr, "0");
}
else {
strcpy(gen_ptr, "&C");
gen_ptr = strchr(gen_ptr, '\0');
int i = cnxt_count - 1;
_itoa(i, gen_ptr, 10);
}
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, ", \"");
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, cnxt_ptr->upstream_name);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, "\", \"");
gen_ptr = strchr(gen_ptr, '\0');
if (cnxt_ptr->upstream_name[0] == '!') {
strcpy(gen_ptr, " \", 0");
gen_ptr = strchr(gen_ptr, '\0');
}
else {
strcpy(gen_ptr, cnxt_ptr->upstream_port_name);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, "\", ");
gen_ptr = strchr(gen_ptr, '\0');
_itoa(cnxt_ptr->upstream_elem_no, gen_ptr, 10);
gen_ptr = strchr(gen_ptr, '\0');
}
strcpy(gen_ptr, ", \"");
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, cnxt_ptr->downstream_name);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, "\", \"");
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, cnxt_ptr->downstream_port_name);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, "\", ");
gen_ptr = strchr(gen_ptr, '\0');
_itoa(cnxt_ptr->downstream_elem_no, gen_ptr, 10);
gen_ptr = strchr(gen_ptr, '\0');
if (cnxt_ptr->upstream_name[0] == '!') {
strcpy(gen_ptr, ", &I");
gen_ptr = strchr(gen_ptr, '\0');
_itoa(iip_count, gen_ptr, 10);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, ", 0};\n");
iip_count++;
}
else {
strcpy(gen_ptr, ", 0, ");
gen_ptr = strchr(gen_ptr, '\0');
if (cnxt_ptr->capacity == -1)
strcpy(gen_ptr, "6");
else
_itoa(cnxt_ptr->capacity, gen_ptr, 10);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, "};\n");
}
fputs(gen_area, fpo);
cnxt_count++;
cnxt_ptr = cnxt_ptr->succ;
}
label_ptr = label_ptr->succ;
}
gen_ptr = gen_area;
//strcpy(gen_ptr, "label_ent LABELTAB = {0, \" \", \"\", &C0, &P0, \'L\'};\n");
strcpy(gen_ptr, "label_ent LABELTAB = {0, \" \", \"\", &C");
gen_ptr = strchr(gen_ptr, '\0');
int i = cnxt_count - 1;
_itoa(i, gen_ptr, 10);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, ", &P");
gen_ptr = strchr(gen_ptr, '\0');
i = proc_count - 1;
_itoa(i, gen_ptr, 10);
gen_ptr = strchr(gen_ptr, '\0');
strcpy(gen_ptr, ", \'L\'};\n");
fputs(gen_area, fpo);
gen_ptr = gen_area;
strcpy(gen_ptr, "void main() {\n");
fputs(gen_area, fpo);
gen_ptr = gen_area;
strcpy(gen_ptr, "CppFBP(&LABELTAB, 0, 0, 0);\n}\n");
fputs(gen_area, fpo);
strcpy(gen_area, "Gen finished\nOutput written to: ");
strcat(gen_area, fname);
strcat(gen_area, "\n");
printf(gen_area);
// free(cnxt_tab);
// free(proc_tab);
free(label_tab);
fclose(fp);
fclose(fpo);
retn:
system("pause"); // to see console
return;
}
void Network::go(label_ent * label_blk, bool dynam, FILE * fp, bool timereq, _anchor proc_anchor) {
Process *this_proc;
cnxt_ent *cnxt_tab;
proc_ent *proc_tab;
label_ent *label_tab;
label_ent *label_curr;
label_ent *label_new;
char file_name[10];
Port *cpp;
time_t st_time, end_time;
double secs;
st_time = time(NULL);
Process * mother = (Process *) proc_anchor.reserved;
_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF);
label_tab = (label_ent *)malloc(sizeof(label_ent));
label_curr = label_tab;
label_ent * label_this = label_blk;
if (!dynam) {
for (;;) {
strcpy(label_curr->label,
label_this->label);
strcpy(label_curr->file,
label_this->file);
label_curr->cnxt_ptr =
label_this->cnxt_ptr;
label_curr->proc_ptr =
label_this->proc_ptr;
label_curr->ent_type =
label_this->ent_type;
label_this = label_this->succ;
if (label_this == 0) break;
label_new = (label_ent *)malloc(sizeof(label_ent)); // handle subnets
label_curr->succ = label_new;
label_curr = label_new;
}
cnxt_tab = label_tab -> cnxt_ptr;
proc_tab = label_tab -> proc_ptr;
}
else {
label_tab->succ = 0;
file_name[0] = '\0';
//if (fp == 0) {
// printf("File does not exist: %s\n", fp);
// exit(4);
//}
if (thxscan(fp, label_tab, file_name) != 0) {
printf("Scan error\n");
exit(4);
}
}
//network = new Appl;
//network = this;
if (proc_anchor.reserved == NULL)
strcpy(name,"APPL");
else
strcpy(name,"SUBNET");
//first_ready_proc = 0;
first_child_proc = 0;
first_child_comp = 0;
first_cnxt = 0;
dynam = dynam;
active = FALSE;
possibleDeadlock = FALSE;
deadlock = FALSE;
thxbnet(label_tab, mother, this, label_tab); // first param is network/subnet, 2nd is "mother" process", 4th is network as a whole
int thread_count = 0;
this_proc = (Process*) first_child_proc;
while (this_proc != 0)
{
thread_count ++;
this_proc = this_proc -> next_proc;
}
/* Look for processes with no input ports */
latch = new Cdl(thread_count);
Cnxt * cnxt_ptr = (Cnxt *) first_cnxt;
while (cnxt_ptr != 0) {
cnxt_ptr -> closed = FALSE;
cnxt_ptr = cnxt_ptr -> succ;
}
this_proc = (Process*) first_child_proc;
while (this_proc != 0)
{
this_proc -> network = this;
this_proc-> self_starting = TRUE;
cpp = this_proc -> in_ports;
while (cpp != 0) {
for (int i = 0; i < cpp -> elem_count; i++) {
if (cpp -> elem_list[i].gen.connxn != 0 &&
! cpp -> elem_list[i].is_IIP)
this_proc->self_starting = FALSE;
}
cpp = cpp -> succ;
}
if (this_proc -> self_starting)
{
// add to ready chain
//this_proc -> status = INITIATED;
if (this_proc -> trace)
printf("%s Initiated\n",this_proc -> procname);
this_proc -> activate();
}
//thread_count ++;
this_proc = this_proc -> next_proc;
}
active = TRUE;
waitForAll();
delete latch;
//if (dynam) { -- check this out!
// free(cnxt_tab);
// free(proc_tab);
//}
//free (latch);
thxfcbs();
//free(label_tab);
end_time = time(NULL);
secs = difftime(end_time, st_time);
if (timereq){
printf("Elapsed time in seconds: %5.3f\n",secs);
}
if (strcmp(name, "SUBNET") != 0) {
//_CrtDumpMemoryLeaks();
//char c;
printf("Press enter to terminate\n");
std::cin.get(); // to see console
//system("pause"); // to see console
exit(0);
}
}
