View difference between Paste ID: wmKzYFL8 and mfmhuLcb

 #include <ncurses.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <signal.h>
 #include <string.h>
 #include <sys/wait.h>
 
-#define MAX_PROCESS_NUMBER 100
+#define MAX_PROCESS_NUMBER 10
 
 void printString();
-void make_string(int num);
+void setQuitFlag(int);
-void quit(int sig);
+void setPrintingFlag(int);
-void chgFlag(int);
+void bindSignals();
 void init();
 void child();
-int num = 0;
+int waitForChild(pid_t);
-char string[MAX_PROCESS_NUMBER][200];
+void onQuit(pid_t*);
-int allowPrint = 1, killflag=0;
+int analyzePid(pid_t);
 int addChildProcess(pid_t*);
 void removeChildProcess(pid_t*);
 /*
  * Global variables
-    endProcessSignal.sa_handler = quit;
+ */
 struct sigaction  endProcessSignal, printingSignal;
-    printingSignal.sa_handler = chgFlag;
+int numberOfProcesses = 0;
 char textStrings[MAX_PROCESS_NUMBER][50] = {
         "<00>",
         "<11>",
         "<22>",
         "<33>",
         "<44>",
         "<55>",
         "<66>",
         "<77>",
         "<88>",
         "<99>"};
 
 int allowPrint = 1,
-    allowPrint;
+    quitFlag = 0;
-    int pos; // extract pos changing to separate func ?
+
-    pos = getpid();
+
-    make_string(num);
+
-    pos -= parentPid; // position in list ?
+
-    if(pos > num){
+
-        pos = num;
+
-    }
+	pid_t   childPids[MAX_PROCESS_NUMBER];
-    while(!killflag)
+	int     currentProcessIndex = 0;
 	while(1)
 	{
 		fflush(stdin);
 		char s = getchar();
 
-            kill(getppid(), SIGUSR2); // send sigusr2 to parent ?
+
 		{
 		case 'q':
             onQuit(childPids);
 		  	exit(EXIT_SUCCESS);
 			break;
 		case '+':
             addChildProcess(childPids);
 			break;
 		case '-':
             removeChildProcess(childPids);
 			break;
         default:
             break;
 		}
 
         if( allowPrint && numberOfProcesses)
         {
-    for(int i = 0; i < num; i++ )
+            currentProcessIndex = currentProcessIndex >= numberOfProcesses ? 0 : currentProcessIndex;
             kill(childPids[currentProcessIndex], SIGUSR2);
             allowPrint = 0;
             currentProcessIndex++;
         }
 	}
 	clear();
 	endwin();
 	exit(EXIT_SUCCESS);
 }
 
 void removeChildProcess(pid_t* childPids)
-	pid_t childPids[MAX_PROCESS_NUMBER], tpid;
+
-	int currentProcessIndex = 0;
+    if( numberOfProcesses )
-	char s;
+
         kill(childPids[numberOfProcesses-1], SIGUSR1);
         waitForChild(childPids[numberOfProcesses-1]);
         --numberOfProcesses;
-		s = getchar();
+
 }
 
 int addChildProcess(pid_t* childPids)
 {
     if ( MAX_PROCESS_NUMBER == numberOfProcesses )
     {
         return 1;
     }
     pid_t pid = fork();
     if (analyzePid(pid))
-            tpid = fork();
+
-
+        return 1;
-			switch(tpid)
+    }
-			{
+    allowPrint = numberOfProcesses ? allowPrint : 1;
-			case 0:
+    ++numberOfProcesses;
-			    child();
+    childPids[numberOfProcesses-1] = pid;
-			    exit(EXIT_SUCCESS);
+    usleep(10);     // wait for sigaction binding in child process
-			    break;
+    return 0;
 }
-			case -1:
+
-				printw("Error!\n");
+int analyzePid(pid_t pid)
-				break;
+
-
+    if ( !pid )
-			default:
+
-                //  In parent process
+        child();
-				allowPrint = num ? allowPrint : 1;
+        exit(EXIT_SUCCESS);
-                ++num;
+
-                childPids[num-1] = tpid;
+    if ( pid == -1) // ERROR
-                usleep(10); // wait for sigaction binding in child process
+
-				break;
+        printw("Error!\n");
-			}
+        refresh();
         return 1;
     }
-			if( num )
+    return 0;
-			{
+
-				kill(childPids[num-1], SIGUSR1);
+
-                waitForChild(childPids[num-1]);
+int getPosition()
-				--num;
+
-			}
+    int pos = getpid();
     pos -= parentPid;
     return pos > numberOfProcesses ? numberOfProcesses : pos;
 }
 
 void printString()
-        if( allowPrint && num)
+
 	int position = getPosition();
-            currentProcessIndex = currentProcessIndex >= num ? 0 : currentProcessIndex;
+	for(int i = 0; i < strlen(textStrings[position]); i++)
 	{
 		printw("%c", textStrings[position][i]);
 		refresh();
 		usleep(100000);
 	}
 }
 
 void setQuitFlag(int arg)
 {
 	quitFlag = 1;
 }
 
-
+void setPrintingFlag(int arg)
-	int pos = getpid();
+
-	char c = 13;
+
 }
-	pos -= parentPid;
+
-	if(pos > num){
+
-		pos = num;
+
     endProcessSignal.sa_handler = setQuitFlag;
     sigaction(SIGUSR1,&endProcessSignal,NULL);
-	for(int i = 0; i < strlen(string[pos]); i++)
+    printingSignal.sa_handler = setPrintingFlag;
     sigaction(SIGUSR2,&printingSignal,NULL);
-		printw("%c", string[pos][i]);
+
 
 void init()
 {
     initscr();
     curs_set(0);
-void make_string(int num)
+
-{
+
-	int pos=getpid()-parentPid;
+
-	int m=getpid();
+
 
-	if(pos>num)
+
-		pos=num;
+
-	char c =  '0' + num;
+    allowPrint = 0;
-    for (int i = 0; i < 10; ++i)
+    int position = getPosition();
     while(!quitFlag)
-        string[pos][i] = c;
+
         if(allowPrint)
         {
             printString();
-void quit(int sig)
+
             kill(getppid(), SIGUSR2);
-	killflag = 1;
+
     }
 }
-void chgFlag(int a)
+
 int waitForChild(pid_t childPid)
 {
     pid_t w;
     int status;
     do
     {
         w = waitpid(childPid, &status, WUNTRACED | WCONTINUED);
     }while(!WIFEXITED(status) && !WIFSIGNALED(status));
     return status;
 }
 /*
  * Ends child processes.
  */
 void onQuit(pid_t* pidArray)
 {
     for(int i = 0; i < numberOfProcesses; i++ )
     {
         kill(pidArray[i], SIGUSR1);
         waitForChild(pidArray[i]);
     }
     clear();
     endwin();
 }