daVinci_wrapper.c File Reference

#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>
#include <signal.h>
#include <sys/wait.h>
#include <errno.h>
#include "genC.h"
#include "constants.h"
#include "misc.h"

Include dependency graph for daVinci_wrapper.c:

Go to the source code of this file.

Functions
static string	read_answer_from_daVinci ()
static void	parse_daVinci_answer ()
static void	send_command_to_daVinci (string command_format,...)
	Send a command to daVinci with an à la printf syntax: More...
static void	monitor_daVinci (int sig, int code, struct sigcontext *scp, char *addr)
void	start_daVinci_if_not_running ()
void	create_daVinci_new_context ()
void	send_graph_to_daVinci (string graph_file_name)
	main ()

Variables
pid_t	daVinci_pid = 0
	All the stuff to use the graph viewer daVinci from PIPS. More...
int	daVinci_current_context = 0
	The daVinci context control: More...
int	daVinci_next_context_to_create = 0
void(*	old_SIGCHLD_handler )() = NULL
	To process some eventual handler somewhere else: More...
FILE *	write_to_daVinci_stream
	The pipes to communicate with daVinci: More...
int	read_from_daVinci_fd

Function Documentation

create_daVinci_new_context()

void create_daVinci_new_context

(

)

Definition at line 258 of file daVinci_wrapper.c.

{
    start_daVinci_if_not_running();
    (void) printf("%s\n", read_answer_from_daVinci());
    send_command_to_daVinci("multi(open_context(\"Context_%d\"))",
                            daVinci_next_context_to_create++);
}

References daVinci_next_context_to_create, printf(), read_answer_from_daVinci(), send_command_to_daVinci(), and start_daVinci_if_not_running().

Here is the call graph for this function:

main()

main

(

void

)

Definition at line 279 of file daVinci_wrapper.c.

{
    /*
    start_daVinci_if_not_running();
    send_command_to_daVinci("multi(open_context(\"Context_1\"))");
    */
    send_graph_to_daVinci("ESSAI.pref-daVinci%");
    send_graph_to_daVinci("ESSAI.pref-daVinci");
    for (;;)
        (void) printf("%s\n", read_answer_from_daVinci());
    
    system("sleep 100");
    exit(0);
}

References exit, printf(), read_answer_from_daVinci(), and send_graph_to_daVinci().

Here is the call graph for this function:

monitor_daVinci()

static void monitor_daVinci ( int  sig, int  code, struct sigcontext *  scp, char *  addr  )

static

Not about daVinci, pass to the old handler:

If the calling process is stopped, pid = 0:

Well, daVinci is no longer here...

Restore the old handler:

Else, the process may have stopped: nothing to do.

Definition at line 161 of file daVinci_wrapper.c.

{
    pid_t pid;
    int statusp;
    
    debug_on("DAVINCI_DEBUG_LEVEL");
    pid = waitpid(daVinci_pid, &statusp, WNOHANG);
    
    pips_debug(5, "waitpid -> %d\n", pid);
 
    if (pid == -1) {
        /* Not about daVinci, pass to the old handler: */
        debug_off();
        ( * old_SIGCHLD_handler)(sig, code, scp, addr);
    }
 
    /* If the calling process is stopped, pid = 0: */
    if (pid != 0 && (statusp & 255) != 127) {
        /* Well, daVinci is no longer here... */
        pips_debug(5, "daVinci pid %d exited with status %x\n",
                   daVinci_pid, statusp);
        daVinci_pid = 0;
        /* Restore the old handler: */
        (void) signal(SIGCHLD, old_SIGCHLD_handler);
        old_SIGCHLD_handler = NULL;
    }
    else {
        /* Else, the process may have stopped: nothing to do. */
    }
    debug_off();
}

References daVinci_pid, debug_off, debug_on, old_SIGCHLD_handler, and pips_debug.

Referenced by start_daVinci_if_not_running().

Here is the caller graph for this function:

parse_daVinci_answer()

static void parse_daVinci_answer ( )

static

I love scanf-based parser... :-)

Definition at line 115 of file daVinci_wrapper.c.

