From: Rafał Długołęcki <kontakt@dlugolecki.net.pl>
Date: Thu, 18 Jul 2013 06:53:12 +0000 (+0200)
Subject: vlp-10 using coding style in cint.c
X-Git-Tag: 3.1~33
X-Git-Url: https://git.dlugolecki.net.pl/?p=vlp.git;a=commitdiff_plain;h=8115e740f3bee6ddc242299ec1aaf3d3e8d85861

vlp-10 using coding style in cint.c
---

diff --git a/src/int/cint.c b/src/int/cint.c
index 547a770..00e78b5 100644
--- a/src/int/cint.c
+++ b/src/int/cint.c
@@ -27,24 +27,25 @@ int main();
 
 
 
-int internal_sock,graph_sock,net_sock,connected=0;
+int internal_sock, graph_sock, net_sock, connected = 0;
 struct sockaddr_un svr;
 int GraphRes=-1;
-char ProgName[255],mygname[80], gname[80],mykname[80], nname[80], mynname[80];
+char ProgName[255], mygname[80], gname[80], mykname[80], nname[80], mynname[80];
 fd_set DirSet;
 int maxDirSet;
 
 ctx_struct my_ctx;
 ctx_struct parent_ctx;
 
-int RInstance[255]; /* IDs of remote instances */
-int DirConn[255];   /* Direct connection channels */
+/* IDs of remote instances */
+int RInstance[255];
+/* Direct connection channels */
+int DirConn[255];
 
 /* graphic vars */
 int fcol, bcol, curx=0, cury=0;
 
 
-
 /* Macro to decode addressing modes : */
 #define getargument(a, argnr)                                       \
     switch (eop->args[ argnr ])                                     \
@@ -60,169 +61,189 @@ int fcol, bcol, curx=0, cury=0;
         case NOARGUMENT : return;                          \
     }
 
-
-static void load(_filename)     /* Load code and prototypes from file */
-   char *_filename;
+/**
+ * Load code and prototypes from file
+ */
+static void load(char *_filename)
 {
-    FILE *fp;
-    char *cp;
-    word n, left;
-    char filename[100]; /* should suffice on all systems */
-
-    strcpy( filename, _filename );
-    M = mallocate(memorysize+1);        /* allocate main memory array */
-    if (M == NULL) abend("Memory size too large (use /m option)\n");
-
-    addext(filename, ".ccd");
-    if ((fp = fopen(filename, BINARYREAD)) == NULL)
-        {
-           fprintf(stderr,"Cannot open .ccd file\n");
-           endrun(10);
-         };
-
-    ic = 0;              /* read static data and code */
-    left = memorysize+1;               /* from .ccd file */
-    do
-    {
-        if (left == 0) abend("Memory size too small (use /m option)\n");
-        n = min(IOBLOCK/sizeof(word), left);
-        n = fread((char *) &M[ ic ], sizeof(word), (int) n, fp);
-        ic += n;
-        left -= n;
-    } while (n != 0);      /* now ic = number of words read */
-
-    fclose(fp);
-    /* Get various addresses passed by GENERATOR */
-    ipradr    = M[ ic-5 ];           /* primitive type desctriptions */
-    temporary = M[ ic-4 ];           /* global temporary variables */
-    strings   = M[ ic-3 ];           /* string constants */
-    lastprot  = M[ ic-2 ];           /* last prototype number */
-    freem     = M[ ic-1 ];           /* first free word in memory */
-
-    /* Read prototypes from .pcd file */
-    addext(filename, ".pcd");
-    if ((fp = fopen(filename, BINARYREAD)) == NULL)
-       {
-         fprintf(stderr,"Cannot open .pcd file\n");
-         endrun(10); 
-        }
-    for (n = MAINBLOCK;  n <= lastprot;  n++ )
-    {
-        cp = ballocate(sizeof(protdescr));
-        if (cp == NULL) abend("Memory size too large (use /m option)\n");
-        prototype[ n ] = (protdescr *) cp;
-        if (fread(cp, sizeof(protdescr), 1, fp) != 1)
-            abend("Cannot read .pcd file\n");
-    }
-    fclose(fp);
-
-    /* Open trace file */
-    if (debug)
-    {
-        addext(filename, ".trd");
-        if ((tracefile = fopen(filename, "w")) == NULL)
-            abend("Cannot open .trd file\n");
-    }
-} /* end load */
-
+	FILE *fp;
+	char *cp;
+	word n, left;
+	/* should suffice on all systems */
+	char filename[100];
+
+	strcpy(filename, _filename);
+	/* allocate main memory array */
+	M = mallocate(memorysize + 1);
+	if (M == NULL)
+		abend("Memory size too large (use /m option)\n");
+
+	addext(filename, ".ccd");
+	if ((fp = fopen(filename, BINARYREAD)) == NULL) {
+		fprintf(stderr, "Cannot open .ccd file\n");
+		endrun(10);
+	};
+
+	/* read static data and code from .ccd file */
+	ic = 0;
+	left = memorysize + 1;
+	do {
+		if (left == 0)
+			abend("Memory size too small (use /m option)\n");
+		n = min(IOBLOCK / sizeof(word), left);
+		n = fread((char *) &M[ ic ], sizeof(word), (int) n, fp);
+		ic += n;
+		left -= n;
+	} while (n != 0);
+	/* now ic = number of words read */
+
+	fclose(fp);
+	
+	/* Get various addresses passed by GENERATOR */
+	
+	/* primitive type desctriptions */
+	ipradr = M[ic - 5];
+	/* global temporary variables */
+	temporary = M[ic - 4];
+	/* string constants */
+	strings = M[ic - 3];
+	/* last prototype number */
+	lastprot = M[ic - 2];
+	/* first free word in memory */
+	freem = M[ic - 1];
+
+	/* Read prototypes from .pcd file */
+	addext(filename, ".pcd");
+	if ((fp = fopen(filename, BINARYREAD)) == NULL) {
+		fprintf(stderr,"Cannot open .pcd file\n");
+		endrun(10); 
+	}
+	for (n = MAINBLOCK; n <= lastprot; n++) {
+		cp = ballocate(sizeof(protdescr));
+		if (cp == NULL)
+			abend("Memory size too large (use /m option)\n");
+		prototype[n] = (protdescr *) cp;
+
+		if (fread(cp, sizeof(protdescr), 1, fp) != 1)
+			abend("Cannot read .pcd file\n");
+	}
+	fclose(fp);
+
+	/* Open trace file */
+	if (debug) {
+		addext(filename, ".trd");
+		if ((tracefile = fopen(filename, "w")) == NULL)
+			abend("Cannot open .trd file\n");
+	}
+}
 
