emacs.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <strings.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/filio.h>
#include <xview/xview.h>
#include <xview/panel.h>
#include <xview/notify.h>
#include "string.h"
#include "genC.h"
#include "misc.h"
#include "linear.h"
#include "ri.h"
#include "database.h"
#include "ri-util.h"
#include "pipsdbm.h"
#include "properties.h"
#include "wpips-labels.h"
#include "wpips.h"

Include dependency graph for emacs.c:

Go to the source code of this file.

Enumerations
enum	epips_input_automaton_states { epips_wait_for_begin , epips_wait_for_end }
	At initialization, we are waiting for an input command: More...
enum	{ EPIPS_COMMAND_BUFFER_SIZE = 2000 }

Functions
static void	send_text_to_emacs (char *some_text)
	Here are described all the functions used to send informations to emacs: More...
static void	send_command_to_emacs (char *command_title, char *command_content)
	The function that frames the command to emacs: More...
void	send_module_name_to_emacs (char *some_text)
	Here are all the methods used to send an object to Emacs: More...
void	send_the_names_of_the_available_modules_to_emacs (void)
	Tell Emacs about what are the modules available in the current workspace, if any: More...
void	send_prompt_user_to_emacs (char *some_text)
void	send_user_error_to_emacs (char *some_text)
void	send_user_log_to_emacs (char *some_text)
void	send_user_warning_to_emacs (char *some_text)
void	send_view_to_emacs (char *view_name, char *the_file_name)
void	send_window_number_to_emacs (int number)
void	send_notice_prompt_to_emacs (char *first_line,...)
void	ask_emacs_to_open_a_new_daVinci_context ()
void	ask_emacs_to_display_a_graph (string file_name)
static bool	epips_select_module (char *module_name)
	Here are described all the functions used to receive informations from emacs: More...
static void	epips_execute_and_display_something (char *view_label, char *module_name)
	Emacs said to display a sequential view: More...
static void	epips_sequential_view (char *module_name)
	Emacs said to display a sequential view: More...
static void	epips_execute_command (char *command_buffer)
static void	trow_away_epips_input (char *entry_buffer, long int length)
static void	add_command_to_buffer (char *entry_buffer, unsigned long int length)
	Copy a part of the entry_buffer in the command_buffer: More...
static char *	unframe_commands_from_emacs (char *entry_buffer, long int *length)
	Try to unframe one half of command sent by emacs. More...
static Notify_value	read_commands_from_emacs (Notify_client client, int fd)
	The function that accept commands from emacs: More...
void	initialize_emacs_mode ()
	The function to initialize some things in the emacs mode: More...

Variables
bool	wpips_emacs_mode = 0
	Here are all the stuff to interface Pips with Emacs. More...
static char	EMACS_AVAILABLE_MODULES_NAME [] = "AVAILABLE_MODULES"
	The title of the commands used by the emacs interface: More...
static char	EMACS_MODULE_NAME [] = "MODULE_NAME"
static char	EMACS_PROMPT_USER [] = "PROMPT_USER"
static char	EMACS_SEQUENTIAL_VIEW [] = "Sequential View"
static char	EMACS_USER_ERROR [] = "USER_ERROR"
static char	EMACS_USER_LOG [] = "USER_LOG"
static char	EMACS_USER_WARNING [] = "USER_WARNING"
static char	EMACS_WINDOW_NUMBER [] = "WINDOW_NUMBER"
static char	EMACS_NEW_DAVINCI_CONTEXT [] = "NEW_DAVINCI_CONTEXT"
static char	EMACS_VIEW_DAVINCI_GRAPH [] = "VIEW_DAVINCI_GRAPH"
static char	epips_begin_of_command_token [] = "\200"
	The token to mark the begin and end of command. More...
static char	epips_end_of_command_token [] = "\201"
static char	epips_receive_begin_of_command_token [] = "\202"
static char	epips_receive_end_of_command_token [] = "\203"
static epips_input_automaton_states	epips_input_automaton_state = epips_wait_for_begin
static char	command_buffer [EPIPS_COMMAND_BUFFER_SIZE]
static unsigned int	command_buffer_length

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
EPIPS_COMMAND_BUFFER_SIZE

Definition at line 373 of file emacs.c.

{ EPIPS_COMMAND_BUFFER_SIZE = 2000 };

epips_input_automaton_states

enum epips_input_automaton_states

