CODEWITHSUNDEEP
cunixprocess
Andreea Deea
Andreea Deea

Reputation: 11

Unix Processes - compile and run c program

Create a parent process that gets from the command line n arguments arg1, arg2, ... , argn. arg1 is the name to a source C, arg2 is the name of the executable file results from compile arg1, and arg3, ... , argn are arguments to start.

The parent compiles arg1 and creates the executable arg2, after that runs it into a son process.

I tried to solve the problem, using some examples, but I didn't really understand them, so the program is not working. I really need some help...

#include<unistd.h>
#include<stdio.h>
#include<sys/wait.h>
#include<string.h>

int main(int argc, char* argv[]){
   char com[200];
   int p;
   p=fork();
   strcpy(com,"gcc -o prog.c");
   strcat(com,argv[1]);

   if(p==0){
       if(WEXITSTATUS(system(com))==0)
          execl("./prog.c","./prog.c",argv[3],argv[4],argv[5],NULL);
   }

   wait(0);
   exit(0);

   return 0;
}

The C program I want to use, reads some input data from two files and stores data into another file.

Upvotes: 0

Views: 533

Answers (2)

Niklas Rosencrantz
Niklas Rosencrantz

Reputation: 26647

You should look into the manual of exec which will tell you how to run exec to fork another process that behaves according to the specification. This code can help you how to pass on variables to a child process:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> /* for fork */
#include <sys/types.h> /* for pid_t */
#include <sys/wait.h> /* for wait */

int main()
{
    /*Spawn a child to run the program.*/
    pid_t pid=fork();
    if (pid==0) { /* child process */
        static char *argv[]={"echo","Foo is my name.",NULL};
        execv("/bin/echo",argv);
        exit(127); /* only if execv fails */
    }
    else { /* pid!=0; parent process */
        waitpid(pid,0,0); /* wait for child to exit */
    }
    return 0;
}

Upvotes: 0

Jonathan Leffler
Jonathan Leffler

Reputation: 753970

This code more or less does what you say your program should do. In particular, it uses argv[2] as the program name. It uses snprintf() to avoid overflows with long arguments (but doesn't verify that it didn't overrun). It prints various status messages — partly as a debugging aid, partly to give meaning to the various parts of the program.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

int main(int argc, char* argv[])
{
    int p;

    if (argc != 6)
    {
        fprintf(stderr, "Usage: %s source program file1 file2 file3\n", argv[0]);
        return(1);
    }

    if ((p = fork()) == 0)
    {
        char com[200];
        snprintf(com, sizeof(com), "gcc -o %s %s", argv[2], argv[1]);
        if (system(com) == 0)
        {
            printf("Compilation of %s successful\n", argv[2]);
            fflush(0);
            execl(argv[2], argv[2], argv[3], argv[4], argv[5], (char *)NULL);
            fprintf(stderr, "Failed to execute %s\n", argv[2]);
            return(1);
        }
        fprintf(stderr, "Compilation of %s from %s failed\n", argv[2], argv[1]);
        return(1);
    }

    int status;

    wait(&status);
    printf("Compilation and execution of %s yielded status %d\n",
           argv[2], WEXITSTATUS(status));
    return 0;
}

When this file is named gc.c and is compiled to make gc, it can be run as:

$ ./gc gc.c ./gc2 gc.c gc.c gc.c
Compilation of ./gc2 successful
Usage: ./gc2 source program file1 file2 file3
Compilation and execution of ./gc2 yielded status 1
$

The usage message from gc2 is correct; the program expects 6 arguments, not the 4 it is given by the program.

Upvotes: 1

Related Questions