MathParser.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) 2004-2015 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 MATHPARSER_H
#define MATHPARSER_H
 
#include <memory>
#include "precomp.h"
#include <wx/xml/xml.h>
 
#include <wx/filesys.h>
#include <wx/fs_arc.h>
#include <wx/regex.h>
#include <wx/hashmap.h>
#include "cells/Cell.h"
#include "cells/TextCell.h"
#include "cells/EditorCell.h"
#include "cells/FracCell.h"
#include "cells/GroupCell.h"
#include <unordered_map>
#include <unordered_set>
 
class MathParser
{
public:
  explicit MathParser(Configuration *cfg, const wxString &zipfile = {});
  MathParser(const MathParser&) = delete;
  MathParser& operator=(const MathParser&) = delete;
  virtual ~MathParser();
 
  void SetUserLabel(const wxString &label){ m_userDefinedLabel = label; }
  /***
   * Parse the string s, which is (correct) xml fragment.
   * Put the result in line.
   */
  std::unique_ptr<Cell> ParseLine(wxString s, CellType style = MC_TYPE_DEFAULT);
  std::unique_ptr<Cell> ParseLine(const wxXmlDocument &xml, CellType style = MC_TYPE_DEFAULT);
  /***
   * Parse the node and return the corresponding tag.
   */
 
  std::unique_ptr<Cell> ParseTag(wxXmlNode *node, bool all = true, int depth = 0);
  std::unique_ptr<Cell> ParseRowTag(wxXmlNode *node, int depth = 0);
 
  std::unique_ptr<GroupCell> CreateTreeFromXMLNode(wxXmlNode *xmlcells);
 
  void SetGroup(GroupCell *group) { m_group = group; }
 
private:
  using MathCellFunc = std::unique_ptr<Cell> (MathParser::*)(wxXmlNode *node, int depth);
 
  using GroupCellFunc = std::unique_ptr<GroupCell> (MathParser::*)(wxXmlNode *node);
 
  typedef std::unordered_map <wxString, MathCellFunc, wxStringHash> MathCellFunctionHash;
  typedef std::unordered_map <wxString, GroupCellFunc, wxStringHash> GroupCellFunctionHash;
 
  static MathCellFunctionHash m_innerTags;
  static GroupCellFunctionHash m_groupTags;
  static std::unordered_set<wxString, wxStringHash> m_knownAttributes;
 
  static void ParseCommonAttrs(wxXmlNode *node, Cell *cell);
  template <typename T>
  static void ParseCommonAttrs(wxXmlNode *node, const std::unique_ptr<T> &cell)
    { ParseCommonAttrs(node, cell.get()); }
 
  static void ParseCommonGroupCellAttrs(wxXmlNode *node, const std::unique_ptr<GroupCell> &group);
 
  std::unique_ptr<Cell> HandleNullPointer(std::unique_ptr<Cell> &&cell);
 
  static wxXmlNode *GetNextTag(wxXmlNode *node);
 
  static int CountChildren(wxXmlNode *node);
 
  static wxXmlNode *SkipWhitespaceNode(wxXmlNode *node);
 
  std::unique_ptr<Cell> ParseCellTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<GroupCell> GroupCellFromCodeTag(wxXmlNode *node);
  std::unique_ptr<GroupCell> GroupCellFromImageTag(wxXmlNode *node);
  std::unique_ptr<GroupCell> GroupCellFromTitleTag(wxXmlNode *WXUNUSED(node));
  std::unique_ptr<GroupCell> GroupCellFromSectionTag(wxXmlNode *WXUNUSED(node));
  std::unique_ptr<GroupCell> GroupCellFromPagebreakTag(wxXmlNode *WXUNUSED(node));
  std::unique_ptr<GroupCell> GroupCellFromSubsectionTag(wxXmlNode *node);
  std::unique_ptr<GroupCell> GroupCellFromSubsubsectionTag(wxXmlNode *WXUNUSED(node));
  std::unique_ptr<GroupCell> GroupCellHeading5Tag(wxXmlNode *WXUNUSED(node));
  std::unique_ptr<GroupCell> GroupCellHeading6Tag(wxXmlNode *WXUNUSED(node));
  std::unique_ptr<GroupCell> GroupCellFromTextTag(wxXmlNode *WXUNUSED(node));
  /* @} */
 
  std::unique_ptr<Cell> ParseEditorTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseFracTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseText(wxXmlNode *node, TextStyle style = TS_MATH, int depth = 0);
  std::unique_ptr<Cell> ParseVariableNameTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseOperatorNameTag(wxXmlNode *node, int depth = 0){return ParseText(node->GetChildren(), TS_FUNCTION, depth);}
  std::unique_ptr<Cell> ParseMiscTextTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseNumberTag(wxXmlNode *node, int depth = 0){return ParseText(node->GetChildren(), TS_NUMBER, depth);}
  std::unique_ptr<Cell> ParseHiddenOperatorTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseGreekTag(wxXmlNode *node, int depth = 0){return ParseText(node->GetChildren(), TS_GREEK_CONSTANT, depth);}
  std::unique_ptr<Cell> ParseSpecialConstantTag(wxXmlNode *node, int depth = 0){return ParseText(node->GetChildren(), TS_SPECIAL_CONSTANT, depth);}
  std::unique_ptr<Cell> ParseFunctionNameTag(wxXmlNode *node, int depth = 0){return ParseText(node->GetChildren(), TS_FUNCTION, depth);}
  std::unique_ptr<Cell> ParseSpaceTag(wxXmlNode *WXUNUSED(node), int WXUNUSED(depth) = 0){return std::make_unique<TextCell>(m_group, m_configuration, wxS(" "));}
  std::unique_ptr<Cell> ParseMthTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseOutputLabelTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseStringTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseHighlightTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseImageTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseAnimationTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseCharCode(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseSupTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseSubTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseAbsTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseConjugateTag(wxXmlNode *node, int depth = 0);
#if 0
  std::unique_ptr<Cell> ParseUnderTag(wxXmlNode *node, int depth = 0);
#endif
  std::unique_ptr<Cell> ParseTableTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseAtTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseDiffTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseSumTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseIntTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseFunTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseSqrtTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseLimitTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseParenTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseSubSupTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseMmultiscriptsTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseOutputTag(wxXmlNode *node, int depth = 0);
  std::unique_ptr<Cell> ParseMtdTag(wxXmlNode *node, int depth = 0);
  // @}
  wxString m_userDefinedLabel;
  static wxRegEx m_graphRegex;
 
  CellType m_ParserStyle = MC_TYPE_DEFAULT;
  FracCell::FracType m_FracStyle;
  CellPtr<GroupCell> m_group;
  Configuration *m_configuration = NULL;
  bool m_highlight = false;
  wxString m_wxmxFile; // if not wxEmptyString: The wxmx file to load images from
  static wxString m_unknownXMLTagToolTip;
};
 
#endif // MATHPARSER_H