At initialization, we are waiting for an input command:

Enumerator
epips_wait_for_begin
epips_wait_for_end

Definition at line 88 of file emacs.c.

{
   epips_wait_for_begin,
      epips_wait_for_end
} epips_input_automaton_states;

Function Documentation

add_command_to_buffer()

static void add_command_to_buffer ( char *  entry_buffer, unsigned long int  length  )

static

Copy a part of the entry_buffer in the command_buffer:

Definition at line 380 of file emacs.c.

{
   pips_assert("add_command_to_buffer in emacs.c: command too big !!!",
               length + command_buffer_length < sizeof(command_buffer) - 1);
   (void) memcpy(command_buffer + command_buffer_length,
                 entry_buffer,
                 length);
   command_buffer_length += length;
   command_buffer[command_buffer_length] = '\0';
}

References command_buffer, command_buffer_length, and pips_assert.

Referenced by unframe_commands_from_emacs().

Here is the caller graph for this function:

ask_emacs_to_display_a_graph()

void ask_emacs_to_display_a_graph

(

string

file_name

)

Definition at line 243 of file emacs.c.

{
    send_command_to_emacs(EMACS_VIEW_DAVINCI_GRAPH, file_name);
}

References EMACS_VIEW_DAVINCI_GRAPH, file_name, and send_command_to_emacs().

Referenced by wpips_display_graph_file_display().

Here is the call graph for this function:

Here is the caller graph for this function:

ask_emacs_to_open_a_new_daVinci_context()

void ask_emacs_to_open_a_new_daVinci_context

(

)

Definition at line 236 of file emacs.c.

{
    send_command_to_emacs(EMACS_NEW_DAVINCI_CONTEXT, "");
}

References EMACS_NEW_DAVINCI_CONTEXT, and send_command_to_emacs().

Referenced by wpips_display_graph_file_display().

Here is the call graph for this function:

Here is the caller graph for this function:

epips_execute_and_display_something()

static void epips_execute_and_display_something ( char *  view_label, char *  module_name  )

static

Emacs said to display a sequential view:

If module_name is not an empty string, we need to select this module first:

Display something only if an eventual module selection has been successful:

Definition at line 302 of file emacs.c.

{
   bool module_selection_result = TRUE;
   
   if (module_name != '\0')
      /* If module_name is not an empty string, we need to select this
         module first: */
      module_selection_result = epips_select_module(module_name);
   
   if (module_selection_result)
      /* Display something only if an eventual module selection has
         been successful: */
      wpips_execute_and_display_something_from_alias(view_label);
}

References epips_select_module(), module_name(), and wpips_execute_and_display_something_from_alias().

Referenced by epips_sequential_view().

Here is the call graph for this function:

Here is the caller graph for this function:

epips_execute_command()

static void epips_execute_command ( char *  command_buffer )

static

Separate the command name from the content with a ":" :

Now we can choose what command to execute:

Definition at line 327 of file emacs.c.

{
   char * command_name, * command_content;
   
   /* Separate the command name from the content with a ":" : */
   char * separator_index = (char *) index(command_buffer, ':');
   debug(2, "epips_execute_command", "Command: \"%s\"\n", command_buffer);
 
   if (separator_index == NULL) {
      user_warning("epips_execute_command",
                   "Cannot understand command: \"%s\"\n", command_buffer);
      return;
   }
 
   command_name = command_buffer;
   *separator_index = '\0';
   command_content = separator_index + 1;
   debug(2, "epips_execute_command",
         "command_name: \"%s\", command_content: \"%s\"\n",
         command_name,
         command_content);
 
   /* Now we can choose what command to execute: */
   if (strcmp(command_name, EMACS_MODULE_NAME) == 0)
      epips_select_module(command_content);
   else if (strcmp(command_name, EMACS_SEQUENTIAL_VIEW) == 0)
      epips_sequential_view(command_content);
   else {
      user_warning("epips_execute_command",
                 "Cannot understand command \"%s\" with argument \"%s\"\n",
                 command_name, command_content);
   }
}

References command_buffer, debug(), EMACS_MODULE_NAME, EMACS_SEQUENTIAL_VIEW, epips_select_module(), epips_sequential_view(), and user_warning.

Referenced by unframe_commands_from_emacs().

Here is the call graph for this function:

Here is the caller graph for this function:

epips_select_module()

static bool epips_select_module ( char *  module_name )