{
    char * command = read_answer_from_daVinci();
    char * buffer = malloc(strlen(command));
    
    for(;;) {
        if (strcmp(command, "ok\001")) {
            pips_debug(8, "\"ok\" parsed\n");
            break;
        }
        
        /* I love scanf-based parser... :-) */
        if (sscanf(command, "context(\"Context_%d\")\001",
                   &daVinci_current_context) == 1) {
            pips_debug(8, "Current context set to %d\n",
                       daVinci_current_context);
            break;
        }
        
        if (sscanf(command, "communication_error(\"%s\")\001",
                   buffer) == 1) {
            user_warning("daVinci said...",
                         "communication_error(\"%s\")", buffer);
            break;
        }
    }
}

References buffer, daVinci_current_context, malloc(), pips_debug, read_answer_from_daVinci(), and user_warning.

Referenced by start_daVinci_if_not_running().

Here is the call graph for this function:

Here is the caller graph for this function:

read_answer_from_daVinci()

static string read_answer_from_daVinci ( )

static

Allocate some place the first time:

A "\n" is used by daVinci to end answers:

Not optimized: read characters one by one...

End of answer found:

Deal with some '\' forms in strings:

Else, '\' -> '\', '"' -> '"' without doing anything.

No more place in the command buffer:

To mark the end to ease later parsing:

Definition at line 59 of file daVinci_wrapper.c.

{
    static char * command = NULL;
    static int command_size = 0;
    int position = 0;
    bool backslash_pending_p = FALSE;
    
    debug_on("DAVINCI_DEBUG_LEVEL");
    
    if (command_size == 0) {
        /* Allocate some place the first time: */
        command_size = 10;
        command = malloc(10);
    }
    
    /* A "\n" is used by daVinci to end answers: */
    for(;;) {
        char a_character;
        /* Not optimized: read characters one by one... */
        int length = read(read_from_daVinci_fd, &a_character, 1);
        if (length == 0)
            continue;
        
        if (length == 1) {
            pips_debug(8, "Read character \"%c\" (%d)\n",
                       a_character, a_character);
            if (a_character == '\n')
                /* End of answer found: */
                break;
 
            /* Deal with some '\' forms in strings: */
            if (backslash_pending_p) {
                backslash_pending_p = FALSE;
                if (a_character == 'n')
                    a_character = '\n';
                /* Else, '\\' -> '\', '\"' -> '"' without doing
                   anything. */
            }
            if (position == command_size - 2) {
                /* No more place in the command buffer: */
                command_size *= 2;
                command = realloc(command, command_size);
            }
            command[position++] = a_character;
        }
    }
    /* To mark the end to ease later parsing: */
    command[position++] = '\001';
    command[position] = '\0';
    
    debug_off();
    return command;
}

References debug_off, debug_on, malloc(), pips_debug, and read_from_daVinci_fd.

Referenced by create_daVinci_new_context(), main(), parse_daVinci_answer(), and send_graph_to_daVinci().

Here is the call graph for this function:

Here is the caller graph for this function:

send_command_to_daVinci()

static void send_command_to_daVinci ( string  command_format,   ...  )

static

Send a command to daVinci with an à la printf syntax:

A "\n" is used by daVinci to end commands:

Definition at line 146 of file daVinci_wrapper.c.

{
    va_list some_arguments;
 
    va_start(some_arguments, command_format);
    vfprintf(write_to_daVinci_stream, command_format, some_arguments);
    va_end(some_arguments);
    
    /* A "\n" is used by daVinci to end commands: */
    fprintf(write_to_daVinci_stream, "\n");
    fflush(write_to_daVinci_stream);
}

References fprintf(), and write_to_daVinci_stream.

Referenced by create_daVinci_new_context(), and send_graph_to_daVinci().

Here is the call graph for this function:

Here is the caller graph for this function:

send_graph_to_daVinci()

void send_graph_to_daVinci

(

string

graph_file_name

)

Send the graph:

Definition at line 267 of file daVinci_wrapper.c.

{
    create_daVinci_new_context();
    (void) printf("%s\n", read_answer_from_daVinci());
    (void) printf("%s\n", read_answer_from_daVinci());
 
    /* Send the graph: */
    send_command_to_daVinci("menu(file(open_graph(\"%s\")))",
                            graph_file_name);
}

