#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:

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 259 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().

Referenced by send_graph_to_daVinci().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

main ( void )

Definition at line 280 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());
  
     safe_system("sleep 100");
     exit(0);
 }

References exit, printf(), read_answer_from_daVinci(), safe_system(), 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 162 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 116 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 60 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 147 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 268 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().

Referenced by main().

Here is the call graph for this function:

Here is the caller 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 199 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();
 }