src/terminal_interface.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : terminal_interface.cpp
* DESCRIPTION: Mathemagix input, output and completion for ascii terminals
* COPYRIGHT  : (C) 2010  Gregoire Lecerf
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#include <basix/system.hpp>
#include <basix/string.hpp>
#include <basix/list.hpp>
#include <basix/table.hpp>
#include <basix/math_syntax.hpp>
#include <basix/parse_tools.hpp>
#include <basix/basix-config.hpp>

#ifdef BASIX_HAVE_UNISTD_H
#include <unistd.h>
#endif

#ifdef BASIX_HAVE_READLINE
#  if defined(BASIX_HAVE_READLINE_READLINE_H)
#    include <readline/readline.h>
#  else
#    include <readline.h>
#  endif
#  if defined(BASIX_HAVE_READLINE_HISTORY_H)
#    include <readline/history.h>
#  else
#    include <history.h>
#  endif
#endif

namespace mmx {
#define DATA_BEGIN   ((char) 2)
#define DATA_END     ((char) 5)

/******************************************************************************
* Global variables
******************************************************************************/

bool script_mode = false;
bool quiet_mode = false;
bool debug_mode = false;
bool type_mode = false;
bool time_mode = false;
nat  history_size = 100;
  
bool completion_mode = true;
bool batch_mode = false;

/******************************************************************************
* Determine batch mode
******************************************************************************/

void
batch_mode_initialize () {
  batch_mode = !isatty(STDIN_FILENO) && !texmacs_mode;
}

/******************************************************************************
* Read line and manage history
******************************************************************************/

#ifdef BASIX_HAVE_READLINE

static bool
read_line (string prompt, string& sline) {
  char* line;
  string buf = "";
  port p = formatting_port (output_string_port (buf));
  p << charcode_as_string (RL_PROMPT_START_IGNORE)
    << bold << blue_foreground
    << charcode_as_string (RL_PROMPT_END_IGNORE)
    << prompt
    << charcode_as_string (RL_PROMPT_START_IGNORE)
    << reset_attributes
    << cyan_foreground
    << charcode_as_string (RL_PROMPT_END_IGNORE);
  char* _prompt = as_charp (buf);
  line = readline (_prompt);
  free_charp (_prompt);
  mmout << reset_attributes << flush_now;
  if (line == NULL) {
    sline = "";
    return false;
  }
  sline = string(line);
  free (line);
  return true;
}

void
shell_save_history () {
  string dir= user_dir ();
  if (dir == "") return;
  string file_name = dir * "/var/history";
  char* _f = as_charp (file_name);
  write_history (_f);
  history_truncate_file (_f, history_size);
  free_charp (_f);
}
  
void
shell_load_history () {
  string dir = user_dir ();
  if (dir == "") return;
  string file_name = dir * "/var/history";
  char* _f = as_charp (file_name);
  history_truncate_file (_f, history_size);
  read_history (_f);
  free_charp (_f);
}

#else

static bool
raw_read_line (string& line) {
  char c;
  line = "";
  while (busy (mmin)) {
    mmin >> c;
    if (c == '\n' || c == '\r')
      return true;
    line << c;
  }
  return false;
}

static bool
shell_read_line (string prompt, string& line) {
  mmout << bold << blue_foreground << prompt << reset_attributes << flush_now;
  mmout << cyan_foreground << flush_now;
  bool r= raw_read_line (line);
  mmout << reset_attributes << flush_now;
  return r;
}

void
shell_save_history () {}
  
void
shell_load_history () {}
  
#endif // BASIX_HAVE_READLINE

void
shell_save_session (void) {
  nat i;
  string dir = user_dir ();
  string contents = "";
  char z = 0;
  if (dir == "") return;
  string file_name = dir * "/var/session";
  for (i = 0; i < get_interactive_number (); ++i) {
    contents << get_interactive_source (i);
    contents << z << "\n";
  }
  save (file_name, contents);
}
  
vector<string>
shell_load_session (void) {
  string dir = user_dir ();
  string file_name = dir * "/var/session";
  string data;
  load (file_name, data);
  store_interactive_number (0);
  string sep= "\n\n"; sep[0]= '\0';
  vector<string> inputs= tokenize (data, sep);
  vector<string> v;
  for (nat i=0; i<N(inputs); i++) {
    v << tokenize (inputs[i], "\n", true);
    store_interactive_source (inputs[i]);
  }
  return inputs;
}
  