References create_daVinci_new_context(), printf(), read_answer_from_daVinci(), and send_command_to_daVinci().

Here is the call graph for this function:

start_daVinci_if_not_running()

void start_daVinci_if_not_running

(

)

It is not necessary to start another daVinci:

Create the 2 pipes to communicate with daVinci.

Hum, need some portability adjustment for SVR4...

This is the child:

Connect the PIPS pipes to stdin and stdout of daVinci:

Hum, the PIPS parent will go on...

The parent:

Install the handler to monitor daVinci:

Wait for the OK stuff.

Definition at line 198 of file daVinci_wrapper.c.

{
    int pips_output_fd[2], pips_input_fd[2];
    
    debug_on("DAVINCI_DEBUG_LEVEL");
    if (daVinci_pid != 0) {
        /* It is not necessary to start another daVinci: */
        debug_off();
        return;
    }
    
    /* Create the 2 pipes to communicate with daVinci.
 
       Hum, need some portability adjustment for SVR4... */
    if (pipe(pips_output_fd) != 0 || pipe(pips_input_fd) != 0) {
      perror("fork");
      pips_internal_error("Cannot create the 2 pipes.\n");
    }
    
    daVinci_pid = fork();
    pips_debug(5, "daVinci_pid = %d\n", daVinci_pid);
 
    if (daVinci_pid == -1) {
        perror("fork");
        pips_internal_error("Cannot fork a process.\n");
    }
    
    if (daVinci_pid == 0) {
        /* This is the child: */
        /* Connect the PIPS pipes to stdin and stdout of daVinci: */
        if (dup2(pips_output_fd[0], fileno(stdin)) == -1
            || dup2(pips_input_fd[1], fileno(stdout)) == -1) {
            perror("dup2");
            pips_internal_error("Cannot dup file descriptors.\n");
        }
        
        execlp("daVinci", "daVinci", "-pipe", NULL);
        perror("execl of daVinci");
        pips_internal_error("Cannot start the daVinci process.\n");
        /* Hum, the PIPS parent will go on... */
    }
    else {
        /* The parent: */
        write_to_daVinci_stream = fdopen(pips_output_fd[1], "w");
        if (write_to_daVinci_stream == NULL)
            pips_internal_error("Cannot fdopen pips_output_fd[1].\n");
        
        read_from_daVinci_fd = pips_input_fd[0];
 
        /* Install the handler to monitor daVinci: */
        old_SIGCHLD_handler = signal(SIGCHLD, monitor_daVinci);
 
        /* Wait for the OK stuff. */
        parse_daVinci_answer();
    }
    debug_off();
}

References daVinci_pid, debug_off, debug_on, monitor_daVinci(), old_SIGCHLD_handler, parse_daVinci_answer(), pips_debug, pips_internal_error, read_from_daVinci_fd, and write_to_daVinci_stream.

Here is the call graph for this function:

Variable Documentation

daVinci_current_context

int daVinci_current_context = 0

The daVinci context control:

Definition at line 48 of file daVinci_wrapper.c.

daVinci_next_context_to_create

int daVinci_next_context_to_create = 0

Definition at line 49 of file daVinci_wrapper.c.

daVinci_pid

pid_t daVinci_pid = 0

All the stuff to use the graph viewer daVinci from PIPS.

Ronan.nosp@m..Ker.nosp@m.yell@.nosp@m.cri..nosp@m.ensmp.nosp@m..fr To monitor if we have already running daVinci:

Definition at line 45 of file daVinci_wrapper.c.

old_SIGCHLD_handler

void( * old_SIGCHLD_handler) ()

(

)

= NULL

To process some eventual handler somewhere else:

Definition at line 52 of file daVinci_wrapper.c.

read_from_daVinci_fd

int read_from_daVinci_fd

Definition at line 56 of file daVinci_wrapper.c.

write_to_daVinci_stream

FILE* write_to_daVinci_stream

The pipes to communicate with daVinci:

Definition at line 55 of file daVinci_wrapper.c.