"Fossies" - the Fresh Open Source Software Archive

Member "ansifilter-2.18-x64/src/codegenerator.h" (30 Jan 2021, 14747 Bytes) of package /windows/misc/ansifilter-2.18-x64.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. See also the latest Fossies "Diffs" side-by-side code changes report for "codegenerator.h": 2.17_vs_2.18.

    1 /***************************************************************************
    2                           codegenerator.h  -  description
    3                              -------------------
    4     copyright            : (C) 2007-2021 by Andre Simon
    5     email                : a.simon@mailbox.org
    6  ***************************************************************************/
    7 
    8 /*
    9 This file is part of ANSIFilter.
   10 
   11 ANSIFilter is free software: you can redistribute it and/or modify
   12 it under the terms of the GNU General Public License as published by
   13 the Free Software Foundation, either version 3 of the License, or
   14 (at your option) any later version.
   15 
   16 ANSIFilter is distributed in the hope that it will be useful,
   17 but WITHOUT ANY WARRANTY; without even the implied warranty of
   18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   19 GNU General Public License for more details.
   20 
   21 You should have received a copy of the GNU General Public License
   22 along with ANSIFilter.  If not, see <http://www.gnu.org/licenses/>.
   23 */
   24 
   25 #ifndef CODEPARSER_H
   26 #define CODEPARSER_H
   27 
   28 #include <iostream>
   29 #include <sstream>
   30 #include <string>
   31 #include <vector>
   32 #include <iomanip>
   33 
   34 // Avoid problems with isspace and UTF-8 characters, use iswspace instead
   35 //#include <cctype>
   36 #include <wctype.h>
   37 
   38 #include "elementstyle.h"
   39 
   40 #include "enums.h"
   41 #include "stringtools.h"
   42 
   43 /// The ansifilter namespace contains all classes and data structures needed for parsing input data.
   44 
   45 namespace ansifilter
   46 {
   47 
   48   /** TheDraw output information of individual characters*/
   49   struct TDChar {
   50     unsigned char c;
   51     ElementStyle style;
   52   };
   53 
   54 
   55   class StyleInfo
   56 {
   57 public:
   58 
   59     /// Constructor
   60     StyleInfo() :  fgColor ( "" ), bgColor ( "" ),  isBold (false),isItalic (false),isConcealed (false), isBlink (false), isUnderLine (false)
   61     {
   62     }
   63 
   64     /// Constructor
   65     StyleInfo (  const string& fgc, const string& bgc, bool b, bool i, bool c, bool blink, bool ul ) :
   66         fgColor ( fgc ), bgColor ( bgc ),isBold ( b ), isItalic ( i ), isConcealed ( c ), isBlink (blink), isUnderLine (ul)
   67     {
   68     }
   69 
   70     /// Copy Constructor
   71     StyleInfo ( const StyleInfo& other )
   72     {
   73         fgColor = other.fgColor;
   74         bgColor = other.bgColor;
   75 
   76         isItalic = other.isItalic;
   77         isBold = other.isBold;
   78         isConcealed=other.isConcealed;
   79         isBlink = other.isBlink;
   80         isUnderLine = other.isUnderLine;
   81     }
   82 
   83     /// Operator overloading
   84     StyleInfo& operator= ( const StyleInfo & other )
   85     {
   86         fgColor = other.fgColor;
   87         bgColor = other.bgColor;
   88 
   89         isItalic = other.isItalic;
   90         isBold = other.isBold;
   91         isConcealed=other.isConcealed;
   92         isBlink = other.isBlink;
   93         isUnderLine = other.isUnderLine;
   94 
   95         return *this;
   96     }
   97 
   98     bool operator==(const StyleInfo& r)
   99     {
  100         return this->fgColor==r.fgColor && this->bgColor==r.bgColor && this->isBold==r.isBold
  101                 && this->isItalic==r.isItalic && this->isConcealed==r.isConcealed
  102                 && this->isBlink==r.isBlink && this->isUnderLine==r.isUnderLine;
  103     }
  104 
  105     ~StyleInfo()
  106     {
  107     }
  108 
  109     string fgColor;    ///< foreground color
  110     string bgColor;    ///< background color
  111     bool isBold, isItalic, isConcealed, isBlink, isUnderLine;  ///< style properties
  112    };
  113 
  114 /** \brief Base class for escape sequence parsing.
  115 
  116     The virtual class provides escape sequence parsing functionality.<br>
  117     The derived classes have to define the output format.<br>
  118     Codegenerator is a singleton class.
  119 
  120 * @author Andre Simon
  121 */
  122 
  123 class CodeGenerator
  124 {
  125 
  126 public:
  127 
  128     virtual ~CodeGenerator();
  129 
  130     /**
  131       Get appropriate Codegenerator instance
  132       \param type Output file type (TEXT, PANGO, HTML, RTF, LATEX, TEX)
  133     */
  134     static CodeGenerator* getInstance(OutputType type);
  135 
  136     /**
  137       Delete Codegenerator instance (this is intended for SWIG integration,
  138       in normal C++ code the result should be saved in an auto_ptr)
  139       \param CodeGenerator* CodeGenerator instance
  140     */
  141     static void deleteInstance(CodeGenerator* inst)
  142     {
  143         if (inst) delete inst;
  144     }
  145 
  146     /**
  147      Generates output file
  148      \param inFileName Path of input file (if empty use stdin)
  149      \param outFileName Path of output file (if empty use stdout)
  150      \return ParseError
  151     */
  152     ParseError generateFile(const string &inFileName, const string &outFileName);
  153 
  154     /**
  155      Generates output string from input string
  156      \param input input code string
  157      \return formatted output code
  158     */
  159     string generateString(const string &input);
  160 
  161     /**
  162      Generates output string from input file
  163      \param inFileName file path
  164      \return formatted output code
  165     */
  166     string generateStringFromFile(const string &inFileName);
  167 
  168     /**
  169      Generates output file from input string
  170      \param sourceStr input string
  171      \param outFileName output file path
  172      \param title document title
  173      \return formatted output code
  174     */
  175     ParseError generateFileFromString (const string &sourceStr,
  176                                        const string &outFileName,
  177                                        const string &title);
  178 
  179     /** Generate a stylesheet with the styles found in the document
  180     \param outPath Output path
  181     \return true if successful
  182      */
  183     virtual bool printDynamicStyleFile ( const string &outPath );
  184 
  185     /**
  186      Overrides default colours by user defined values; resets palette to default if mapPath is empty
  187      \param mapPath path of map file
  188      \return true if parsing was successful
  189     */
  190     bool setColorMap(const string& mapPath);
  191 
  192     /** tell parser to omit document header and footer
  193        \param  flag true if output should be fragmented
  194     */
  195     void setFragmentCode(bool flag);
  196 
  197     /** \return fragment flag */
  198     bool getFragmentCode();
  199 
  200     /** tell parser to use this font as base font
  201     \param s the font name, e.g. "Courier New"
  202      */
  203     void setFont(const string& s);
  204 
  205     /** \return base font */
  206     const string getFont() const ;
  207 
  208     /** tell parser to use this size as base font size
  209     \param s the font size, e.g. "12"
  210      */
  211     void setFontSize(const string& s);
  212 
  213     /** \return base font size*/
  214     const string getFontSize();
  215 
  216     /** Set encloding
  217       \param encodingName encoding name
  218     */
  219     void setEncoding(const string& encodingName);
  220 
  221     /** \param title Document title */
  222     void setTitle(const string & title);
  223 
  224     /** \return Document title */
  225     string getTitle();
  226 
  227     /** \param path style sheet path*/
  228     void setStyleSheet(const string & path);
  229 
  230     /** \param b set to true if text formatting should be stripped */
  231     void setPlainOutput(bool b)
  232     {
  233         ignoreFormatting=b;
  234     }
  235 
  236     /** \param b set to true if HTML anchors should be added to line numbers */
  237     void setAddAnchors(bool b, bool self=false)
  238     {
  239         addAnchors=b;
  240         addFunnyAnchors=self;
  241     }
  242 
  243     /** \param b set to true if the input stream is not closed after reaching EOF */
  244     void setContinueReading(bool b)
  245     {
  246         readAfterEOF=b;
  247     }
  248 
  249      /** \param b set to true if the output should not be terminated with EOL*/
  250     void setOmitTrailingCR(bool b)
  251     {
  252         omitTrailingCR=b;
  253     }
  254 
  255     /** \param b set to true if the output should not contain a version info comment*/
  256     void setOmitVersionInfo(bool b)
  257     {
  258         omitVersionInfo=b;
  259     }
  260 
  261     /** \return plain outputting flag */
  262     bool getPlainOutput()
  263     {
  264         return ignoreFormatting;
  265     }
  266 
  267     /** \return continue reading from input stream flag */
  268     bool getContinueReading()
  269     {
  270         return readAfterEOF;
  271     }
  272 
  273     /** \param lineWrappingStyle wrapping style
  274         \param lineLength maximum length  per wrapped text line */
  275     void setPreformatting ( WrapMode lineWrappingStyle,unsigned int lineLength);
  276 
  277     /** \param b set to true if line numbers should be added */
  278     void setShowLineNumbers(bool flag);
  279 
  280     /** \param b set to true if line numbers of wrapped lines should be omitted */
  281     void setWrapNoNumbers(bool flag);
  282 
  283     /** \param b set to true if input is ASCII art codepage 437 file  */
  284     void setParseCodePage437(bool flag);
  285 
  286     /** \param b set to true if input is an ASCII art BIN file*/
  287     void setParseAsciiBin(bool flag);
  288 
  289     /** \param b set to true if input is an Tundra art BIN file*/
  290     void setParseAsciiTundra(bool flag);
  291 
  292     /** \param b set to true if K clear sequences should be ignored*/
  293     void setIgnoreClearSeq(bool flag);
  294 
  295     /** \param b set to true if CSI sequences should be ignored*/
  296     void setIgnoreCSISeq(bool flag);
  297 
  298     /** \param b set dimensions of ASCII art virtual console */
  299     void setAsciiArtSize(int width, int height);
  300 
  301     /** tell parser to use dynamic stylesheets derived from the document's formatting
  302        \param  flag true
  303     */
  304     void setApplyDynStyles(bool flag);
  305 
  306     /** Set SVG dimensions
  307         \param w page width
  308         \param h page height
  309     */
  310     void setSVGSize ( const string& w, const string& h );
  311 
  312 protected:
  313 
  314     /** \param type Output type */
  315     CodeGenerator(ansifilter::OutputType type);
  316 
  317     CodeGenerator() {}
  318 
  319     /** \param c Character to be masked
  320         \return Escape sequence of output format */
  321     virtual string maskCharacter(unsigned char c) = 0;
  322 
  323     /** \param c Character to be masked
  324      \return Codepage 437 escape sequence of output format */
  325     virtual string maskCP437Character(unsigned char c) { return maskCharacter(c); }
  326 
  327     /** \param uri URI
  328      *  \param txt Description
  329      \return returns link formatting sequence */
  330     virtual string getHyperlink(string uri, string txt) { return txt+"["+uri+"]"; }
  331 
  332     /** Tag for inserting line feeds*/
  333     string newLineTag;
  334 
  335     /** SVG document dimensions */
  336     string width, height;
  337 
  338     /** file input*/
  339     istream *in;
  340 
  341     /** file output*/
  342     ostream *out;
  343 
  344     /** line buffer*/
  345     ostringstream lineBuf;
  346 
  347     bool tagIsOpen; ///< a reminder to close an open tag
  348 
  349     string styleCommentOpen,  ///< open comment delimiter
  350            styleCommentClose; ///< close comment delimiter
  351 
  352     /** Encoding name */
  353     string encoding;
  354 
  355     /** Encoding name */
  356     string docTitle;
  357 
  358     string spacer;
  359 
  360     /** Test if header and footer should be omitted */
  361     bool fragmentOutput;
  362 
  363     /** The base font to use */
  364     string font ;
  365 
  366     /** The base font size to use */
  367     string fontSize ;
  368 
  369     /** Style sheet path */
  370     string styleSheetPath;
  371 
  372     /** Width of line numbers */
  373     unsigned int lineNumberWidth;
  374 
  375     /** Current line number */
  376     unsigned int lineNumber;
  377     bool showLineNumbers,     ///< show line numbers
  378          numberWrappedLines,  ///< also show number of wrapped lines
  379          numberCurrentLine,   ///< output number of current line
  380          addAnchors,          ///< add HTML anchor to line number
  381          addFunnyAnchors,     ///< add HTML links to themselves
  382          applyDynStyles;      ///< insert dynamic style references instead of inline styles
  383 
  384     bool omitVersionInfo;     ///< do not print version info comment
  385     bool parseCP437;          ///< treat input as CP437 file
  386     bool parseAsciiBin;       ///< treat input as BIN or XBIN file
  387     bool parseAsciiTundra;    ///< treat input as Tundra file
  388 
  389     /** Processes input data */
  390     void processInput();
  391 
  392     virtual void insertLineNumber ();
  393 
  394     /** \return true id encoding is defined */
  395     bool encodingDefined()
  396     {
  397         return StringTools::lowerCase(encoding)!="none";
  398     }
  399 
  400     /** convert a rgb triple to HTML color notation
  401     @param rgb RGB input values
  402     @return HTML color string
  403     */
  404     string rgb2html(unsigned char* rgb);
  405 
  406     string rgb2html(int r, int g, int b);
  407 
  408     /// 16 basic colors
  409     static unsigned char workingPalette[16][3];
  410     static unsigned char defaultPalette[16][3];
  411 
  412     ElementStyle elementStyle;
  413 
  414     vector<StyleInfo> documentStyles;
  415 
  416 private:
  417 
  418     CodeGenerator(const CodeGenerator&) {}
  419 
  420     CodeGenerator& operator=(CodeGenerator&)
  421     {
  422         return *this;
  423     }
  424 
  425     /** parses string to extract ANSI sequence information
  426         @param line text line
  427         @param begin starting position within line
  428         @param end ending position within line
  429         @return true if sequence was recognized */
  430     bool parseSGRParameters(const string& line, size_t begin, size_t end);
  431 
  432     /** parses Codepage 437 sequence information
  433         @param line text line
  434         @param begin starting position within line
  435         @param end ending position within line
  436         */
  437     void parseCodePage437Seq(string line, size_t begin, size_t end);
  438 
  439     /** Prints document footer
  440         @return footer */
  441     virtual string getFooter() = 0;
  442 
  443     /** Prints document body*/
  444     virtual void printBody() = 0;
  445 
  446     /** Prints document header
  447         @return header
  448     */
  449     virtual string getHeader() = 0;
  450 
  451     /** Resets parser to origin state, call this after every file conversion */
  452     void reset();
  453 
  454     /** Output format type*/
  455     OutputType outputType;
  456 
  457     virtual string getOpenTag() = 0;  ///< returns opening formatting sequence
  458     virtual string getCloseTag() = 0; ///< returns closing formatting sequence
  459 
  460     bool ignoreFormatting; ///< ignore color and font face information
  461     bool readAfterEOF;     ///< continue reading after EOF occoured
  462     bool omitTrailingCR;   ///< do not print EOL at the end of output
  463     bool ignClearSeq;      ///< ignore clear sequence ESC K
  464     bool ignCSISeq;       ///< ignore CSIs (may interfere with UTF-8 input)
  465 
  466     TDChar* termBuffer;
  467     int curX, curY, memX, memY, maxY; ///< cursor position for Codepage 437 sequences
  468     int asciiArtWidth;        ///< virtual console column count
  469     int asciiArtHeight;       ///< virtual console line count
  470     unsigned int lineWrapLen; ///< max line length before wrapping
  471 
  472     ElementStyle memStyle;
  473 
  474     /** clear line buffer
  475     */
  476     void printNewLine(bool eof=false);
  477 
  478     /** convert an xterm color value (0-253) to 3 unsigned chars rgb
  479         @param color xterm color
  480         @param rgb RGB output values */
  481     void xterm2rgb(unsigned char color, unsigned char* rgb);
  482 
  483     /**Print content of virtual terminal buffer. Deletes buffer. */
  484     void printTermBuffer();
  485 
  486     /**Parses BIN ASCII art file */
  487     void parseBinFile();
  488 
  489     /**Parses XBIN ASCII art file */
  490     void parseXBinFile();
  491 
  492     /**Parses Tundra ASCII art file */
  493     void parseTundraFile();
  494 
  495     /**allocate virtual terminal buffer */
  496     void allocateTermBuffer();
  497 
  498     /** @return true if stream begins with XBIN id  */
  499     bool streamIsXBIN();
  500 
  501      /** @return true if stream begins with Tundra id  */
  502     bool streamIsTundra();
  503 
  504     /// the 6 value iterations in the xterm color cube
  505     static const unsigned char valuerange[] ;
  506 };
  507 
  508 }
  509 
  510 #endif