  /*
   * Completion for Readline mode
   */

#ifdef BASIX_HAVE_READLINE

// Keywords for completion
list<string> identifiers_for_completion = 
  list<string> ("case", "continue", "else", "error") *
  list<string> ("exists", "for", "generate", "in") *
  list<string> ("operator", "postfix", "prefix", "step") *
  list<string> ("then", "until", "while", "help");

table<generic,generic> strings_for_completion;

static char*
duplicate (char *s) {
  // strdup does not work on some platforms.
  char* r= (char*) malloc (strlen (s) + 1);
  strcpy (r, s);
  return r;
}

/* Generator function for command completion. STATE lets us know whether
   to start from scratch; without any state (i.e. STATE == 0), then we
   start at the top of the list. */
static char *
completion_generator (const char* text, int state) {
  static nat text_len;
  static list<string> current_list;
  iterator<string> iter;
  string name;
  char *tmp, *copiedname;
  /* If this is a new word to complete, initialize now.  This includes
     saving the length of TEXT for efficiency, and initializing the index
     variable to 0. */
  if (!state) {
    rl_special_prefixes = "$";
    current_list = identifiers_for_completion
      * as<list<string> > (list<generic> (entries (strings_for_completion)));
    text_len = strlen (text);
  }
  
  /* Return the next name which partially matches from the command list. */
  while (!is_nil(current_list)) {
    name = car (current_list);
    current_list = cdr (current_list);
    tmp = as_charp (name);
    if (strncmp (tmp, text, text_len) == 0) {
      // Alloc memory for copiedname with malloc
      copiedname = duplicate (tmp);
      free_charp (tmp);
      // Readline frees the strings when it has finished with them.
      return copiedname;
    }
    else { // Completion of members of a class, such as z.re
      int dot;
      for (dot= text_len-1; dot>=0 && text[dot] != '.'; dot--);
      if (dot >= 0 && strncmp (text + dot, tmp, text_len - dot) == 0) {
        char* r= (char*) malloc (dot + strlen (tmp) + 1);
        strncpy (r, text, dot);
        strcpy  (r + dot, tmp);
        free_charp (tmp);
        return r;
      }
      else free_charp (tmp);
    }
  }

  /* If no names matched, then return NULL. */
  return ((char *)NULL);
}

/* Attempt to complete on the contents of TEXT.  START and END bound
   the region of rl_line_buffer that contains the word to complete.
   TEXT is the word to complete. We can use the entire contents of
   rl_line_buffer in case we want to do some simple parsing.  Return
   the vector of matches, or NULL if there aren't any. */
static char **
complete (const char *text, int start, int end) {
  char **matches;

#if defined(RL_VERSION_MAJOR) && RL_VERSION_MAJOR >= 4
  rl_completion_append_character = '\0';
#endif
  matches = (char **)NULL;
  matches = rl_completion_matches(text, completion_generator);
  return (matches);
}
#endif // BASIX_HAVE_READLINE

  /*
   * Read input
   */

#ifdef BASIX_HAVE_READLINE

static bool fed;
  
static int
passive_newline(int a, int b) {
  (void) a;
  (void) b;
  rl_crlf ();
  rl_on_new_line ();
  fed = false;
  rl_done = 1;
  return 0;
}

static int
active_newline(int a, int b) {
  (void) a;
  (void) b;
  rl_crlf ();
  rl_on_new_line ();
  fed = true;
  rl_done = 1;
  return 0;
}

#endif // BASIX_HAVE_READLINE

#ifdef BASIX_HAVE_READLINE

bool
shell_terminal_input (string& buffer) {
  string prompt, promptc;
  string s;
  bool b;
  nat i, size;
  vector<string> v;
  char* tmp;
  buffer = "";
  fed = false;
  size = 0;

  HIST_ENTRY* last_entry;
  HISTORY_STATE* history = history_get_history_state ();

  if (quiet_mode) {
    prompt = "";
    promptc= "";
  }
  else {
    string next= as_string (get_interactive_number () + 1);
    prompt = next * "] ";
    promptc = "";
    for (i=0; i < N(next); i++)
      promptc << " ";
    promptc << "] ";
  }

  // entering interactive input
  while (true) {
    if (completion_mode)
      rl_attempted_completion_function = complete;
    rl_bind_key (RETURN, active_newline);
    rl_bind_key (META(RETURN), passive_newline);

    b = read_line (prompt, s);
    v << s;
    size += N(s);
    buffer << s << "\n";
    if (N(s) > 0) {
      tmp = as_charp(s);
      if (history->length == 0)
        last_entry = NULL;
      else
        last_entry = history -> entries[history->length-1];
      if ((last_entry == NULL) ||
          ((last_entry != NULL) && (strcmp (tmp, last_entry->line) != 0))) {
        add_history (tmp);
        shell_save_history ();
        shell_save_session ();
      }
      free_charp (tmp);
    }
    if (fed || !b) {
      if (size > 0)
        store_interactive_source (recompose (v, "\n"));
      else
        buffer = "";
      shell_save_history ();
      shell_save_session ();
      return b;
    }
    prompt = promptc;
  }
}

#else

bool
shell_terminal_input (string& buffer) {
  vector<string> v;
  string prompt;
  bool b;
  buffer = "";

  // entering interactive input
  if (quiet_mode)
    prompt = "";
  else
    prompt = as_string (get_interactive_number () + 1) * "] ";
  b = shell_read_line (prompt, buffer);
  if (N(buffer) != 0) {
    v << buffer;
    store_interactive_source (recompose (v, "\n"));
    buffer << "\n";
  }
  return b;
}
#endif // BASIX_HAVE_READLINE

} // namespace mmx

---