static

Here are described all the functions used to receive informations from emacs:

Emacs said to select a module:

If there is no module...

Just to be sure that the selected module exist:

args_free zeroes also its length argument...

Something went wrong.

Definition at line 255 of file emacs.c.

{
    gen_array_t modules;
    int new_module_list_length;
    int module_list_length = 0;
    int i = 0;
 
   if (db_get_current_workspace_name() == NULL) {
      user_warning("epips_select_module",
                 "No workspace selected or created yet !\n");
      return FALSE;
   }
 
   modules = db_get_module_list();
   module_list_length = gen_array_nitems(modules);
 
   if (module_list_length == 0)
   {
      /* If there is no module... */
      prompt_user("No module available in this workspace");
   }
   else {
      /* Just to be sure that the selected module exist: */
      for(i = 0; i < module_list_length; i++) {
         if (strcmp(module_name, gen_array_item(modules, i)) == 0) {
            end_select_module_notify(module_name);
            break;
         }
      }
      if (i == module_list_length)
         user_warning("epips_select_module",
                      "The module \"%s\" does not exist.\n", module_name);
   }
   /* args_free zeroes also its length argument... */
   new_module_list_length = module_list_length;
   gen_array_full_free(modules);
 
   if (module_list_length == 0 || i == module_list_length)
      /* Something went wrong. */
      return FALSE;
 
   return TRUE;
}

References db_get_current_workspace_name(), db_get_module_list(), end_select_module_notify(), gen_array_full_free(), gen_array_item(), gen_array_nitems(), module_name(), prompt_user(), and user_warning.

Referenced by epips_execute_and_display_something(), and epips_execute_command().

Here is the call graph for this function:

Here is the caller graph for this function:

epips_sequential_view()

static void epips_sequential_view ( char *  module_name )

static

Emacs said to display a sequential view:

Definition at line 320 of file emacs.c.

{
   epips_execute_and_display_something(EMACS_SEQUENTIAL_VIEW, module_name);
}

References EMACS_SEQUENTIAL_VIEW, epips_execute_and_display_something(), and module_name().

Referenced by epips_execute_command().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_emacs_mode()

void initialize_emacs_mode

(

)

The function to initialize some things in the emacs mode:

An arbitrary number to identify the notify client function:

The commands from emacs are read from stdin.

Thus, we need to register stdin in the XView event Notifier:

The user query is redirected to Emacs:

pips_request_handler = epips_user_request;

Initialize the epips.el epips-window-number variable:

Ask for Emacs prettyprinting:

Ask Pips to display the declarations from the RI to have hypertext functions on the declarations:

Since the comments of the declarations are not in the RI, pick them in the text:

Definition at line 511 of file emacs.c.

{
   if (wpips_emacs_mode) {
      /* An arbitrary number to identify the notify client function: */
      Notify_client notifier_client = (Notify_client) 1234;
      
     /* The commands from emacs are read from stdin.
 
         Thus, we need to register stdin in the XView event Notifier: */
      (void) notify_set_input_func(notifier_client,
                                   read_commands_from_emacs,
                                   fileno(stdin));
 
      /* The user query is redirected to Emacs: */
      /* pips_request_handler = epips_user_request; */
 
      /* Initialize the epips.el epips-window-number variable: */
      send_window_number_to_emacs(INITIAL_NUMBER_OF_WPIPS_WINDOWS);
      
      /* Ask for Emacs prettyprinting: */
      set_bool_property("PRETTYPRINT_ADD_EMACS_PROPERTIES", TRUE);
      /* Ask Pips to display the declarations from the RI to have
         hypertext functions on the declarations: */
      set_bool_property("PRETTYPRINT_ALL_DECLARATIONS", TRUE);
      /* Since the comments of the declarations are not in the RI,
         pick them in the text: */
      set_bool_property("PRETTYPRINT_HEADER_COMMENTS", TRUE);      
   }
}

References INITIAL_NUMBER_OF_WPIPS_WINDOWS, read_commands_from_emacs(), send_window_number_to_emacs(), set_bool_property(), and wpips_emacs_mode.

Referenced by wpips_main().

Here is the call graph for this function:

Here is the caller graph for this function:

read_commands_from_emacs()

static Notify_value read_commands_from_emacs ( Notify_client  client, int  fd  )

static

The function that accept commands from emacs:

Nasty thing. In act, if stdin happens to close (for example I debugged the stuff with wpips -emacs < a), the notifier loop on read_commands_from_emacs(). Thus, in this case, we disinterest the notifier from stdin:

We have something to read:

OK, we have read something...

Try to parse until the buffer is empty:

Do not try a blocking read:

Definition at line 459 of file emacs.c.

{
   char emacs_entry_buffer[1000];
   long int length;
 
   debug_on("EPIPS_DEBUG_LEVEL");
   
   if (ioctl(fd, FIONREAD, &length) == -1 || length == 0) {
      /* Nasty thing. In act, if stdin happens to close (for example I
         debugged the stuff with wpips -emacs < a), the notifier loop
         on read_commands_from_emacs(). Thus, in this case, we
         disinterest the notifier from stdin: */
      debug(3, "read_commands_from_emacs",
            "Detach the notifyer from stdin (length to read is %d)\n",
            length);
      (void) notify_set_input_func(client,
                                   NOTIFY_FUNC_NULL,
                                   fileno(stdin));
   }
   else {
      /* We have something to read: */
      long int read_length;
      char * entry_buffer = emacs_entry_buffer;
      do {
         read_length = read(fd,
                           emacs_entry_buffer,
                           sizeof(emacs_entry_buffer) - 1);
         if (read_length > 0) {
            long int analyze_length = read_length;
            
            /* OK, we have read something... */
            emacs_entry_buffer[length] = '\0';
            debug(9, "read_commands_from_emacs", "Read got \"%s\"\n",
                  emacs_entry_buffer);
            /* Try to parse until the buffer is empty: */
            while(*(entry_buffer
                    = unframe_commands_from_emacs(entry_buffer, &analyze_length)) != '\0')
               debug(8, "unframe_commands_from_emacs", "Return \"%s\"\n",
                  entry_buffer);
;
         }
         /* Do not try a blocking read: */
      } while (read_length > 0 && (length -= read_length) > 0);
   }
   debug_off();
   
   return NOTIFY_DONE;
}

References debug(), debug_off, debug_on, and unframe_commands_from_emacs().

Referenced by initialize_emacs_mode().

Here is the call graph for this function:

Here is the caller graph for this function:

send_command_to_emacs()

static void send_command_to_emacs ( char *  command_title, char *  command_content  )

static

The function that frames the command to emacs:

Separate the command name from the content with a ":" :

Definition at line 114 of file emacs.c.

{
   send_text_to_emacs(epips_begin_of_command_token);
   send_text_to_emacs(command_title);
   /* Separate the command name from the content with a ":" : */
   send_text_to_emacs(":");
   send_text_to_emacs(command_content);
   send_text_to_emacs(epips_end_of_command_token);
}

References epips_begin_of_command_token, epips_end_of_command_token, and send_text_to_emacs().

Referenced by ask_emacs_to_display_a_graph(), ask_emacs_to_open_a_new_daVinci_context(), send_module_name_to_emacs(), send_prompt_user_to_emacs(), send_the_names_of_the_available_modules_to_emacs(), send_user_error_to_emacs(), send_user_log_to_emacs(), send_user_warning_to_emacs(), send_view_to_emacs(), and send_window_number_to_emacs().

Here is the call graph for this function:

Here is the caller graph for this function:

send_module_name_to_emacs()

void send_module_name_to_emacs

(

char *

some_text

)

Here are all the methods used to send an object to Emacs:

Definition at line 128 of file emacs.c.

{
   send_command_to_emacs(EMACS_MODULE_NAME, some_text);
}

References EMACS_MODULE_NAME, and send_command_to_emacs().

Referenced by wpips_file_view().

Here is the call graph for this function:

Here is the caller graph for this function:

send_notice_prompt_to_emacs()

void send_notice_prompt_to_emacs	(	char *	first_line,
			...
	)

Definition at line 220 of file emacs.c.

{
   va_list ap;
   char * prompt_string;
   
   va_start(ap, first_line);
 
   send_prompt_user_to_emacs(first_line);
   while((prompt_string = va_arg(ap, char *)) != NULL)
      send_prompt_user_to_emacs(prompt_string);
 
   va_end(ap);
}

References send_prompt_user_to_emacs().

Referenced by continue_create_workspace_notify(), end_delete_workspace_notify(), and quit_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

send_prompt_user_to_emacs()

void send_prompt_user_to_emacs

