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 "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 "Cell.h"
#include "TextCell.h"
#include "EditorCell.h"
#include "FracCell.h"
#include "GroupCell.h"
 
class MathParser
{
public:
  explicit MathParser(Configuration **cfg, const wxString &zipfile = {});
  MathParser(const MathParser&) = delete;
  MathParser& operator=(const MathParser&) = delete;
  ~MathParser();
 
  void SetUserLabel(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);
  /***
   * Parse the node and return the corresponding tag.
   */
  
  std::unique_ptr<Cell> ParseTag(wxXmlNode *node, bool all = true);
  std::unique_ptr<Cell> ParseRowTag(wxXmlNode *node);
 
  void SetGroup(GroupCell *group) { m_group = group; }
 
private:
  using MathCellFunc = std::unique_ptr<Cell> (MathParser::*)(wxXmlNode *node);
  WX_DECLARE_STRING_HASH_MAP(MathCellFunc, MathCellFunctionHash);
 
  using GroupCellFunc = std::unique_ptr<GroupCell> (MathParser::*)(wxXmlNode *node);
  WX_DECLARE_STRING_HASH_MAP(GroupCellFunc, GroupCellFunctionHash);
 
  static MathCellFunctionHash m_innerTags;
  static GroupCellFunctionHash m_groupTags;
 
  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);
 
  wxXmlNode *GetNextTag(wxXmlNode *node);
 
  int CountChildren(wxXmlNode *node);
 
  wxXmlNode *SkipWhitespaceNode(wxXmlNode *node);
 
  std::unique_ptr<Cell> ParseCellTag(wxXmlNode *node);
  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);
  std::unique_ptr<Cell> ParseFracTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseText(wxXmlNode *node, TextStyle style = TS_DEFAULT);
  std::unique_ptr<Cell> ParseVariableNameTag(wxXmlNode *node){return ParseText(node->GetChildren(), TS_VARIABLE);}
  std::unique_ptr<Cell> ParseOperatorNameTag(wxXmlNode *node){return ParseText(node->GetChildren(), TS_FUNCTION);}
  std::unique_ptr<Cell> ParseMiscTextTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseNumberTag(wxXmlNode *node){return ParseText(node->GetChildren(), TS_NUMBER);}
  std::unique_ptr<Cell> ParseHiddenOperatorTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseGreekTag(wxXmlNode *node){return ParseText(node->GetChildren(), TS_GREEK_CONSTANT);}
  std::unique_ptr<Cell> ParseSpecialConstantTag(wxXmlNode *node){return ParseText(node->GetChildren(), TS_SPECIAL_CONSTANT);}
  std::unique_ptr<Cell> ParseFunctionNameTag(wxXmlNode *node){return ParseText(node->GetChildren(), TS_FUNCTION);}
  std::unique_ptr<Cell> ParseSpaceTag(wxXmlNode *WXUNUSED(node)){return std::make_unique<TextCell>(m_group, m_configuration, wxT(" "));}
  std::unique_ptr<Cell> ParseMthTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseOutputLabelTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseStringTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseHighlightTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseImageTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseAnimationTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseCharCode(wxXmlNode *node);
  std::unique_ptr<Cell> ParseSupTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseSubTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseAbsTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseConjugateTag(wxXmlNode *node);
#if 0
  std::unique_ptr<Cell> ParseUnderTag(wxXmlNode *node);
#endif
  std::unique_ptr<Cell> ParseTableTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseAtTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseDiffTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseSumTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseIntTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseFunTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseSqrtTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseLimitTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseParenTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseSubSupTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseMmultiscriptsTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseOutputTag(wxXmlNode *node);
  std::unique_ptr<Cell> ParseMtdTag(wxXmlNode *node);
  // @}
  wxString m_userDefinedLabel;
  static wxRegEx m_graphRegex;
 
  CellType m_ParserStyle;
  FracCell::FracType m_FracStyle;
  CellPtr<GroupCell> m_group;
  Configuration **m_configuration;
  bool m_highlight;
  std::shared_ptr<wxFileSystem> m_fileSystem; // used for loading pictures in <img> and <slide>
  static wxString m_unknownXMLTagToolTip;
};
 
#endif // MATHPARSER_H