-static void initiate(argc, argv)        /* Establish configuration parameters */
-int argc;
-char **argv;
+/**
+ * Establish configuration parameters
+ */
+static void initiate(int argc, char **argv)
 {
-    long m;
-    int len,i,on;
-    char filename[80];
-    int sock;
-    fd_set rset,wset;
-
-     ournode = 0;
-     network = TRUE;
-    if ( (argc==4) && (strcmp(argv[3],"r") == 0) ) remote = TRUE;else remote=FALSE;
-      for(i=0;i<255;i++)
-      {
-        RInstance[i] = -1;
-        DirConn[i] = -1;
-      }
-      
-    FD_ZERO(&DirSet);    
-    maxDirSet=0;
+	long m;
+	int len,i,on;
+	char filename[80];
+	int sock;
+	fd_set rset, wset;
+
+	ournode = 0;
+	network = TRUE;
+	if ((argc == 4) && (strcmp(argv[3], "r") == 0))
+		remote = TRUE;
+	else
+		remote = FALSE;
+	
+	for(i = 0; i < 255; i++) {
+		RInstance[i] = -1;
+		DirConn[i] = -1;
+	}
+
+	FD_ZERO(&DirSet);
+	maxDirSet = 0;
  
-    strcpy(filename,argv[2]);
-    strcpy(ProgName,argv[2]);
-
-    strcpy(mynname,argv[1]);
-    strcat(mynname,".net");
-    unlink(mynname);
-    sock = socket(AF_UNIX,SOCK_STREAM,0); 
-    bzero(&svr, sizeof(svr));
-    svr.sun_family = AF_UNIX;
-    strcpy(svr.sun_path,mynname);
-    len = strlen(svr.sun_path)+sizeof(svr.sun_family);
-    bind(sock,(struct sockaddr*)&svr, len);
-    listen(sock,5);
-
-
-   /* socket for graphic requests */ 
-    strcpy(mygname,argv[1]);
-    strcat(mygname,".gr");
-    unlink(mygname);
-   
-
-   /* socket for KERNEL communication */  
-      internal_sock = socket(AF_UNIX,SOCK_STREAM,0);
-      bzero(&svr, sizeof(svr));
-      svr.sun_family = AF_UNIX;
-      strcpy(svr.sun_path,argv[1]);
-      strcpy(mykname,argv[1]);
-      len = strlen(svr.sun_path)+sizeof(svr.sun_family);
-      i=connect(internal_sock,(struct sockaddr*)&svr,len);
-     
-    if (i==0)
-       { 
-        fcntl(internal_sock,F_SETFL, O_NONBLOCK|fcntl(internal_sock,F_GETFL,0));
-        }
-    else
-     while (i!=0)
-    {
-      close(internal_sock);
-      internal_sock = socket(AF_UNIX,SOCK_STREAM,0);
-      fcntl(internal_sock,F_SETFL, O_NONBLOCK|fcntl(internal_sock,F_GETFL,0));
-      i=connect(internal_sock,(struct sockaddr*)&svr,len);     
-    }    
-    on=1;
-    setsockopt(internal_sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
-    
-    /* socket for network requests */
-     FD_ZERO(&rset);FD_ZERO(&wset);
-     FD_SET(sock,&rset);
-     if (select(sock+1,&rset,&wset,0,0))
-      net_sock = accept(sock,(struct sockaddr*)0,(int *)0);
-    if (net_sock>0)
-    {
-     fcntl(net_sock,F_SETFL,O_NONBLOCK|fcntl(net_sock,F_GETFL,0));
-     setsockopt(net_sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
-
-    }
-    close(sock);
-
-    if( filename!=NULL )
-       load(filename);                     /* load code and prototypes */
-    else
-       usage();
+	strcpy(filename, argv[2]);
+	strcpy(ProgName, argv[2]);
+
+	strcpy(mynname, argv[1]);
+	strcat(mynname, ".net");
+	unlink(mynname);
+	sock = socket(AF_UNIX, SOCK_STREAM, 0);
+	bzero(&svr, sizeof(svr));
+	svr.sun_family = AF_UNIX;
+	strcpy(svr.sun_path, mynname);
+	len = strlen(svr.sun_path) + sizeof(svr.sun_family);
+	bind(sock, (struct sockaddr*)&svr, len);
+	listen(sock, 5);
+
+
+	/* socket for graphic requests */ 
+	strcpy(mygname, argv[1]);
+	strcat(mygname, ".gr");
+	unlink(mygname);
+
+	/* socket for KERNEL communication */  
+	internal_sock = socket(AF_UNIX, SOCK_STREAM, 0);
+	bzero(&svr, sizeof(svr));
+	svr.sun_family = AF_UNIX;
+	strcpy(svr.sun_path, argv[1]);
+	strcpy(mykname, argv[1]);
+	len = strlen(svr.sun_path) + sizeof(svr.sun_family);
+	i = connect(internal_sock, (struct sockaddr*)&svr, len);
+
+	if (i==0) {
+		fcntl(internal_sock,F_SETFL, O_NONBLOCK |
+						fcntl(internal_sock,F_GETFL,0));
+	}
+	else
+		while (i!=0) {
+			close(internal_sock);
+			internal_sock = socket(AF_UNIX, SOCK_STREAM, 0);
+			fcntl(internal_sock, F_SETFL, O_NONBLOCK |
+					fcntl(internal_sock, F_GETFL, 0));
+			i = connect(internal_sock, (struct sockaddr*)&svr, len);
+		}
+	on = 1;
+	setsockopt(internal_sock, IPPROTO_TCP, TCP_NODELAY, (char*)&on,
+								sizeof(on));
+
+	/* socket for network requests */
+	FD_ZERO(&rset);
+	FD_ZERO(&wset);
+	FD_SET(sock, &rset);
+	if (select(sock + 1, &rset, &wset, 0, 0))
+		net_sock = accept(sock, (struct sockaddr*)0, (int *)0);
+
+	if (net_sock > 0) {
+		fcntl(net_sock, F_SETFL, O_NONBLOCK |
+						fcntl(net_sock, F_GETFL, 0));
+		setsockopt(net_sock, IPPROTO_TCP, TCP_NODELAY, (char*)&on,
+								sizeof(on));
+
+	}
+	close(sock);
+
+	/* load code and prototypes */
+	if (filename != NULL)
+		load(filename);
+	else
+		usage();
 }
 
 
 void decode(){
-    extopcode *eop;
-
-    eop = (extopcode *)(M+ic);   /* pointer to extended opcode in M */
-    lastic = ic;                     /* save ic for possible redecoding */
-    ic += APOPCODE;
-    opcode = ((int) eop->opcode ) & 0xFF ;
-    getargument(a1, 0);
-    getargument(a2, 1);
-    getargument(a3, 2);
+	extopcode *eop;
+
+	/* pointer to extended opcode in M */
+	eop = (extopcode *)(M + ic);
+	/* save ic for possible redecoding */
+	lastic = ic;
+	ic += APOPCODE;
+	opcode = ((int) eop->opcode ) & 0xFF ;
+	getargument(a1, 0);
+	getargument(a2, 1);
+	getargument(a3, 2);
 }
 
 /* -------------------------------------------------------------------- */
@@ -230,509 +251,505 @@ void decode(){
 
 void send_to_graph(G_MESSAGE *msg)
 {
- write(graph_sock,msg,sizeof(G_MESSAGE));
+	write(graph_sock, msg, sizeof(G_MESSAGE));
 }
 
 int read_from_graph(G_MESSAGE *msg)
 {
- fd_set rset,wset;
- struct timeval tout={0,0};
- 
- FD_ZERO(&rset);FD_ZERO(&wset);
- FD_SET(graph_sock,&rset);
- 
-  
- if (select(graph_sock+1,&rset,&wset,0,(struct timeval *)&tout)>0)
- {
-  if (FD_ISSET(graph_sock,&rset))
-   return(read(graph_sock,msg,sizeof(G_MESSAGE)));
- }
- return(0);  
+	fd_set rset,wset;
+	struct timeval tout = {0, 0};
+
+	FD_ZERO(&rset);
+	FD_ZERO(&wset);
+	FD_SET(graph_sock, &rset);
+
+
+	if (select(graph_sock + 1, &rset, &wset, 0, (struct timeval *)&tout) > 0) {
+		if (FD_ISSET(graph_sock, &rset))
+			return(read(graph_sock,msg,sizeof(G_MESSAGE)));
+	}
+	return(0);
 }
 
 int read_from_net(MESSAGE *msg)
 {
- fd_set rset,wset;
- struct timeval tout={0,0};
- 
- FD_ZERO(&rset);FD_ZERO(&wset);
- FD_SET(net_sock,&rset);
- 
-  
- if (select(net_sock+1,&rset,&wset,0,(struct timeval *)&tout)>0)
- {
-  if (FD_ISSET(net_sock,&rset))
-   return(read(net_sock,msg,sizeof(MESSAGE)));
- }
- return(0);  
+	fd_set rset,wset;
+	struct timeval tout = {0, 0};
+
+	FD_ZERO(&rset);
+	FD_ZERO(&wset);
+	FD_SET(net_sock, &rset);
+
+
+	if (select(net_sock + 1, &rset, &wset, 0, (struct timeval *)&tout) > 0) {
+		if (FD_ISSET(net_sock, &rset))
+			return(read(net_sock, msg, sizeof(MESSAGE)));
+	}
+	return(0);
 }
 
 
 /* Get graphic resource number */
 int get_graph_res()
 {
- MESSAGE msg;
- int sock;
- struct sockaddr_un svr;
- int len,i,on;
- fd_set rset,wset;
-
- unlink(mygname);
- sock = socket(AF_UNIX,SOCK_STREAM,0);
- bzero(&svr,sizeof(svr));
- svr.sun_family = AF_UNIX;
- strcpy(svr.sun_path,mygname);
- len = strlen(svr.sun_path)+sizeof(svr.sun_family);
- bind(sock,(struct sockaddr*)&svr, len);      
- listen(sock,5);
-
-
- msg.msg_type = MSG_GRAPH;
- msg.param.pword[0] = GRAPH_ALLOCATE;
- strcpy(msg.param.pstr,mygname);
- write(internal_sock,&msg,sizeof(MESSAGE));
- bzero(&msg,sizeof(MESSAGE));
- FD_ZERO(&rset);FD_ZERO(&wset);
- FD_SET(sock,&rset);
-  if (select(sock+1,&rset,&wset,0,0))
-    graph_sock = accept(sock,(struct sockaddr*)0,(int*)0);
- 
- if (graph_sock == -1)
- {
-   graphics=FALSE;return(0);
- }
-  on=1;
-  close(sock);
-  fcntl(graph_sock,F_SETFL, O_NONBLOCK|fcntl(graph_sock,F_GETFL,0));
-  setsockopt(graph_sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
-
-  return(1);
-   
-} /* get_graph_res */
+	MESSAGE msg;
+	int sock;
+	struct sockaddr_un svr;
+	int len, i, on;
+	fd_set rset, wset;
+
+	unlink(mygname);
+	sock = socket(AF_UNIX, SOCK_STREAM, 0);
+	bzero(&svr, sizeof(svr));
+	svr.sun_family = AF_UNIX;
+	strcpy(svr.sun_path, mygname);
+	len = strlen(svr.sun_path) + sizeof(svr.sun_family);
+	bind(sock, (struct sockaddr*)&svr, len);
+	listen(sock, 5);
+
+
+	msg.msg_type = MSG_GRAPH;
+	msg.param.pword[0] = GRAPH_ALLOCATE;
+	strcpy(msg.param.pstr, mygname);
+	write(internal_sock, &msg, sizeof(MESSAGE));
+	bzero(&msg, sizeof(MESSAGE));
+	FD_ZERO(&rset);
+	FD_ZERO(&wset);
+	FD_SET(sock, &rset);
+	if (select(sock+1, &rset, &wset, 0, 0))
+		graph_sock = accept(sock, (struct sockaddr*)0, (int*)0);
+
+	if (graph_sock == -1) {
+		graphics = FALSE;
+		return 0;
+	}
+	on = 1;
+	close(sock);
+	fcntl(graph_sock, F_SETFL, O_NONBLOCK|fcntl(graph_sock, F_GETFL, 0));
+	setsockopt(graph_sock, IPPROTO_TCP, TCP_NODELAY, (char*)&on, sizeof(on));
+
+	return 1;
+}
 
 
 /* writeln string */
 void writeln_str(char *s)
 {
- G_MESSAGE msg;
- msg.msg_type = MSG_GRAPH;
- msg.param.pword[1] = GraphRes;
- msg.param.pword[2] = GRAPH_WRITE;
- strcpy(msg.param.pstr,s);
- 
- send_to_graph(&msg);
- strcpy(msg.param.pstr,"\n");
- send_to_graph(&msg);
+	G_MESSAGE msg;
+	msg.msg_type = MSG_GRAPH;
+	msg.param.pword[1] = GraphRes;
+	msg.param.pword[2] = GRAPH_WRITE;
+	strcpy(msg.param.pstr, s);
+
+	send_to_graph(&msg);
+	strcpy(msg.param.pstr, "\n");
+	send_to_graph(&msg);
 }
 
 /* write string */
 void write_str(char *s)
 {
- G_MESSAGE msg;
- msg.msg_type = MSG_GRAPH;
- msg.param.pword[1] = GraphRes;
- msg.param.pword[0] = GRAPH_WRITE;
- strcpy(msg.param.pstr,s);
- send_to_graph(&msg);
+	G_MESSAGE msg;
+	msg.msg_type = MSG_GRAPH;
+	msg.param.pword[1] = GraphRes;
+	msg.param.pword[0] = GRAPH_WRITE;
+	strcpy(msg.param.pstr, s);
+	send_to_graph(&msg);
 }
 
 /* write char */
 void write_char(char a)
 {
- G_MESSAGE msg;
+	G_MESSAGE msg;
 
- msg.msg_type = MSG_GRAPH;
- msg.param.pword[1] = GraphRes;
- msg.param.pword[0] = GRAPH_PUTCHAR;
- msg.param.pchar = a;
- send_to_graph(&msg);
+	msg.msg_type = MSG_GRAPH;
+	msg.param.pword[1] = GraphRes;
+	msg.param.pword[0] = GRAPH_PUTCHAR;
+	msg.param.pchar = a;
+	send_to_graph(&msg);
 }
 
 
 /* read char */
 char read_char()
 {
- char ch;
- G_MESSAGE msg;
- int st;
-
-
-  msg.msg_type = MSG_GRAPH;
-  msg.param.pword[1] = GraphRes;
-  msg.param.pword[0] = GRAPH_READCHAR;
-  send_to_graph(&msg);
-  while(TRUE)
-      {
-       st = read_from_graph(&msg);
-       if (st>0)
-         {
-          if ((msg.msg_type == MSG_GRAPH) && 
-              (msg.param.pword[0]==GRAPH_READCHAR_RESPONSE)) 
-            {ch = msg.param.pchar;break;}
-         }
-       }
- return(ch);
-
+	char ch;
+	G_MESSAGE msg;
+	int st;
+
+	msg.msg_type = MSG_GRAPH;
+	msg.param.pword[1] = GraphRes;
+	msg.param.pword[0] = GRAPH_READCHAR;
+	send_to_graph(&msg);
+	while(TRUE) {
+		st = read_from_graph(&msg);
+		if (st > 0) {
+			if ((msg.msg_type == MSG_GRAPH) && 
+				(msg.param.pword[0] == GRAPH_READCHAR_RESPONSE)) 
+				{
+				ch = msg.param.pchar;
+				break;
+			}
+		}
+	}
+	return ch;
 }
 
 /* read line */
 void read_line()
 {
- G_MESSAGE msg;
- int st;
-
-
-  msg.msg_type = MSG_GRAPH;
-  msg.param.pword[1] = GraphRes;
-  msg.param.pword[0] = GRAPH_READLN;
-  send_to_graph(&msg);
-  while(TRUE)
-      {
-       st = read_from_graph(&msg);
-       if (st>0)
-         if ((msg.msg_type == MSG_GRAPH) && (msg.param.pword[0]== GRAPH_READLN_RESPONSE))
-          break;
-       }
+	G_MESSAGE msg;
+	int st;
+
+
+	msg.msg_type = MSG_GRAPH;
+	msg.param.pword[1] = GraphRes;
+	msg.param.pword[0] = GRAPH_READLN;
+	send_to_graph(&msg);
+	while(TRUE) {
+		st = read_from_graph(&msg);
+		if (st > 0)
+			if ((msg.msg_type == MSG_GRAPH) &&
+				(msg.param.pword[0]== GRAPH_READLN_RESPONSE))
+				break;
+	}
 }
 
 /* read string */
 void read_str(char *s)
 {
- char ss[255];
- G_MESSAGE msg;
- int st;
-
-  msg.msg_type = MSG_GRAPH;
-  msg.param.pword[1] = GraphRes;
-  msg.param.pword[0] = GRAPH_READSTR;
-  send_to_graph(&msg);
-  while(TRUE)
-      {
-       st = read_from_graph(&msg);
-       if (st>0)
-         {
-          if ((msg.msg_type == MSG_GRAPH) && 
-              (msg.param.pword[0]==GRAPH_READSTR_RESPONSE)) 
-            { strcpy(ss,msg.param.pstr);break;}
-         }
-       }
- strcpy(s,ss);
-
+	char ss[255];
+	G_MESSAGE msg;
+	int st;
+
+	msg.msg_type = MSG_GRAPH;
+	msg.param.pword[1] = GraphRes;
+	msg.param.pword[0] = GRAPH_READSTR;
+	send_to_graph(&msg);
+	while(TRUE) {
+		st = read_from_graph(&msg);
+		if (st > 0) {
+			if ((msg.msg_type == MSG_GRAPH) && 
+				(msg.param.pword[0]==GRAPH_READSTR_RESPONSE)) {
+				strcpy(ss,msg.param.pstr);
+				break;
+			}
+		}
+	}
+	strcpy(s, ss);
 }
 
-
-/* send message to kernel */
+/**
+ * send message to kernel
+ */
 void send_to_kernel(MESSAGE *msg)
 {
- write(internal_sock,msg,sizeof(MESSAGE));
+	write(internal_sock, msg, sizeof(MESSAGE));
 }
 
 /* send message to net */
 /* 2010 returns 1 if ok and 0 if node desn't exists */
 int send_to_net(MESSAGE *msg)
 {
- int k,len;
- MESSAGE m;
- struct sockaddr_in svr;
- char addr[256];
-
- 
- k = msg->int_msg.control.receiver.node; 
-
- /* 2010 check if node exists */
- m.msg_type = MSG_NET;
- m.param.pword[0] = NET_NODE_EXIST;
- m.param.pword[1] = k;
- m.param.pword[2] = my_ctx.program_id;
- write(net_sock,&m,sizeof(MESSAGE));
- bzero(&m,sizeof(MESSAGE));
- while( (m.msg_type!=MSG_NET) && (m.param.pword[0]!=NET_NODE_EXIST) )
-  read(net_sock,&m,sizeof(MESSAGE));
- if (m.param.pword[1]!=1) return 0;
- strcpy(addr,m.param.pstr);
-
- if (RInstance[k]==-1)
-  { 
-   bzero(&m,sizeof(MESSAGE));
-   m.msg_type = MSG_VLP;
-   m.param.pword[0] = VLP_REMOTE_INSTANCE_PLEASE;
-   m.param.pword[1] = my_ctx.program_id;
-   m.param.pword[2] = k;
-   send_to_kernel(&m);
-   bzero(&m,sizeof(MESSAGE));
-   
-   while(1)
-     {
-       read(internal_sock,&m,sizeof(MESSAGE));
-       if ( (m.msg_type == MSG_VLP) && (m.param.pword[0]==VLP_REMOTE_INSTANCE_HERE)) break;
-      }
-      
-   /*printf("DEBUG: remote instance made with id: %d addr %s port %d\n",m.param.pword[1],addr, htons(m.param.pword[8]));*/
-   RInstance[k] = m.param.pword[1];
-   /* Make direct connection */
-   DirConn[k] = socket(AF_INET,SOCK_STREAM,0);
-   svr.sin_family = AF_INET;
-   svr.sin_addr.s_addr = inet_addr(addr);
-   svr.sin_port = htons(m.param.pword[8]);
-   len = connect(DirConn[k],(struct sockaddr*)&svr,sizeof(svr));
-   if (len!=0) 
-    {
-     RInstance[k]=-1;
-     
-     writeln_str("Cannot connect remote instance!");
-    }
-   else
-     {
-      fcntl(DirConn[k], F_SETFL,O_NONBLOCK | fcntl(DirConn[k], F_GETFL,0));
-     } 
-   }
-   if (RInstance[k]!=-1)
-   {
-      
-      write(DirConn[k],&(msg->int_msg),sizeof(message)); 
-   } 
-   return 1;
+	int k, len;
+	MESSAGE m;
+	struct sockaddr_in svr;
+	char addr[256];
+
+
+	k = msg->int_msg.control.receiver.node; 
+
+	/* 2010 check if node exists */
+	m.msg_type = MSG_NET;
+	m.param.pword[0] = NET_NODE_EXIST;
+	m.param.pword[1] = k;
+	m.param.pword[2] = my_ctx.program_id;
+	write(net_sock, &m, sizeof(MESSAGE));
+	bzero(&m, sizeof(MESSAGE));
+	 while((m.msg_type != MSG_NET) && (m.param.pword[0] != NET_NODE_EXIST))
+		read(net_sock, &m, sizeof(MESSAGE));
+
+	if (m.param.pword[1] != 1)
+		return 0;
+
+	strcpy(addr, m.param.pstr);
+
+	if (RInstance[k] == -1) {
+		bzero(&m,sizeof(MESSAGE));
+		m.msg_type = MSG_VLP;
+		m.param.pword[0] = VLP_REMOTE_INSTANCE_PLEASE;
+		m.param.pword[1] = my_ctx.program_id;
+		m.param.pword[2] = k;
+		send_to_kernel(&m);
+		bzero(&m, sizeof(MESSAGE));
+
+		while(1) {
+			read(internal_sock, &m, sizeof(MESSAGE));
+			if ((m.msg_type == MSG_VLP) &&
+				(m.param.pword[0] == VLP_REMOTE_INSTANCE_HERE))
+				break;
+		}
+
+		/*printf("DEBUG: remote instance made with id: "
+			"%d addr %s port %d\n", m.param.pword[1], addr,
+			htons(m.param.pword[8]));*/
+		RInstance[k] = m.param.pword[1];
+		/* Make direct connection */
+		DirConn[k] = socket(AF_INET, SOCK_STREAM, 0);
+		svr.sin_family = AF_INET;
+		svr.sin_addr.s_addr = inet_addr(addr);
+		svr.sin_port = htons(m.param.pword[8]);
+		len = connect(DirConn[k], (struct sockaddr*)&svr, sizeof(svr));
+		if (len!=0) {
+			RInstance[k] = -1;
+
+			writeln_str("Cannot connect remote instance!");
+		} else {
+			fcntl(DirConn[k], F_SETFL, O_NONBLOCK |
+						fcntl(DirConn[k], F_GETFL, 0));
+		}
+	}
+	if (RInstance[k] != -1) {
+		write(DirConn[k], &(msg->int_msg), sizeof(message));
+	} 
+	return 1;
 }
 
-
-
 /* -------------------- Check for message on internal socket -------------*/
 
-
 void get_internal()
 {
- MESSAGE m,m1;
- message mx;
- 
- int r,max,i;
- char s[80];
- fd_set rset;
- struct timeval tout={0,0};
- 
- 
+	MESSAGE m, m1;
+	message mx;
+
+	int r, max, i;
+	char s[80];
+	fd_set rset;
+	struct timeval tout = {0, 0};
 
  /* 2010 */
  /* ----------- Direct connection messages -----
- FD_ZERO(&DirSet);
- maxDirSet=0;
- for(i=0;i<255;i++)
-  if (DirConn[i]!=-1) 
-   {
-    FD_SET(DirConn[i],&DirSet);
-    if (maxDirSet<DirConn[i]) maxDirSet=DirConn[i];
-   }
- 
- if (select(maxDirSet+1,&DirSet,0,0,(struct timeval *)&tout)>0)
-  {
-   for(i=0;i<255;i++)
-   {
-    if ( (DirConn[i]!=-1) && (FD_ISSET(DirConn[i],&DirSet)) )
-    {
-     r=read(DirConn[i],&mx,sizeof(mx));
-     if (r>0)
-     {
-      memcpy(globmsgqueue+msgtail,&mx,sizeof(message));
-      msgtail = (msgtail+1) % MAXMSGQUEUE;
-      msgready++;
-     } 
-    }
-   }
-   }
- -----------------------------------------*/
- 
- 
- FD_ZERO(&rset);
- FD_SET(net_sock,&rset);
- FD_SET(internal_sock,&rset); 
- if (net_sock>internal_sock) max = net_sock; else max = internal_sock;
- /* 2010 */
- for(i=0;i<255;i++) {
-  if (DirConn[i]!=-1) 
-   {
-    FD_SET(DirConn[i],&rset);
-    if (max<DirConn[i]) max=DirConn[i];
-   }
- } /* for */
-  
- if (select(max+1,&rset,0,0,(struct timeval *)&tout)>0)
- {
- 
-  /* 2010 */
-  for(i=0;i<255;i++)
-   {
-    if ( (DirConn[i]!=-1) && (FD_ISSET(DirConn[i],&rset)) )
-    {
-     /*printf("DEBUG: Interp has message on direct connection: type %d par %d\n",mx.control.type,mx.control.par);  */
-     r=read(DirConn[i],&mx,sizeof(mx));
-     if (r>0 && r==sizeof(mx))
-     {      
-      memcpy(globmsgqueue+msgtail,&mx,sizeof(message));
-      msgtail = (msgtail+1) % MAXMSGQUEUE;
-      msgready++;
-     } 
-    }
-   }
-
-
-
-
- if (FD_ISSET(net_sock,&rset))
- {
- r = read(net_sock, &m, sizeof(MESSAGE));
- if (r>0)
- {
-   switch(m.msg_type)
-   {
-     case MSG_NET:
-                  switch(m.param.pword[0])
-                  {
-                   case NET_PROPAGATE:
-                    /*printf("DEBUG: cint net_sock MSG_NET NET_PROPAGATE cmd %d\n",m.param.pword[6]);*/
-                    memcpy(globmsgqueue+msgtail,&m.int_msg,sizeof(message));
-                    msgtail = (msgtail+1) % MAXMSGQUEUE;
-                    msgready++;
-                   break;
-                  }; break;
-    } /*switch */
- }
-  } /* FD_ISSET */
- 
- if (FD_ISSET(internal_sock,&rset))
- {
- r = read(internal_sock,&m,sizeof(MESSAGE));
-
- if (r>0)
- {
-  switch(m.msg_type)
-  {
-    case MSG_INT:
-               switch(m.param.pword[0])
-               { 
-                case INT_CLOSE_INSTANCE: endrun(0);
-                case INT_KILL: endrun(1);                     
-                default:break;     
-               } /* switch int */
-    case MSG_NET: 
-            if (m.param.pword[0] == NET_PROPAGATE)
-            {
-             /*printf("DEBUG: cint internal_sock MSG_NET NET_PROPAGATE cmd %d\n",m.param.pword[6]);*/
-             memcpy(globmsgqueue+msgtail,&m.int_msg,sizeof(message));
-             msgtail = (msgtail+1) % MAXMSGQUEUE;
-             msgready++;
-            };break;           
-    
-    
-    
-  }/*switch type */
- }
- } /* FD_ISSET */
- } /* select */
-
+	FD_ZERO(&DirSet);
+	maxDirSet = 0;
+	for(i = 0; i < 255; i++)
+		if (DirConn[i]!=-1) {
+			FD_SET(DirConn[i], &DirSet);
+			if (maxDirSet<DirConn[i])
+				maxDirSet=DirConn[i];
+		}
+
+	if (select(maxDirSet + 1, &DirSet, 0, 0, (struct timeval *)&tout) > 0) {
+		for(i = 0; i < 255; i++) {
+			if ((DirConn[i] != -1) &&
+					(FD_ISSET(DirConn[i], &DirSet))) {
+				r = read(DirConn[i], &mx, sizeof(mx));
+				if (r > 0) {
+					memcpy(globmsgqueue + msgtail,&mx,
+							sizeof(message));
+					msgtail = (msgtail + 1) % MAXMSGQUEUE;
+					msgready++;
+				}
+			}
+		}
+	}
+-----------------------------------------*/
+
+	FD_ZERO(&rset);
+	FD_SET(net_sock, &rset);
+	FD_SET(internal_sock, &rset); 
+	if (net_sock > internal_sock)
+		max = net_sock;
+	else
+		max = internal_sock;
+	/* 2010 */
+	for(i = 0; i < 255; i++) {
+		if (DirConn[i] != -1) {
+			FD_SET(DirConn[i], &rset);
+			if (max < DirConn[i])
+				max = DirConn[i];
+		}
+	}
+
+	if (select(max + 1, &rset, 0, 0, (struct timeval *)&tout) > 0) {
+		/* 2010 */
+		for(i = 0; i < 255; i++) {
+			if ((DirConn[i] != -1) && (FD_ISSET(DirConn[i], &rset))) {
+				/*
+				printf("DEBUG: Interp has message on "
+					"direct connection: type %d par %d\n",
+						mx.control.type,mx.control.par);
+				*/
+				r = read(DirConn[i], &mx, sizeof(mx));
+				if (r > 0 && r == sizeof(mx)) {
+					memcpy(globmsgqueue + msgtail, &mx,
+							sizeof(message));
+					msgtail = (msgtail+1) % MAXMSGQUEUE;
+					msgready++;
+				} 
+			}
+		}
+
+		if (FD_ISSET(net_sock,&rset)) {
+			r = read(net_sock, &m, sizeof(MESSAGE));
+		
+			if (r>0) {
+				switch(m.msg_type) {
+				case MSG_NET:
+					switch(m.param.pword[0]) {
+					case NET_PROPAGATE:
+					/*
+					printf("DEBUG: cint net_sock MSG_NET "
+						"NET_PROPAGATE cmd %d\n",
+							m.param.pword[6]);*/
+						memcpy(globmsgqueue + msgtail,
+							&m.int_msg,
+							sizeof(message));
+						msgtail = (msgtail + 1) %
+								MAXMSGQUEUE;
+						msgready++;
+						break;
+					};
+					break;
+				}
+			}
+		}
+
+		if (FD_ISSET(internal_sock, &rset)) {
+			r = read(internal_sock, &m, sizeof(MESSAGE));
+
+			if (r > 0) {
+				switch(m.msg_type) {
+				case MSG_INT:
+					switch(m.param.pword[0]) {
+					case INT_CLOSE_INSTANCE:
+						endrun(0);
+					case INT_KILL:
+						endrun(1);
+					default:
+						break;
+					}
+				case MSG_NET:
+					if (m.param.pword[0] == NET_PROPAGATE) {
+						/*
+						printf("DEBUG: cint internal_sock MSG_NET NET_PROPAGATE cmd %d\n",m.param.pword[6]);*/
+						memcpy(globmsgqueue + msgtail,
+							&m.int_msg,
+							sizeof(message));
+						msgtail = (msgtail+1) %
+								MAXMSGQUEUE;
+						msgready++;
+					};
+					break;
+				}
+			}
+		}
+	}
 }
 
 
 void request_id()
 {
- MESSAGE m;
- G_MESSAGE m1; 
- 
- m.msg_type = MSG_INT;
- m.param.pword[0] = INT_CTX_REQ;
- send_to_kernel(&m);
- while ( (m.msg_type != MSG_INT) || (m.param.pword[0] != INT_CTX) )
-  read(internal_sock,&m,sizeof(MESSAGE));
-  
-    my_ctx.node = m.param.pword[1];
-    my_ctx.program_id = m.param.pword[2];
-    if (remote)
-            {
-              parent_ctx.node = m.param.pword[3];
-              parent_ctx.program_id = m.param.pword[4];
-              RInstance[parent_ctx.node] = parent_ctx.program_id;
-            }
-              else
-        {
-         parent_ctx.node = my_ctx.node;
-         parent_ctx.program_id = my_ctx.program_id;
-        } 
-  ournode = my_ctx.node;
-//  strcpy(nname,m.param.pstr);
-//  net_sock = open(nname,O_WRONLY);
-  m1.msg_type = MSG_GRAPH;
-  m1.param.pword[0] = GRAPH_SET_TITLE;
-  m1.param.pword[1] = GraphRes;
-  sprintf(m1.param.pstr,
-  "%s      ID: %d",ProgName,my_ctx.program_id);       
-  if (remote) strcat(m1.param.pstr,"  REMOTE instance");
-  send_to_graph(&m1);
+	MESSAGE m;
+	G_MESSAGE m1; 
+
+	m.msg_type = MSG_INT;
+	m.param.pword[0] = INT_CTX_REQ;
+	send_to_kernel(&m);
+	while ((m.msg_type != MSG_INT) || (m.param.pword[0] != INT_CTX))
+		read(internal_sock, &m, sizeof(MESSAGE));
+
+	my_ctx.node = m.param.pword[1];
+	my_ctx.program_id = m.param.pword[2];
+	if (remote) {
+		parent_ctx.node = m.param.pword[3];
+		parent_ctx.program_id = m.param.pword[4];
+		RInstance[parent_ctx.node] = parent_ctx.program_id;
+	} else {
+		parent_ctx.node = my_ctx.node;
+		parent_ctx.program_id = my_ctx.program_id;
+	}
+	ournode = my_ctx.node;
+	/* strcpy(nname,m.param.pstr);*/
+	/* net_sock = open(nname,O_WRONLY);*/
+	m1.msg_type = MSG_GRAPH;
+	m1.param.pword[0] = GRAPH_SET_TITLE;
+	m1.param.pword[1] = GraphRes;
+	sprintf(m1.param.pstr, "%s      ID: %d", ProgName, my_ctx.program_id);
+
+	if (remote)
+		strcat(m1.param.pstr, "  REMOTE instance");
+	send_to_graph(&m1);
 }
 
 
 
 void send_ready()
 {
- int sock,len;
- struct sockaddr_in svr;
- char name[255];
- struct hostent *info;
- 
-
- MESSAGE msg;
- msg.msg_type = MSG_NET;
- msg.param.pword[0] = NET_PROPAGATE;
- msg.param.pword[1] = MSG_VLP;
- msg.param.pword[2] = my_ctx.node;
- msg.param.pword[4] = parent_ctx.node;
- msg.param.pword[6] = VLP_REMOTE_INSTANCE_OK;
- msg.param.pword[7] = my_ctx.program_id;
- 
- sock = socket(AF_INET,SOCK_STREAM,0);
- bzero(&svr,sizeof(svr));
- svr.sin_family = AF_INET;
- svr.sin_addr.s_addr = INADDR_ANY;
- svr.sin_port = 0;
- bind(sock, (struct sockaddr*)&svr, sizeof(svr));
- listen(sock,5);
- len=sizeof(svr);
- getsockname(sock,(struct sockaddr*)&svr,&len);
- msg.param.pword[8] = ntohs(svr.sin_port);
- gethostname(name,&len);
- info = (struct hostent*)gethostbyname(name);
- bcopy((char*)info->h_addr,(char*)&svr.sin_addr,info->h_length);
- sprintf(msg.param.pstr,"%s",inet_ntoa(svr.sin_addr));
- send_to_kernel(&msg);
- 
- bzero(&svr,sizeof(svr));
- DirConn[parent_ctx.node] = accept(sock,(struct sockaddr*)&svr,&len);
- fcntl(DirConn[parent_ctx.node], F_SETFL,O_NONBLOCK | fcntl(DirConn[parent_ctx.node], F_GETFL,0));
+	int sock, len;
+	struct sockaddr_in svr;
+	char name[255];
+	struct hostent *info;
+
+	MESSAGE msg;
+	msg.msg_type = MSG_NET;
+	msg.param.pword[0] = NET_PROPAGATE;
+	msg.param.pword[1] = MSG_VLP;
+	msg.param.pword[2] = my_ctx.node;
+	msg.param.pword[4] = parent_ctx.node;
+	msg.param.pword[6] = VLP_REMOTE_INSTANCE_OK;
+	msg.param.pword[7] = my_ctx.program_id;
+
+	sock = socket(AF_INET, SOCK_STREAM, 0);
+	bzero(&svr, sizeof(svr));
+	svr.sin_family = AF_INET;
+	svr.sin_addr.s_addr = INADDR_ANY;
+	svr.sin_port = 0;
+	bind(sock, (struct sockaddr*)&svr, sizeof(svr));
+	listen(sock, 5);
+	len = sizeof(svr);
+	getsockname(sock,(struct sockaddr*)&svr, &len);
+	msg.param.pword[8] = ntohs(svr.sin_port);
+	gethostname(name, &len);
+	info = (struct hostent*)gethostbyname(name);
+	bcopy((char*)info->h_addr, (char*)&svr.sin_addr, info->h_length);
+	sprintf(msg.param.pstr, "%s", inet_ntoa(svr.sin_addr));
+	send_to_kernel(&msg);
+
+	bzero(&svr, sizeof(svr));
+	DirConn[parent_ctx.node] = accept(sock, (struct sockaddr*)&svr, &len);
+	fcntl(DirConn[parent_ctx.node], F_SETFL, O_NONBLOCK |
+				fcntl(DirConn[parent_ctx.node], F_GETFL, 0));
 }
 
-int main(argc, argv)
-int argc;
-char **argv;
+int main(int argc, char **argv)
 {
-    initiate(argc, argv);             /* initialize executor */
-    runsys();              /* initialize running system */
-    init_scheduler();
-    GraphRes = get_graph_res();
-    if ( GraphRes < 0 ) exit(12); 
-     
-    request_id();
-    if (remote) send_ready(); 
-
-
-    setjmp(contenv);         /* set label for continue long jump */
-    while (TRUE)                     /* repeat until exit() is called */
-    {
-        get_internal();        
-        schedule();         /* reschedule current process */
-   if (ready != 0)
-    {   
-        decode();               /* fetch instruction */
-        execute();            /* and execute it */
-    } 
-       
-    }
-    return 0;
-} /* end main */
+	/* initialize executor */
+	initiate(argc, argv);
+	/* initialize running system */
+	runsys();
+	init_scheduler();
+	GraphRes = get_graph_res();
+	if (GraphRes < 0)
+		exit(12);
+
+	request_id();
+	if (remote)
+		send_ready(); 
+
+	/* set label for continue long jump */
+	setjmp(contenv);
+	/* repeat until exit() is called */
+	while (TRUE) {
+		get_internal();
+		/* reschedule current process */
+		schedule();
+		if (ready != 0) {
+			/* fetch instruction */
+			decode();
+			/* and execute it */
+			execute();
+		}
+	}
+	return 0;
+}