(

char *

some_text

)

Definition at line 164 of file emacs.c.

{
   send_command_to_emacs(EMACS_PROMPT_USER, some_text);
}

References EMACS_PROMPT_USER, and send_command_to_emacs().

Referenced by prompt_user(), and send_notice_prompt_to_emacs().

Here is the call graph for this function:

Here is the caller graph for this function:

send_text_to_emacs()

static void send_text_to_emacs ( char *  some_text )

static

Here are described all the functions used to send informations to emacs:

Just send some raw text to emacs:

Definition at line 105 of file emacs.c.

{
   (void) printf("%s", some_text);
   fflush(stdout);
}

References printf().

Referenced by send_command_to_emacs().

Here is the call graph for this function:

Here is the caller graph for this function:

send_the_names_of_the_available_modules_to_emacs()

void send_the_names_of_the_available_modules_to_emacs

(

void

)

Tell Emacs about what are the modules available in the current workspace, if any:

Definition at line 137 of file emacs.c.

{
    if (wpips_emacs_mode) {
        char * module_string_list_string = strdup("(");
   
        if (db_get_current_workspace_name() != NULL) {
            gen_array_t modules = db_get_module_list();
            int module_list_length = gen_array_nitems(modules), i;
            for(i = 0; i < module_list_length; i++) {
                char * new_module_string_list_string =
                    strdup(concatenate(module_string_list_string,
                                       "\"", gen_array_item(modules, i), "\" ",
                                       NULL));
                free(module_string_list_string);
                module_string_list_string = new_module_string_list_string;
            }
            gen_array_full_free(modules);
        }
        send_command_to_emacs(EMACS_AVAILABLE_MODULES_NAME,
                              concatenate(module_string_list_string,
                                         ")", NULL));
        free(module_string_list_string);
    }
}

References concatenate(), db_get_current_workspace_name(), db_get_module_list(), EMACS_AVAILABLE_MODULES_NAME, free(), gen_array_full_free(), gen_array_item(), gen_array_nitems(), send_command_to_emacs(), strdup(), and wpips_emacs_mode.

Referenced by close_workspace_notify(), end_create_workspace_notify(), end_open_workspace_notify(), execute_safe_apply_outside_the_notifyer(), and execute_wpips_execute_and_display_something_outside_the_notifyer().

Here is the call graph for this function:

Here is the caller graph for this function:

send_user_error_to_emacs()

void send_user_error_to_emacs

(

char *

some_text

)

Definition at line 171 of file emacs.c.

{
   send_command_to_emacs(EMACS_USER_ERROR, some_text);
}

References EMACS_USER_ERROR, and send_command_to_emacs().

Referenced by wpips_user_error_message().

Here is the call graph for this function:

Here is the caller graph for this function:

send_user_log_to_emacs()

void send_user_log_to_emacs

(

char *

some_text

)

Definition at line 178 of file emacs.c.

{
   send_command_to_emacs(EMACS_USER_LOG, some_text);
}

References EMACS_USER_LOG, and send_command_to_emacs().

Referenced by wpips_user_log().

Here is the call graph for this function:

Here is the caller graph for this function:

send_user_warning_to_emacs()

void send_user_warning_to_emacs

(

char *

some_text

)

Definition at line 185 of file emacs.c.

{
   send_command_to_emacs(EMACS_USER_WARNING, some_text);
}

References EMACS_USER_WARNING, and send_command_to_emacs().

Referenced by wpips_user_warning_message().

Here is the call graph for this function:

Here is the caller graph for this function:

send_view_to_emacs()

void send_view_to_emacs	(	char *	view_name,
		char *	the_file_name
	)

Send a complete file path since the current directory in Emacs is no the same a priori:

Definition at line 192 of file emacs.c.

{
   unsigned int number_of_characters_written;
   char full_path[1000];
   
   /* Send a complete file path since the current directory in Emacs
      is no the same a priori: */
   (void) sprintf(full_path, "%s/%s%n", get_cwd(), the_file_name,
                  &number_of_characters_written);
   pips_assert("send_view_to_emacs",
               number_of_characters_written < sizeof(full_path));
   
   send_command_to_emacs(view_name, full_path);
}

References get_cwd(), pips_assert, and send_command_to_emacs().

Referenced by wpips_file_view().

Here is the call graph for this function:

Here is the caller graph for this function:

send_window_number_to_emacs()

