Maxima.h

Go to the documentation of this file.

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-
//
//  Copyright (C) 2004-2015 Andrej Vodopivec <andrej.vodopivec@gmail.com>
//            (C) 2014-2018 Gunter Königsmann <wxMaxima@physikbuch.de>
//            (C) 2020      Kuba Ober <kuba@bertec.com>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
//  SPDX-License-Identifier: GPL-2.0+
 
#ifndef WXMAXIMA_MAXIMA_H
#define WXMAXIMA_MAXIMA_H
 
#include <wx/defs.h>
#include <wx/buffer.h>
#include <wx/event.h>
#include <wx/sckstrm.h>
#include <wx/txtstrm.h>
#include <wx/socket.h>
#include <wx/string.h>
#include <wx/timer.h>
#include <memory>
#include <thread>
#include <atomic>
#include <mutex>
#include "Configuration.h"
#include "Compat.h"
 
// TEMPORARY shutdown tracing to find where wxMaxima wedges during teardown on
// the Windows CI (the hang happens after wxLog::EnableLogging(false), so it uses
// raw fprintf(stderr) rather than wxLogMessage). Silent unless the
// WXM_SHUTDOWN_TRACE environment variable is set, so it is a no-op in normal use
// on every platform. Remove once the teardown hang is fixed.
void WxmShutdownTrace(const char *where);
 
class Maxima : public wxEvtHandler
{
public:
  explicit Maxima(wxSocketBase *socket, Configuration *config);
  virtual ~Maxima() override;
 
  static wxString EscapeVarnameForMaxima(wxString var);
  static wxString InvertCase(const wxString &var);
  static wxString MaximaVarnameToLisp(wxString var);
 
  wxSocketBase *Socket() const { return m_socket.get(); }
 
  bool IsConnected() const { return m_socket->IsConnected(); }
 
  static void SetPipeToStdErr(bool pipe) { m_pipeToStderr = pipe; }
  static void GetPipeToStdErr(bool pipe) { m_pipeToStderr = pipe; }
  static bool GetPipeToStdErr() { return m_pipeToStderr; }
 
  bool Write(const void *buffer, std::size_t length);
 
  void ReadSocket();
 
  void ClearFirstPrompt() { m_firstPrompt = false; }
 
  enum EventCause {
    READ_PENDING,
    READ_MISC_TEXT,
    XML_PROMPT,
    XML_SUPPRESSOUTPUT,
    XML_WXXMLSYMBOLS,
    XML_VARIABLES,
    XML_WATCH_VARIABLES_ADD,
    XML_STATUSBAR,
    XML_HTML_MANUAL_KEYWORDS,
    XML_MATHS,
    XML_TOOLONGMATHS,
    XML_WXXML_KEY,
    DISCONNECTED,
    WRITE_PENDING,
    WRITE_ERROR,
    STRING_FOR_XMLINSPECTOR,
  };
  void XmlInspectorActive(bool active){m_xmlInspector = active;}
private:
  std::atomic_bool m_xmlInspector{false};
 
  Configuration *m_configuration;
 
  jthread m_workerThread;
  std::atomic_bool m_readPendingQueued;
 
  void SocketEvent(wxSocketEvent &event);
  void TimerEvent(wxTimerEvent &event);
  void OnIdle(wxIdleEvent &event);
 
  std::unique_ptr<wxSocketBase> m_socket;
  std::mutex m_socketMutex;
  wxSocketInputStream m_socketInput;
  wxTextInputStream m_textInput;
 
  wxString m_socketInputData;
 
  wxString m_processingBuffer;
 
  std::vector<std::vector<char>> m_outputQueue;
  std::mutex m_outputQueueMutex;
 
  struct InterpretedItem {
      EventCause cause;
      wxString data;
  };
  std::vector<InterpretedItem> m_interpretedQueue;
  std::mutex m_interpretedQueueMutex;
 
  wxMemoryBuffer m_socketOutputData;
 
  bool m_firstPrompt = true;
  static bool m_pipeToStderr;
 
  void WorkerThread(stop_token stopToken);
 
  void ProcessData(stop_token stopToken);
  wxTimer m_readIdleTimer{this};
  static std::unordered_map<wxString, EventCause, wxStringHash> m_knownTags;
  static std::mutex m_knownTagsMutex;
};
 
wxDECLARE_EVENT(EVT_MAXIMA, wxThreadEvent);
#endif