/Users/magix/mmx/mmxlight/src/texmacs.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : texmacs.cpp
* DESCRIPTION: mathemagix texmacs interface
* COPYRIGHT  : (C) 2007  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 <mmxlight/base_evaluator.hpp>
#include <mmxlight/shell.hpp>
#include <basix/math_syntax.hpp>
#include <basix/list.hpp>
#include <basix/dynamic.hpp>

namespace mmx {

#define DATA_BEGIN   ((char) 2)
#define DATA_END     ((char) 5)
#define DATA_ESCAPE  ((char) 27)
#define DATA_COMMAND '\20'

// Completion

static void
output_completion (const string& text, const list<string>& matches2) {
  list<string> matches= matches2;
  mmout << DATA_BEGIN << "scheme:(tuple ";
  mmout << '\"' << text << '\"';
  while (!is_nil (matches)) {
    if (N (car (matches)) >0)
      mmout << " \"" << car (matches) << '\"';
    matches = cdr (matches);
  }
  mmout << ')';
  mmout << DATA_END << flush_now;
}

static void
complete (const string& text) {
  list<string> matches, tomatch;
  string name;
  tomatch = identifiers_for_completion 
    * strings_for_completion (get_environment (current_ev));
  while (!is_nil (tomatch)) {
    name = car (tomatch);
    tomatch = cdr (tomatch);
    if (starts (name, text))
      matches = cons (name (N(text), N(name)), matches);
  }
  output_completion (text, matches);
}

/*
 * texmacs request parser
 */

static bool
parse_char (const string& text, char c, nat& pos) {
  if ((pos >= N(text)) || (text[pos]!=c)) return false;
  ++pos;
  return true;
}

static bool
parse_blanks (const string& text, nat& pos) {
  nat beg= pos;
  while (pos < N(text) &&
         (text[pos] == ' ' || text[pos] == '\t' || text[pos] == '\n'))
    ++pos;
  return (pos > beg);
}

static bool
parse_nat (const string& text, nat& pos, nat& out) {
  nat beg= pos;
  while (pos < N(text) && text[pos] >= '0' && text[pos] <= '9')
    ++pos;
  out= as_int (text (beg, pos));
  return (pos > beg);
}

static bool
parse_identifier (const string& text, const string& id, nat& pos) {
  nat beg = pos;
  for(nat j=0; j < N(id); pos++,j++)
    if ((pos >= N(text)) || (text[pos]!=id[j])) {
      pos = beg;
      return false;
    }
  return true;
}

static bool
parse_string (const string& text, nat& pos, string& out) {
  bool esc= false;
  nat i= pos;
  if (!parse_char(text, '\"', i)) return false;
  while ((i < N(text)) && (esc || text[i]!='\"')) {
    esc = (!esc) && (text[i]=='\\');
    ++i;
  }
  out = text(pos+1,i);
  if (!parse_char(text,'\"',i)) return false;
  pos = i;
  return true;
}

static bool
parse_completion_request (const string& text, nat& pos, string& s, nat& p) {
  nat i=pos;
  if (!parse_char(text, '(', i)) return false;
  parse_blanks(text, i);
  if (!parse_identifier(text, "complete", i)) return false;
  parse_blanks(text, i);
  if (!parse_string(text, i, s)) return false;
  parse_blanks(text, i);
  if (!parse_nat(text, i, p)) return false;
  parse_blanks(text, i);
  if (!parse_char(text, ')', i)) return false;
  pos = i;
  return true;
}

static void
handle_completion_request (const string& request) {
  string text;
  nat pos, i, p;
  p = 0;
  pos = 0;
  if (!parse_completion_request (request, pos, text, p)
      || p < 1 || p >= N(request)) {
    output_completion ("", list<string>());
    mmerr << "mmx warning: ignoring texmacs request" << "\n";
    return;
  }
  i=p-1;
  while (i+1 > 0 && ((text[i] >= 'a' && text[i] <= 'z')
                     || (text[i] >= 'A' && text[i] <= 'Z')
                     || text[i] == '_'))
    i--;
  complete (text (i+1, p));
}

// readline

void
shell_texmacs_initialize () {
  dynamic_event= texmacs_dynamic_event;
  mmout << DATA_BEGIN << "verbatim:";
  if (completion_mode) {
    mmout << DATA_BEGIN << "command:";
    mmout << "(plugin-configure mathemagix (:tab-completion #t))";
    mmout << DATA_END;
  }
}

bool
shell_texmacs_input (string& line) {
  static nat nr= 1;
  string next= "\"" * as_string (nr++) * "\"";
  mmout << DATA_BEGIN << "channel:prompt" << DATA_END;
  mmout << DATA_BEGIN << "scheme:(mmx-prompt " << next << ")" << DATA_END;
  mmout << texmacs_flush_commands ();
  mmout << DATA_END << flush_now;
  string in;
  string request;
  char c;
  nat discard=0;
  while (busy (mmin)) {
    mmin >> c;
    if (c==DATA_COMMAND) {
      discard++;
      continue;
    }
    if (c=='\n' && discard) {
      discard--;
      if (discard==0) {
        if (completion_mode)
          handle_completion_request(request);
        request = string("");
      }
      continue;
    }
    if (discard) {
      request << c;
      continue;
    }
    if (c=='\n' && !discard) break;
    in << c;
  }
  mmout << DATA_BEGIN << "verbatim:";
  if (N(in)==0 && c==EOF) {
    mmout << DATA_END << flush_now;
    return false;
  }
  line = recompose (tokenize (in, "/{CR}/"), "\n", true);
  store_interactive_source (line);
  return true;
}

// Output

void
shell_texmacs_output (const generic& g, const generic& t) {
  if (math_mode) {
    mmout << DATA_BEGIN << "scheme:";
    mmout << flatten_as_texmacs_scheme (g);
    mmout << DATA_END;
  }
  else
    mmout << g;
  if (exact_neq (t, "None") && exact_neq (t, "Document"))
    mmout << ": " << t;
  mmout << "\n";
}

} // namespace mmx