void send_window_number_to_emacs

(

int

number

)

Definition at line 209 of file emacs.c.

{
   char a_string[10];
 
   (void) sprintf(a_string, "%d", number);
   send_command_to_emacs(EMACS_WINDOW_NUMBER, a_string);
}

References a_string, EMACS_WINDOW_NUMBER, and send_command_to_emacs().

Referenced by initialize_emacs_mode(), and window_number_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

trow_away_epips_input()

static void trow_away_epips_input ( char *  entry_buffer, long int  length  )

static

By default, send what we do not understand to stderr:

I can't remember how to give an argument to %...c ...

Definition at line 363 of file emacs.c.

{
   if (length > 0) {
      /* By default, send what we do not understand to stderr: */
      /* I can't remember how to give an argument to %...c ...*/
      (void) write(fileno(stderr), entry_buffer, length);
   }
}

Referenced by unframe_commands_from_emacs().

Here is the caller graph for this function:

unframe_commands_from_emacs()

static char* unframe_commands_from_emacs ( char *  entry_buffer, long int *  length  )

static

Try to unframe one half of command sent by emacs.

Thus needs an iterator outside.

Wait for a begin of command:

No begin of command:

Return an empty string:

Discard the begin of buffer:

Now we wait for an end of command:

Empty the command buffer:

Skip the begin token:

Look for an end of command:

No end of packet found yet. Add the content to the command buffer and keep waiting:

Go in the wait for begin state:

Skip the end token:

Definition at line 396 of file emacs.c.

{
   if (epips_input_automaton_state == epips_wait_for_begin) {
      /* Wait for a begin of command: */
      char * epips_packet_begin_position = 
          (char*) index(entry_buffer,
                        epips_receive_begin_of_command_token[0]);
      debug(8, "unframe_commands_from_emacs",
            "epips_packet_begin_position = %8X\n", epips_packet_begin_position);
      if (epips_packet_begin_position == NULL) {
         /* No begin of command: */
         trow_away_epips_input(entry_buffer, *length);
         /* Return an empty string: */
         entry_buffer += *length;
         *length = 0;
         return entry_buffer;
      }
      else {
         /* Discard the begin of buffer: */
         trow_away_epips_input(entry_buffer,
                               epips_packet_begin_position - entry_buffer);
         /* Now we wait for an end of command: */
         epips_input_automaton_state = epips_wait_for_end;
         /* Empty the command buffer: */
         command_buffer_length = 0;
         /* Skip the begin token: */
         *length -= epips_packet_begin_position + 1 - entry_buffer;
         return epips_packet_begin_position + 1;
      }
   }
   else {
      /* Look for an end of command: */
      char * epips_packet_end_position = 
          (char*) index(entry_buffer,
                        epips_receive_end_of_command_token[0]);
      debug(8, "unframe_commands_from_emacs",
            "epips_packet_end_position = %8X\n", epips_packet_end_position);
      if (epips_packet_end_position == NULL) {
         /* No end of packet found yet. Add the content to the command
            buffer and keep waiting: */
         add_command_to_buffer(entry_buffer,
                               *length);
         entry_buffer += *length;
         *length = 0;
         return entry_buffer;
      }
      else {
         add_command_to_buffer(entry_buffer,
                               epips_packet_end_position - entry_buffer);
         epips_execute_command(command_buffer);
         /* Go in the wait for begin state: */
         epips_input_automaton_state = epips_wait_for_begin;
         /* Skip the end token: */
         *length -= epips_packet_end_position + 1 - entry_buffer;
         return epips_packet_end_position + 1;
      }
      
   }     
}

References add_command_to_buffer(), command_buffer, command_buffer_length, debug(), epips_execute_command(), epips_input_automaton_state, epips_receive_begin_of_command_token, epips_receive_end_of_command_token, epips_wait_for_begin, epips_wait_for_end, and trow_away_epips_input().

Referenced by read_commands_from_emacs().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

command_buffer

char command_buffer[EPIPS_COMMAND_BUFFER_SIZE]

static

Definition at line 374 of file emacs.c.

Referenced by add_command_to_buffer(), epips_execute_command(), and unframe_commands_from_emacs().

command_buffer_length

unsigned int command_buffer_length

static

Definition at line 375 of file emacs.c.

Referenced by add_command_to_buffer(), and unframe_commands_from_emacs().

EMACS_AVAILABLE_MODULES_NAME

char EMACS_AVAILABLE_MODULES_NAME[] = "AVAILABLE_MODULES"

static

The title of the commands used by the emacs interface:

Definition at line 69 of file emacs.c.

Referenced by send_the_names_of_the_available_modules_to_emacs().

EMACS_MODULE_NAME

char EMACS_MODULE_NAME[] = "MODULE_NAME"

static

Definition at line 70 of file emacs.c.

Referenced by epips_execute_command(), and send_module_name_to_emacs().

EMACS_NEW_DAVINCI_CONTEXT

char EMACS_NEW_DAVINCI_CONTEXT[] = "NEW_DAVINCI_CONTEXT"

static

Definition at line 77 of file emacs.c.

Referenced by ask_emacs_to_open_a_new_daVinci_context().

EMACS_PROMPT_USER

char EMACS_PROMPT_USER[] = "PROMPT_USER"

static

Definition at line 71 of file emacs.c.

Referenced by send_prompt_user_to_emacs().

EMACS_SEQUENTIAL_VIEW

char EMACS_SEQUENTIAL_VIEW[] = "Sequential View"

static

Definition at line 72 of file emacs.c.

Referenced by epips_execute_command(), and epips_sequential_view().

EMACS_USER_ERROR

char EMACS_USER_ERROR[] = "USER_ERROR"

static

Definition at line 73 of file emacs.c.

Referenced by send_user_error_to_emacs().

EMACS_USER_LOG

char EMACS_USER_LOG[] = "USER_LOG"

static

Definition at line 74 of file emacs.c.

Referenced by send_user_log_to_emacs().

EMACS_USER_WARNING

char EMACS_USER_WARNING[] = "USER_WARNING"

static

Definition at line 75 of file emacs.c.

Referenced by send_user_warning_to_emacs().

EMACS_VIEW_DAVINCI_GRAPH

char EMACS_VIEW_DAVINCI_GRAPH[] = "VIEW_DAVINCI_GRAPH"

static

Definition at line 78 of file emacs.c.

Referenced by ask_emacs_to_display_a_graph().

EMACS_WINDOW_NUMBER

char EMACS_WINDOW_NUMBER[] = "WINDOW_NUMBER"

static

Definition at line 76 of file emacs.c.

Referenced by send_window_number_to_emacs().

epips_begin_of_command_token

char epips_begin_of_command_token[] = "\200"

static

The token to mark the begin and end of command.

Use some strings to be usually never used in ISO-8859-1:

Definition at line 82 of file emacs.c.

Referenced by send_command_to_emacs().

epips_end_of_command_token

char epips_end_of_command_token[] = "\201"

static

Definition at line 83 of file emacs.c.

Referenced by send_command_to_emacs().

epips_input_automaton_state

epips_input_automaton_states epips_input_automaton_state = epips_wait_for_begin

static

Definition at line 95 of file emacs.c.

Referenced by unframe_commands_from_emacs().

epips_receive_begin_of_command_token

char epips_receive_begin_of_command_token[] = "\202"

static

Definition at line 84 of file emacs.c.

Referenced by unframe_commands_from_emacs().

epips_receive_end_of_command_token

char epips_receive_end_of_command_token[] = "\203"

static

Definition at line 85 of file emacs.c.

Referenced by unframe_commands_from_emacs().

wpips_emacs_mode

bool wpips_emacs_mode = 0

Here are all the stuff to interface Pips with Emacs.

This variable is used to indicate wether wpips is in the Emacs mode:

Ronan.nosp@m..Ker.nosp@m.yell@.nosp@m.cri..nosp@m.ensmp.nosp@m..fr, 23/05/1995. Include the label names: This variable is used to indicate wether wpips is in the Emacs mode: By default, wpips is not called from emacs. RK.

Definition at line 65 of file emacs.c.

Referenced by continue_create_workspace_notify(), create_edit_menu(), create_log_menu(), edit_close_notify(), edit_notify(), end_delete_workspace_notify(), initialize_emacs_mode(), notify_hpfc_file_view(), prompt_user(), quit_notify(), send_the_names_of_the_available_modules_to_emacs(), window_number_notify(), wpips_display_graph_file_display(), wpips_file_view(), wpips_main(), wpips_parse_arguments(), wpips_user_error_message(), wpips_user_log(), wpips_user_warning_message(), and wpips_view_marked_busy().