diff options
Diffstat (limited to 'tests/examplefiles/example.cpp')
| -rw-r--r-- | tests/examplefiles/example.cpp | 7300 |
1 files changed, 0 insertions, 7300 deletions
diff --git a/tests/examplefiles/example.cpp b/tests/examplefiles/example.cpp index 316c1420..4dffc3f7 100644 --- a/tests/examplefiles/example.cpp +++ b/tests/examplefiles/example.cpp @@ -6242,7303 +6242,3 @@ void CodeGenerator::openKWTag(unsigned int kwClassID){ currentState=KEYWORD; } - -/////////////////////////////////////////////////////////////////////////////// - -void CodeGenerator::processRootState() -{ - if (langInfo.highlightingDisabled()){ - string line; - while (getline(*in, line)){ - *out << maskString(line) << getNewLine(); - } - *out << flush; - return; - } - - State state=STANDARD; - - bool eof=false, - firstLine=true; // avoid newline before printing the first output line - openTag(STANDARD); - do { - // determine next state - state= getCurrentState(state==NUMBER); - // handle current state - switch(state) - { - case KEYWORD: - case KEYWORD_BEGIN: - closeTag(STANDARD); - eof=processKeywordState(state); - openTag(STANDARD); - break; - case NUMBER: - closeTag(STANDARD); - eof=processNumberState(); - openTag(STANDARD); - break; - case ML_COMMENT_BEGIN: - closeTag(STANDARD); - eof=processMultiLineCommentState(); - openTag(STANDARD); - break; - case SL_COMMENT: - closeTag(STANDARD); - eof=processSingleLineCommentState(); - openTag(STANDARD); - break; - case STRING: - closeTag(STANDARD); - eof=processStringState(STANDARD); - openTag(STANDARD); - break; - case DIRECTIVE_LINE: - closeTag(STANDARD); - eof=processDirectiveState(); - openTag(STANDARD); - break; - case TAG_BEGIN: - closeTag(STANDARD); - eof=processTagState(); - openTag(STANDARD); - break; - case ESC_CHAR: - if (langInfo.allowExtEscSeq()){ - closeTag(STANDARD); - eof=processEscapeCharState(); - openTag(STANDARD); - } else { - printMaskedToken(); - } - break; - case SYMBOL: - closeTag(STANDARD); - eof=processSymbolState(); - openTag(STANDARD); - break; - case _EOL: - insertLineNumber(!firstLine); - firstLine=false; - break; - case _EOF: - eof=true; - break; - case _WS: - processWsState(); - break; - default: - printMaskedToken(); - break; - } - } - while (!eof); - closeTag(STANDARD); - *out << getNewLine(); - *out << flush; -} - -bool CodeGenerator::processKeywordState(State myState){ - State newState=STANDARD; - unsigned int myClassID=currentKeywordClass; - bool eof=false, - exitState=false; - - openKWTag(myClassID); - do { - printMaskedToken(newState!=_WS); - newState= getCurrentState(); - switch(newState) - { - case _WS: - processWsState(); - break; - case _EOL: - insertLineNumber(); - exitState=true; - break; - case _EOF: - eof = true; - break; - case KEYWORD_END: - if (myState==KEYWORD_BEGIN){ - printMaskedToken(); - } - exitState=true; - break; - default: - exitState= myState!=KEYWORD_BEGIN - &&((myClassID!=currentKeywordClass)||(myState!=newState)); - break; - } - } while ((!exitState) && (!eof)); - - closeKWTag(myClassID); - - currentKeywordClass=0; - return eof; -} - -bool CodeGenerator::processNumberState(){ - State newState=STANDARD; - bool eof=false, - exitState=false; - - openTag(NUMBER); - do { - printMaskedToken(newState!=_WS); - newState= getCurrentState(true); - switch(newState) - { - case _WS: - processWsState(); - break; - case _EOL: - insertLineNumber(); - exitState=true; - break; - case _EOF: - eof = true; - break; - default: - exitState=newState!=NUMBER; - break; - } - } while ((!exitState) && (!eof)); - - closeTag(NUMBER); - return eof; -} - -bool CodeGenerator::processMultiLineCommentState() -{ - int commentCount=1; - State newState=STANDARD; - bool eof=false, exitState=false; - - openTag(ML_COMMENT_BEGIN); - do { - printMaskedToken(newState!=_WS); - newState= getCurrentState(); - - switch(newState) - { - case _WS: - processWsState(); - break; - case _EOL: - wsBuffer += styleTagClose[ML_COMMENT_BEGIN]; - insertLineNumber(); - wsBuffer += styleTagOpen[ML_COMMENT_BEGIN]; - break; - case _EOF: - eof = true; - break; - case ML_COMMENT_BEGIN: - if (langInfo.allowNestedMLComments()) { - ++commentCount; - } - break; - case ML_COMMENT_END: - commentCount--; - if (!commentCount){ - printMaskedToken(); - exitState=true; - } - break; - default: - break; - } - } while ((!exitState) && (!eof)); - - closeTag(ML_COMMENT_BEGIN); - return eof; -} - -bool CodeGenerator::processSingleLineCommentState() -{ - - //if ( checkSpecialCmd()) return false; - - State newState=STANDARD; - bool eof=false, exitState=false; - - openTag(SL_COMMENT); - do { - printMaskedToken(newState!=_WS); - newState= getCurrentState(); - - switch(newState) - { - case _WS: - processWsState(); - break; - case _EOL: - printMaskedToken(); - insertLineNumber(); - exitState=true; - break; - case _EOF: - eof = true; - break; - default: - break; - } - } while ((!exitState) && (!eof)); - - closeTag(SL_COMMENT); - return eof; -} - -bool CodeGenerator::processDirectiveState() -{ - State newState=STANDARD; - bool eof=false, exitState=false; - - openTag(DIRECTIVE_LINE); - do { - printMaskedToken(newState!=_WS); - newState= getCurrentState(); - switch(newState) - { - case _WS: - processWsState(); - break; - case DIRECTIVE_LINE_END: - printMaskedToken(); - exitState=true; - break; - case _EOL: - printMaskedToken(); - exitState=(terminatingChar!=langInfo.getContinuationChar()); - if (!exitState) wsBuffer += styleTagClose[DIRECTIVE_LINE]; - insertLineNumber(); - if (!exitState) wsBuffer += styleTagOpen[DIRECTIVE_LINE]; - break; - case ML_COMMENT_BEGIN: - closeTag(DIRECTIVE_LINE); - eof= processMultiLineCommentState(); - openTag(DIRECTIVE_LINE); - break; - case SL_COMMENT: - closeTag(DIRECTIVE_LINE); - eof= processSingleLineCommentState(); - openTag(DIRECTIVE_LINE); - exitState=true; - break; - case STRING: - closeTag(DIRECTIVE_LINE); - eof=processStringState(DIRECTIVE_LINE); - openTag(DIRECTIVE_LINE); - break; - case _EOF: - eof = true; - break; - default: - break; - } - } while ((!exitState) && (!eof)); - - closeTag(DIRECTIVE_LINE); - return eof; -} - -bool CodeGenerator::processStringState(State oldState) -{ - State newState=STANDARD; - bool eof=false, exitState=false; - bool returnedFromOtherState=false; - // Test if character before string open delimiter token equals to the - // raw string prefix (Example: r" ", r""" """ in Python) - bool isRawString= - line[lineIndex-token.length()-1]==langInfo.getRawStringPrefix(); - - string openStringDelimiter=token; - - State myState= (oldState==DIRECTIVE_LINE) ? DIRECTIVE_STRING : STRING; - openTag(myState); - do { - // true if last token was an escape char - if (!returnedFromOtherState) { - printMaskedToken(newState!=_WS); - } - returnedFromOtherState=false; - newState= getCurrentState(); - - switch(newState) - { - case _WS: - processWsState(); - break; - case _EOL: - wsBuffer += styleTagClose[myState]; - insertLineNumber(); - wsBuffer += styleTagOpen[myState]; - //exitState=true; - break; - case ML_COMMENT_END: - printMaskedToken(); - break; - case STRING: - exitState= openStringDelimiter==token; - printMaskedToken(); - break; - case ESC_CHAR: - if (!isRawString){ - closeTag(myState); - eof=processEscapeCharState(); - openTag(myState); - returnedFromOtherState=true; - } - break; - case _EOF: - eof = true; - break; - default: - printMaskedToken(); - break; - } - } while ((!exitState) && (!eof)); - - closeTag(myState); - return eof; -} - -bool CodeGenerator::processTagState() -{ - State newState=STANDARD; - bool eof=false, exitState=false, returnedFromOtherState=false; - unsigned int myKeywordClass=currentKeywordClass; - - openTag(KEYWORD); - do { - if (!returnedFromOtherState) { - printMaskedToken(newState!=_WS); - } - returnedFromOtherState = false; - newState= getCurrentState(); - - switch(newState) - { - case _WS: - processWsState(); - break; - case _EOL: - insertLineNumber(); - exitState=true; - break; - case TAG_END: - printMaskedToken(); - exitState=true; - break; - case STRING: - closeTag(KEYWORD); - eof=processStringState(KEYWORD); - currentKeywordClass=myKeywordClass; - openTag(KEYWORD); - returnedFromOtherState = true; - break; - case ESC_CHAR: - closeTag(KEYWORD); - eof=processEscapeCharState(); - currentKeywordClass=myKeywordClass; - openTag(KEYWORD); - returnedFromOtherState = true; - break; - case NUMBER: - closeTag(KEYWORD); - eof=processNumberState(); - currentKeywordClass=myKeywordClass; - openTag(KEYWORD); - returnedFromOtherState = true; - break; - case _EOF: - eof = true; - break; - default: - printMaskedToken(); - break; - } - } while ((!exitState) && (!eof)); - - closeTag(KEYWORD); - currentKeywordClass=0; - - return eof; -} - -bool CodeGenerator::processSymbolState(){ - - State newState=STANDARD; - bool eof=false, - exitState=false; - - openTag(SYMBOL); - do { - printMaskedToken(newState!=_WS); - newState= getCurrentState(true); - switch(newState) - { - case _WS: - processWsState(); - break; - case _EOL: - insertLineNumber(); - exitState=true; - break; - case _EOF: - eof = true; - break; - default: - exitState=newState!=SYMBOL; - break; - } - } while ((!exitState) && (!eof)); - - closeTag(SYMBOL); - return eof; -} - -bool CodeGenerator::processEscapeCharState() -{ - State newState=STANDARD; - bool eof=false, exitState=false; - - openTag(ESC_CHAR); - do { - printMaskedToken(newState!=_WS); - skipEscapeSequence(); - newState= getCurrentState(); - switch(newState) - { - case _EOL: - insertLineNumber(); - exitState=true; - break; - case _WS: - processWsState(); - --lineIndex; - break; - case _EOF: - eof = true; - break; - default: - exitState=newState!=ESC_CHAR; - break; - } - } while ((!exitState) && (!eof)); - - closeTag(ESC_CHAR); - return eof; -} - -void CodeGenerator::skipEscapeSequence(){ - if (lineIndex<line.length()){ - char c=line[lineIndex]; - int charsToSkip=1; - // Escape Sequenz /ooo Oktal, /x000 hex, /u00xx Java unicode - if (isdigit(c) ){ - // \0 abfangen - while ( isdigit(line[lineIndex+charsToSkip]) && charsToSkip<4) { - ++charsToSkip; - } - } else if (tolower(c)=='x'){ - charsToSkip=langInfo.isJava() ? 4 : 3; - } else if (tolower(c)=='u'){ - charsToSkip=5; - } - while (charsToSkip-- && lineIndex++<line.length()){ - *out <<maskCharacter(line[lineIndex-1]); - } - } -} - - -void CodeGenerator::processWsState() -{ - if (!maskWs) { - wsBuffer += token; - token.clear(); - return; - } - flushWs(); - int cntWs=0; - lineIndex--; - - while (isspace(line[lineIndex]) ) { - ++cntWs; - ++lineIndex; - } - - if (cntWs>1) { - unsigned int styleID=getStyleID(currentState, currentKeywordClass); - if (excludeWs && styleID!=_UNKNOWN) { - *out << styleTagClose[styleID]; - } - *out << maskWsBegin; - for (int i=0; i<cntWs; i++){ - *out << spacer; - } - *out << maskWsEnd; - if (excludeWs && styleID!=_UNKNOWN){ - *out << styleTagOpen[styleID]; - } - } else { - *out << token; - } - token.clear(); -} - -void CodeGenerator::flushWs(){ - *out<<wsBuffer; - wsBuffer.clear(); -} - -bool CodeGenerator::isFirstNonWsChar() { - unsigned int i=lineIndex-1; - while (i--){ - if (!isspace(line[i])){ - return false; - } - } - return true; -} - -string CodeGenerator::getNewLine(){ - return newLineTag; -} - -void CodeGenerator::insertLineNumber(bool insertNewLine) { - if (insertNewLine){ - wsBuffer += getNewLine(); - } - if (showLineNumbers) { - ostringstream os; - ostringstream numberPrefix; - if (lineNumberFillZeroes) { - os.fill('0'); - } - os <<setw(LINE_NUMBER_WIDTH) << right << lineNumber; - - numberPrefix << styleTagOpen[LINENUMBER] - << maskString(os.str()) << spacer - << styleTagClose[LINENUMBER]; - - wsBuffer += numberPrefix.str(); - } -} - -unsigned int CodeGenerator::getLineIndex(){ - return lineIndex; -} - -bool CodeGenerator::printExternalStyle(const string &outFile) -{ - if (!includeStyleDef && langInfo.getSyntaxHighlight()) { - ofstream cssOutFile(outFile.c_str()); - if (cssOutFile) { - cssOutFile << styleCommentOpen - <<" Style definition file generated by highlight " - << HIGHLIGHT_VERSION << ", " << HIGHLIGHT_URL - << " " << styleCommentClose << "\n"; - cssOutFile << "\n"<<styleCommentOpen<<" Highlighting theme definition: " - << styleCommentClose << "\n\n" - << getStyleDefinition() - << "\n"; - cssOutFile << readUserStyleDef(); - cssOutFile.close(); - } else { - return false; - } - } - return true; -} - -string CodeGenerator::readUserStyleDef(){ - ostringstream ostr; - if (!styleInputPath.empty()){ - ifstream userStyleDef(styleInputPath.c_str()); - if (userStyleDef) { - ostr << "\n"<<styleCommentOpen<<" Content of "<<styleInputPath<<": "<<styleCommentClose<<"\n"; - string line; - while (getline(userStyleDef, line)){ - ostr << line << "\n"; - } - userStyleDef.close(); - } else { - ostr << styleCommentOpen<<" ERROR: Could not include " - << styleInputPath - << "."<<styleCommentClose<<"\n"; - } - } - return ostr.str(); -} - -bool CodeGenerator::checkSpecialCmd(){ - bool insertNL = (lineIndex-token.length()); - cerr << "token: "<<token<< " index"<< lineIndex << " "<<line [ lineIndex ]<<endl; - - if (line [ lineIndex ]=='!'){ - // find cmd - size_t cmdPos1 = line.find('@', lineIndex+1); - - cerr << "cmdPos"<<cmdPos1<<endl; - if(cmdPos1==string::npos) return false; - size_t cmdPos2=cmdPos1+1; - while (cmdPos2 < line.length() && StringTools::isAlpha(line[cmdPos2])) cmdPos2++; - cerr << "cmdPos2"<<cmdPos2<<endl; - cerr << line.substr(cmdPos1, cmdPos2)<<endl; - - // hide comment line - token.clear(); - lineIndex=line.length(); - getInputChar(); lineNumber--; - if (insertNL) { lineNumber++;insertLineNumber();}; - // end hide - - return true; - } - - return false; -} - -} -/*************************************************************************** - codeparser.h - description - ------------------- - begin : Die Jul 9 2002 - copyright : (C) 2002 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef CODEPARSER_H -#define CODEPARSER_H - -#include <iostream> -#include <sstream> -#include <string> -#include <iomanip> -#include <cctype> - -#include "languagedefinition.h" -#include "documentstyle.h" -#include "ASFormatter.h" -#include "preformatter.h" -#include "enums.h" - - -#define NUMBER_BUILTIN_STYLES 10 -#define LINE_NUMBER_WIDTH 5 -#define MAX_LINE__WIDTH 80 - -#define OUTPUT_FLAG_LN 1 -#define OUTPUT_FLAG_LNZ 2 -#define OUTPUT_FLAG_FRAG 4 - -/** The highlight namespace contains all classes and data structures - needed for parsing input data. -*/ -namespace highlight { - -/** \brief Base class for parsing. Works similar to a Turing machine. - - The virtual class provides source code parsing functioality, based on - information stored in language definitions.<br> - Deriving classes have to define the output format.<br> - Codegenerator is a singleton class. - -* @author Andre Simon -*/ - -class CodeGenerator - { - - public: - - virtual ~CodeGenerator(); - - /** - Get appropriate Codegenerator instance - \param type Output file type (HTML, XHTML, RTF, LATEX, TEX, XSLFO, ANSI) - \param styleInfoPath Path to formatting style information - \param styleInPath Path to style definition input file (to be included in styleOutPath) - \param styleOutPath Path to style definition output file (CSS path for HTML output) - \param encoding Output file encoding name - \param includeStyle Switch to include style information in output file (only XHTML, HTML) - \param attachAnchors Switch to attach anchors to line numbers (only XHTML, HTML) - \param replaceQuotes Switch to replace quotes by \dq{} (only LATEX) - \param fopCompatible Switch to generate FO for Apache FOP (only XSLFO) - \param omitEncoding Switch to omit encoding info in output document - \param ln Set true if line numbers should be printed - \param lnz Set true if leading space of line numbers should be filled with 0's - \param fragment Set true if document header and footer should be omitted - \param numSpaces Number of spaces which replace a tab - \param lineWrappingMode Line wrapping mode - */ - static CodeGenerator* getInstance(OutputType type, - const string& styleInfoPath, - const string& styleInPath, - const string& styleOutPath, - const string& encoding, - bool includeStyle, - bool attachAnchors, - bool replaceQuotes, - bool fopCompatible, - int numSpaces, - WrapMode lineWrappingMode, - bool ln, - bool lnz, - bool fragment, - bool omitEncoding ); - - /** Deletes the singleton CodeGenerator instance. - Call this method if getInstance was already called, or if you want to - free the momory after usage.*/ - static void deleteInstance(); - - /** - Generates output - \param inFileName Path of input file (if empty use stdin) - \param outFileName Path of input file (if empty use stdout) - - \return ParseError - */ - ParseError printOutput(const string &inFileName, const string &outFileName); - - /** \return True if document style was found */ - bool styleFound(); - - /** \return True if reformatting of current input is disabled */ - bool formattingDisabled(); - - /** \return True if reformatting of current input is possible */ - bool formattingIsPossible(); - - /** \param langDefPath Absolute path to language definition - \return Failure: LOAD_FAILED; Reload necessary: LOAD_NEW, - no reload necessary: LOAD_NONE */ - LoadResult initLanguage(const string& langDefPath); - - /** \return Language definition*/ - LanguageDefinition &getLanguage(); - - /** tell parser to output line numbers - \param flag true if line numbers should be printed - */ - void setPrintLineNumbers(bool flag); - - /** \return line number flag */ - bool getPrintLineNumbers(); - - - /** tell parser to output line numbers filled with zeroes - \param flag true if zeroes should be printed - */ - void setPrintZeroes(bool flag); - - /** \return print zeroes flag */ - bool getPrintZeroes(); - - /** tell parser to omit document header and footer - \param flag true if output should be fragmented - */ - void setFragmentCode(bool flag); - - /** \return fragment flag */ - bool getFragmentCode(); - - /** tell parser the style name - \param s path to style definition - */ - void setStyleName(const string& s); - - /** \return style path */ - const string& getStyleName(); - - /** tell parser the wrapping mode - \param lineWrappingStyle wrapping style - \param lineLength max line length - \param numberSpaces number of spaces which replace a tab - */ - void setPreformatting(WrapMode lineWrappingStyle, unsigned int lineLength,int numberSpaces); - - /** \return wrapping style */ - WrapMode getLineWrapping(); - - /** tell parser the include style definition in output - \param flag true if style should be included - */ - void setIncludeStyle(bool flag); - - /** Print style definitions to external file - \param outFile Path of external style definition - */ - bool printExternalStyle(const string &outFile); - - /** Print index file with all input file names - \param fileList List of output file names - \param outPath Output path - */ - virtual bool printIndexFile(const vector<string> & fileList, - const string &outPath); - - /** initialize source code indentation - \param indentSchemePath Path of indentation scheme - \return true id successfull - */ - bool initIndentationScheme(const string&indentSchemePath); - - /** Set style input path - \param s path to style input file - */ - void setStyleInputPath(const string& path); - - /** Set style output path - \param s path to style output file - */ - void setStyleOutputPath(const string& path); - -/** Set output type - \param s output type - */ - void setType(OutputType t); - - /** - \return style input file path - */ - const string& getStyleInputPath(); - - /** - \return style output file path - */ - const string& getStyleOutputPath(); - -protected: - - CodeGenerator(); - - //! CodeGenerator Constructor - /** - \param colourTheme Name of coloring style being used - */ - CodeGenerator(const string &colourTheme); - - /** \param c Character to be masked - \return Escape sequence of output format */ - virtual string maskCharacter(unsigned char c) = 0; - - /** \param s string - \return Copy of s with all escaped characters */ - string maskString(const string &s ) ; - - /** \param s Symbol string - \param searchPos Position where search starts - \return Found state (integer value) */ - State getState(const string &s, unsigned int searchPos); - - /** \return Next identifier in current line of code */ - string getIdentifier(); - - /** \return Next number in current line of code */ - string getNumber(); - - /** Insert line number at the beginning of current output line */ - virtual void insertLineNumber(bool insertNewLine=true); - - /** Prints document footer*/ - virtual string getFooter() = 0; - - /** Prints document body*/ - virtual void printBody() = 0; - - /** prints document header - \param title Title of the document - */ - virtual string getHeader(const string &title) = 0; - - /** Get current line number - \return line number */ - unsigned int getLineNumber(); - - - /** Tag Delimiters for every colour style*/ - vector <string> styleTagOpen, styleTagClose; - - /** Description of document colour style*/ - DocumentStyle docStyle; - - /** Language definition*/ - LanguageDefinition langInfo; - - /** Tag for inserting line feeds*/ - string newLineTag; - - /** String that represents a white space in output */ - string spacer; - - /** file input*/ - istream *in; - - /** file output*/ - ostream *out; - - /** Tags which enclose white space indentation blocks */ - string maskWsBegin, maskWsEnd; - - /** Style comment delimiters */ - string styleCommentOpen, styleCommentClose; - - /** Test if maskWsBegin and maskWsEnd should be applied */ - bool maskWs; - - /** Test if whitespace sould always be separated from enclosing tokens */ - bool excludeWs; - - /** Test if header and footer should be omitted */ - bool fragmentOutput; - - /** Test if line numbers should be printed */ - bool showLineNumbers; - - /** Test if leading spyce of line number should be filled with zeroes*/ - bool lineNumberFillZeroes; - - /** Current line of input file*/ - string line; - - /** Current line number */ - unsigned int lineNumber; - - // Zeigt den aktuellen Zustand an - // wird nicht in getCurrentState gesetzt, da nur Zustände interessant - // sind, die als Index auf die styleCloseTags und styleOpenTags verwendet - // werden können - /** Current state*/ - State currentState; - - /** keyword class id, used to apply the corresponding keyword style*/ - unsigned int currentKeywordClass; - - /** Processes origin state */ - void processRootState(); - - /** return line break sequence */ - virtual string getNewLine(); - - /** - \param s current state - \return Index of style tag corresponding to the states - */ - unsigned int getStyleID(State s, unsigned int kwClassID = 0); - - /** \return line index */ - unsigned int getLineIndex(); - - /** print all remaining white space*/ - void flushWs(); - - /** - \return Content of user defined input style - */ - string readUserStyleDef(); - - /** - \return Style definition of the chosen output format - */ - virtual string getStyleDefinition() {return "";}; - - /** contains white space, which will be printed after a closing tag */ - string wsBuffer; - - /** - Flag to test if style definition should be included in output document - */ - bool includeStyleDef; - -private: - - CodeGenerator(const CodeGenerator&){} - CodeGenerator& operator=(CodeGenerator&){ return *this;} - - static CodeGenerator* generator; - - /** return matching open and close tags of the given state */ - virtual string getMatchingOpenTag(unsigned int) = 0; - virtual string getMatchingCloseTag(unsigned int) = 0; - - /** open a new tag, set current state to s*/ - void openTag(State s); - - /** close opened tag, clear current state */ - void closeTag(State s); - - void closeTag(unsigned int styleID); - - void openTag(unsigned int styleID); - - // path to style definition file - string stylePath; - - // contains current position in line - unsigned int lineIndex; - - /**last character of the last line*/ - unsigned char terminatingChar; - - /** Class for reformatting */ - astyle::ASFormatter *formatter; - - /** Class for line wrapping and tab replacement*/ - PreFormatter *preFormatter; - - /** Flag to test if formatting is enabled with current input document*/ - bool formattingEnabled; - - - /** Flag to test if formatting is possible with current input document*/ - bool formattingPossible; - - /** contains the current token*/ - string token; - - string styleInputPath, styleOutputPath; - - /** Resets parser to origin state, call this after every file conversion */ - void reset(); - - /** read new line from in stream */ - bool readNewLine(string &newLine); - - /** return next character from in stream */ - unsigned char getInputChar(); - - OutputType outputType; - - /** return new state */ - State getCurrentState ( bool lastStateWasNumber=false); - - /** Methods that represent a parsing state */ - bool processKeywordState(State myState) ; - bool processNumberState() ; - bool processMultiLineCommentState(); - bool processSingleLineCommentState(); - bool processStringState(State oldState); - bool processEscapeCharState(); - bool processDirectiveState(); - bool processTagState(); - bool processSymbolState(); - void processWsState(); - - /** gibt true zurck, falls c ein erlaubter Character innerhalb von Keyword - oder Typbezeichner ist */ - bool isAllowedChar(char c) ; - - /** returns true if curret token is the first in line and no whitespace */ - bool isFirstNonWsChar() ; - - /** print escaped token and clears it */ - void printMaskedToken(bool flushWhiteSpace=true); - - /** print escape sequence */ - void skipEscapeSequence(); - - void closeKWTag(unsigned int styleID); - void openKWTag(unsigned int styleID); - - /** look for special commands in comments, take action in derived class - \return true if command was found - */ - bool checkSpecialCmd(); - - }; -} - -#endif - -/* - * Copyright (c) 1998,1999,2000,2001,2002 Tal Davidson. All rights reserved. - * - * compiler_defines.h (1 January 1999) - * by Tal Davidson (davidsont@bigfoot.com) - * This file is a part of "Artistic Style" - an indentater and reformatter - * of C, C++, C# and Java source files. - * - * The "Artistic Style" project, including all files needed to compile it, - * is free software; you can redistribute it and/or use 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. - * - * You should have received a copy of the GNU General Public - * License along with this program. - */ - - - - - -/* - * comment out the line below if your compiler does NOT understand NAMESPACES - */ -#define USES_NAMESPACE - - -#if defined(__GNUC__) && __GNUC__ < 3 -// for G++ implementation of string.compare: -#define COMPARE(place, length, str) compare((str), (place), (length)) -#else -// for standard implementation of string.compare: -#define COMPARE(place, length, str) compare((place), (length), (str)) -#endif - - -// Fix by John A. McNamara -// Get rid of annoying MSVC warnings on debug builds about lengths of -// identifiers in template instantiations. -#ifdef _MSC_VER -#pragma warning( disable:4786 ) -#endif - -/*************************************************************************** - configurationreader.cpp - description - ------------------- - begin : Son Nov 10 2002 - copyright : (C) 2002 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "configurationreader.h" - -using namespace std; - -ConfigurationReader::ConfigurationReader(const string & configuration_path) -{ - ifstream in (configuration_path.c_str()); - fileFound=in; - if (fileFound) { - string line; - line.reserve(500); - unsigned int lineBegin; - size_t delimPos; - string paramName, paramValue; - while (getline(in, line)) { - lineBegin=line.find_first_not_of("\t "); - if ((line.size()>2) && (lineBegin!=string::npos) - && (line.at(lineBegin)!='#')) { //comment? - if (line[lineBegin]=='$') { // neuer Parametername? - delimPos=line.find("=",lineBegin)-1; - if (delimPos!=string::npos) { - paramName=StringTools::trimRight( - StringTools::lowerCase(line.substr(lineBegin+1, delimPos))); - parameterNames.push_back(paramName); - paramValue=line.substr(delimPos+2, line.length()); - } - } else { // line belongs to last parameter - paramValue=line; - } - if (parameterMap[paramName].empty()) { - parameterMap[paramName] = paramValue; - } else { - parameterMap[paramName]+= (" "+paramValue); - } - } //if ((lineBegin!=string::npos) && (line.at(lineBegin)!='#')) - } //while - in.close(); - } //if (in) -} - -ConfigurationReader::~ConfigurationReader() -{ -} - -bool ConfigurationReader::found() -{ - return fileFound; -} - -string &ConfigurationReader::getParameter(const string & paramName) -{ - return parameterMap[paramName] ; -} - -const char* ConfigurationReader::getCParameter(const string & paramName) -{ - return parameterMap[paramName].c_str() ; -} - -vector<string> &ConfigurationReader::getParameterNames() -{ - return parameterNames; -} -/*************************************************************************** - configurationreader.h - description - ------------------- - begin : Son Nov 10 2002 - copyright : (C) 2002 by Andrďż˝Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef CONFIGURATIONREADER_H -#define CONFIGURATIONREADER_H - -#include <string> -#include <sstream> -#include <map> -#include <iostream> -#include <fstream> -#include <vector> - -#include "stringtools.h" - -using namespace std; - -/** Maps parameter keys to values*/ -typedef map<string, string> ParameterMap; - - -/** \brief Class to handle ASCII config files - - Configuration file format:<br> - $ParamName=ParamValue<br> - ParamValue may be splittet over multiple lines<br> - ParamName is not case sensitive<br> - Comments start with # as the first character of a line - - **/ - -class ConfigurationReader - { - public: - /** Constructor - \param configuration_path Path to configuration file - */ - ConfigurationReader(const string & configuration_path); - ~ConfigurationReader(); - - /** \param paramName Name of parameter - \return Value of parameter */ - string &getParameter(const string & paramName); - - /** \param paramName Name of parameter - \return Value of parameter */ - const char* getCParameter(const string & paramName); - - /** \return True if config file exists */ - bool found(); - - /** \return List of parameter names */ - vector<string> &getParameterNames(); - - private: - ParameterMap parameterMap; - bool fileFound; - vector<string> parameterNames; - }; - -#endif -/*************************************************************************** - dataDir.cpp - description - ------------------- - begin : Sam Mďż˝ 1 2003 - copyright : (C) 2003 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "datadir.h" - -using namespace std; - -bool DataDir::searchDataDir(const string &userDefinedDir){ -#ifndef _WIN32 - - bool found = false; - //falls kein Datenverzeichnis angegeben, startIndex auf 1 setzen - int searchStartIndex=(userDefinedDir.empty()); - - string possibleDirs[] ={ userDefinedDir, - #ifdef HL_DATA_DIR - HL_DATA_DIR, - #endif - "/usr/share/highlight/" - }; - - for (int i=searchStartIndex;i< - #ifdef HL_DATA_DIR - 3 - #else - 2 - #endif - ;i++) - { - if (fileExists(possibleDirs[i])) - { - dataDir=possibleDirs[i]; - found = true; - } - if (found) { - break; - } - else { - if (!searchStartIndex) - cerr << "highlight: directory " - << userDefinedDir - << " specified by data-dir option not found.\n" - << " Searching another standard directory.\n"; - - } - } - return found; -#else - dataDir=userDefinedDir; - return true; -#endif - -} - -DataDir::DataDir() -{ -} - -void DataDir::setAdditionalDataDir(const string& dir){ - additionalDataDir=dir; -} - -const string &DataDir::getDir() -{ - return dataDir; -} - -const string DataDir::getLangDefDir() -{ - return dataDir+"langDefs"+Platform::pathSeparator; -} - -const string DataDir::getThemeDir() -{ - return dataDir+"themes"+Platform::pathSeparator; -} - -const string DataDir::getIndentSchemesDir() -{ - return dataDir+"indentSchemes"+Platform::pathSeparator; -} - - -const string DataDir::getAdditionalLangDefDir() -{ - return additionalDataDir+"langDefs"+Platform::pathSeparator; -} - -const string DataDir::getAdditionalThemeDir() -{ - return additionalDataDir+"themes"+Platform::pathSeparator; -} -const string DataDir::getAdditionalIndentSchemesDir() -{ - return additionalDataDir+"indentSchemes"+Platform::pathSeparator; -} - - -const string DataDir::getHelpMsgDir() -{ - return dataDir+"helpmsg"+Platform::pathSeparator; -} - -const string DataDir::searchForLangDef(const string & langDef){ - if (!additionalDataDir.empty()){ - string path=getAdditionalLangDefDir()+langDef; - if (fileExists(path)){ - return path; - } - } - return getLangDefDir()+langDef; -} - -const string DataDir::searchForTheme(const string & theme){ - if (!additionalDataDir.empty()){ - string path=getAdditionalThemeDir()+theme; - if (fileExists(path)){ - return path; - } - } - return getThemeDir()+theme; -} - -const string DataDir::searchForIndentScheme(const string & scheme){ - if (!additionalDataDir.empty()){ - string path=getAdditionalIndentSchemesDir()+scheme; - if (fileExists(path)){ - return path; - } - } - return getIndentSchemesDir()+scheme; -} - - -bool DataDir::fileExists(const string&f){ - ifstream file(f.c_str()); - bool exists=!file.fail(); - file.close(); - return exists; -} -/*************************************************************************** - datadir.h - description - ------------------- - begin : Sam Mďż˝ 1 2003 - copyright : (C) 2003 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef DATADIR_H -#define DATADIR_H - -#include <string> -#include <fstream> -#include <iostream> -//#include "stringtools.h" -#include "platform_fs.h" - -using namespace std; - - /** \brief Manages access to installation directories. - - Apart from the standard installation directory, one can define additional - search paths. - **/ - -class DataDir - { - string dataDir; - string additionalDataDir; - bool fileExists(const string&f); - - public: - - DataDir(); - - /** search for a valid installation directory - \param userDefinedDir Directory defined by user - \return True if directory was found */ - bool searchDataDir(const string &userDefinedDir); - - /** add another installation directory, which is added to search path - \param dir Directory defined by user */ - void setAdditionalDataDir(const string& dir); - - /** \return Data installation directory */ - const string & getDir() ; - - /** \return Location of languafe definitions */ - const string getLangDefDir() ; - - /** \return Location of themes */ - const string getThemeDir() ; - - /** \return Location of indentation schemes */ - const string getIndentSchemesDir(); - - /** \return User defined location of indentation schemes */ - const string getAdditionalIndentSchemesDir(); - - /** \return User defined location of languafe definitions */ - const string getAdditionalLangDefDir() ; - - /** \return User defined location of themes */ - const string getAdditionalThemeDir() ; - - /** \return Location of help files */ - const string getHelpMsgDir() ; - - /** \param langDef Name of language definition - \return Absolute path of definiton found in a data directory */ - const string searchForLangDef(const string & langDef); - - /** \param theme Name of colour theme file - \return Absolute path of theme found in a data directory */ - const string searchForTheme(const string & theme); - - /** \param scheme Name of indent scheme file - \return Absolute path of theme found in a data directory */ - const string searchForIndentScheme(const string & scheme); - }; - -#endif -/*************************************************************************** - documentstyle.cpp - description - ------------------- - begin : Son Nov 10 2002 - copyright : (C) 2002 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "documentstyle.h" - -namespace highlight { - -DocumentStyle::DocumentStyle(const string &styleDefinitionFile) -{ - fileFound=load(styleDefinitionFile); -} -DocumentStyle::DocumentStyle():fileFound(false) -{} - -bool DocumentStyle::load(const string &styleDefinitionPath) -{ - ConfigurationReader styleConfig(styleDefinitionPath); - if (styleConfig.found()){ - fontsize = styleConfig.getParameter("fontsize"); - bgColour.setRGBValues(styleConfig.getParameter("bgcolour")); - defaultElem.set(styleConfig.getParameter("defaultcolour")); - comment.set(styleConfig.getParameter("comment")); - directive.set(styleConfig.getParameter("directive")); - str.set(styleConfig.getParameter("string")); - escapeChar.set(styleConfig.getParameter("escapechar")); - number.set(styleConfig.getParameter("number")); - dstr.set(styleConfig.getParameter("string_directive")); - line.set(styleConfig.getParameter("line")); - - - string tmpstr; - // TODO: Remove this check as soon as all themes have a brackets attribute - tmpstr=styleConfig.getParameter("symbol"); - if (tmpstr.empty()) { - tmpstr=styleConfig.getParameter("defaultcolour"); - } - symbol.set(tmpstr); - -// TODO: Remove this check as soon as all themes have a sl-comment attribute - tmpstr=styleConfig.getParameter("sl-comment"); - if (tmpstr.empty()) { - tmpstr=styleConfig.getParameter("comment"); - } - slcomment.set(tmpstr); - - string paramVal; - vector<string> paramNames=styleConfig.getParameterNames(); - - //collect keyword classes, save corresponding style definition - for (unsigned int i=0;i<paramNames.size();i++){ - paramVal=paramNames[i]; - if (paramVal.find("kw_class") != string::npos){ - keywordStyles.insert(make_pair(StringTools::getParantheseVal(paramVal), - new ElementStyle(styleConfig.getParameter(paramVal)))); - } - } - - fileFound = true; - } - else { - fileFound = false; - } - return fileFound; -} - -DocumentStyle::~DocumentStyle() -{ - for(KSIterator iter = keywordStyles.begin(); iter != keywordStyles.end(); iter++){ - delete (*iter).second; //remove ElementStyle* - } -} - -string& DocumentStyle::getFontSize() - { - return fontsize; - } -StyleColour& DocumentStyle::getBgColour() - { - return bgColour; - } -ElementStyle& DocumentStyle::getDefaultStyle() - { - return defaultElem; - } -ElementStyle& DocumentStyle::getCommentStyle() - { - return comment; - } -ElementStyle& DocumentStyle::getSingleLineCommentStyle() - { - return slcomment; - } - - -ElementStyle& DocumentStyle::getStringStyle() - { - return str; - } -ElementStyle& DocumentStyle::getDirectiveStringStyle() - { - return dstr; - } -ElementStyle& DocumentStyle::getEscapeCharStyle() - { - return escapeChar; - } -ElementStyle& DocumentStyle::getNumberStyle() - { - return number; - } -ElementStyle& DocumentStyle::getDirectiveStyle() - { - return directive; - } -ElementStyle& DocumentStyle::getLineStyle() - { - return line; - } -ElementStyle& DocumentStyle::getSymbolStyle() - { - return symbol; - } -bool DocumentStyle::found () const - { - return fileFound; - } -ElementStyle& DocumentStyle::getKeywordStyle(const string &className){ - if (!keywordStyles.count(className)) return defaultElem; - return *keywordStyles[className]; -} - -vector <string> DocumentStyle::getClassNames(){ - vector <string> kwClassNames; - for(KSIterator iter = keywordStyles.begin(); iter != keywordStyles.end(); iter++){ - kwClassNames.push_back( (*iter).first); - } - return kwClassNames; -} - -KeywordStyles& DocumentStyle::getKeywordStyles(){ - return keywordStyles; -} - -} -/*************************************************************************** - documentstyle.h - description - ------------------- - begin : Son Nov 10 2002 - copyright : (C) 2002 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef DOCUMENTSTYLE_H -#define DOCUMENTSTYLE_H - -#include <string> -#include <iostream> -#include "configurationreader.h" -#include "elementstyle.h" -#include "stylecolour.h" - -using namespace std; - -namespace highlight { - -/** maps keyword class names and the corresponding formatting information*/ -typedef map <string, ElementStyle*> KeywordStyles; - -/** iterator for keyword styles*/ -typedef KeywordStyles::iterator KSIterator; - -/** \brief Contains information about document formatting properties. - -* @author Andre Simon -*/ - -class DocumentStyle - { - private: - ElementStyle comment, slcomment, str, dstr, - escapeChar, number, directive, line, symbol; - ElementStyle defaultElem; - StyleColour bgColour; - - string fontsize; - bool fileFound; - - KeywordStyles keywordStyles; - - public: - /** Constructor - \param styleDefinitionPath Style definition path */ - DocumentStyle(const string & styleDefinitionPath); - DocumentStyle(); - ~DocumentStyle(); - - /** load sytle definition - \param styleDefinitionFile Style definition path - \return True if successfull */ - bool load(const string & styleDefinitionFile); - - /** \return class names defined in the theme file */ - vector <string> getClassNames(); - - /** \return keyword styles */ - KeywordStyles& getKeywordStyles(); - - /** \return Font size */ - string &getFontSize() ; - - /** \return Background colour*/ - StyleColour& getBgColour(); - - /** \return Style of default (unrecognized) strings */ - ElementStyle & getDefaultStyle() ; - - /** \return Comment style*/ - ElementStyle & getCommentStyle() ; - - /** \return Single line comment style*/ - ElementStyle& getSingleLineCommentStyle() ; - - /** \return Keyword style*/ - ElementStyle & getKeywordStyle() ; - - /** \return String style*/ - ElementStyle & getStringStyle() ; - - /** \return Directive line string style*/ - ElementStyle & getDirectiveStringStyle() ; - - /** \return Escape character style*/ - ElementStyle & getEscapeCharStyle() ; - - /** \return Number style*/ - ElementStyle & getNumberStyle() ; - - /** \return Directive style*/ - ElementStyle & getDirectiveStyle() ; - - /** \return Type style*/ - ElementStyle & getTypeStyle() ; - - /** \return Line number style*/ - ElementStyle & getLineStyle() ; - - /** \return Bracket style*/ - ElementStyle & getSymbolStyle() ; - - /** - \param className Name of keyword class - \return keyword style of the given className - */ - ElementStyle & getKeywordStyle(const string &className); - - /** \return True if language definition was found */ - bool found() const ; - }; - -} - -#endif -/*************************************************************************** - elementstyle.cpp - description - ------------------- - begin : Son Nov 10 2002 - copyright : (C) 2002 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "elementstyle.h" - -namespace highlight { - -ElementStyle::ElementStyle(StyleColour col, bool b, bool i, bool u) - : colour(col) , bold(b), italic(i), underline(u) -{} - -ElementStyle:: ElementStyle(const string & elementStyleString) - : bold(false), italic(false), underline(false) -{ - set(elementStyleString); -} - -ElementStyle::ElementStyle() - : bold(false), italic(false), underline(false) -{} - -void ElementStyle::set(const string & elementStyleString){ - - istringstream valueStream(elementStyleString.c_str()); - string r, g, b, attr; - valueStream >> r; - valueStream >> g; - valueStream >> b; - colour.setRedValue(r); - colour.setGreenValue(g); - colour.setBlueValue(b); - while ( valueStream >> attr) - { - if (attr=="italic") - { - italic = true; - } - else if (attr=="bold") - { - bold = true; - } - else if (attr=="underline") - { - underline = true; - } - } -} - -ElementStyle::~ElementStyle() -{} - -bool ElementStyle::isItalic() const -{ - return italic; -} -bool ElementStyle::isBold() const -{ - return bold; -} -bool ElementStyle::isUnderline() const -{ - return underline; -} -StyleColour ElementStyle::getColour() const -{ - return colour; -} - -} -/*************************************************************************** - elementstyle.h - description - ------------------- - begin : Son Nov 10 2002 - copyright : (C) 2002 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef ELEMENTSTYLE_H -#define ELEMENTSTYLE_H - -#include <sstream> - -#include "stylecolour.h" - -using namespace std; - -namespace highlight { - -/** \brief The class stores the basic text formatting properties. - -* @author Andre Simon -*/ - -class ElementStyle { - public: - - /** Constructor - \param col Style colour - \param b Bold flag - \param i Italic flag - \param u Underline flag */ - ElementStyle(StyleColour col, bool b, bool i, bool u); - - /** Constuctor - \param elementStyleString String with fotmatting information */ - ElementStyle(const string & elementStyleString); - - ElementStyle(); - - ~ElementStyle(); - - /** initialize object - \param elementStyleString String which contains formatting attributes - */ - void set(const string & elementStyleString); - - /** \return True if italic */ - bool isItalic() const; - - /** \return True if bold */ - bool isBold() const; - - /** \return True if underline */ - bool isUnderline() const; - - /** \return Element colour */ - StyleColour getColour() const; - - private: - StyleColour colour; - bool bold, italic, underline; - }; - -} - -#endif -// -// C++ Interface: enums -// -// Description: -// -// -// Author: Andre Simon <andre.simon1@gmx.de>, (C) 2004 -// -// Copyright: See COPYING file that comes with this distribution -// -// - -#ifndef ENUMS_H -#define ENUMS_H - -namespace highlight { - -/** states which may occour during input file parsing*/ -enum State { - STANDARD=0, - STRING, - NUMBER, - SL_COMMENT, - ML_COMMENT_BEGIN, - ESC_CHAR, - DIRECTIVE_LINE, - DIRECTIVE_STRING, - LINENUMBER, - SYMBOL, - - // Konstanten ab hier duefen nicht mehr als Array-Indizes benutzt werden!! - KEYWORD, - ML_COMMENT_END, - DIRECTIVE_LINE_END, - TAG_BEGIN, - TAG_END, - KEYWORD_BEGIN, - KEYWORD_END, - - _UNKNOWN=100, - _EOL, - _EOF, - _WS -} ; - -/** Parser return values*/ -enum ParseError{ - PARSE_OK, - BAD_INPUT=1, - BAD_OUTPUT=2, - BAD_STYLE=4 -}; - -/** line wrapping modes*/ -enum WrapMode { - WRAP_DISABLED, - WRAP_SIMPLE, - WRAP_DEFAULT -}; - -/** language definition loading results*/ -enum LoadResult{ - LOAD_FAILED, - LOAD_NEW, - LOAD_NONE -}; - -/** output formats */ -enum OutputType { - HTML, - XHTML, - TEX, - LATEX, - RTF, - XSLFO, - XML, - ANSI -}; - -} - -#endif -/* Getopt for GNU. - NOTE: getopt is now part of the C library, so if you don't know what - "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu - before changing it! - - Copyright (C) 1987, 88, 89, 90, 91, 92, 1993 - Free Software Foundation, Inc. - - 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, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#ifndef __STDC__ -# ifndef const -# define const -# endif -#endif - -/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>. */ -#ifndef _NO_PROTO -#define _NO_PROTO -#endif - -#include <cstdio> -#include <cstring> -//#include "tailor.h" - -/* Comment out all this code if we are using the GNU C Library, and are not - actually compiling the library itself. This code is part of the GNU C - Library, but also included in many other GNU distributions. Compiling - and linking in this code is a waste when using the GNU C library - (especially if it is a shared library). Rather than having every GNU - program understand `configure --with-gnu-libc' and omit the object files, - it is simpler to just do this in the source for each such file. */ - -#if defined (_LIBC) || !defined (__GNU_LIBRARY__) - - -/* This needs to come after some library #include - to get __GNU_LIBRARY__ defined. */ -#ifdef __GNU_LIBRARY__ -/* Don't include stdlib.h for non-GNU C libraries because some of them - contain conflicting prototypes for getopt. */ -#include <stdlib.h> -#endif /* GNU C library. */ - -/* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a - long-named option. Because this is not POSIX.2 compliant, it is - being phased out. */ -/* #define GETOPT_COMPAT */ - -/* This version of `getopt' appears to the caller like standard Unix `getopt' - but it behaves differently for the user, since it allows the user - to intersperse the options with the other arguments. - - As `getopt' works, it permutes the elements of ARGV so that, - when it is done, all the options precede everything else. Thus - all application programs are extended to handle flexible argument order. - - Setting the environment variable POSIXLY_CORRECT disables permutation. - Then the behavior is completely standard. - - GNU application programs can use a third alternative mode in which - they can distinguish the relative order of options and other arguments. */ - -#include "getopt.h" - -/* For communication from `getopt' to the caller. - When `getopt' finds an option that takes an argument, - the argument value is returned here. - Also, when `ordering' is RETURN_IN_ORDER, - each non-option ARGV-element is returned here. */ - -char *optarg = 0; - -/* Index in ARGV of the next element to be scanned. - This is used for communication to and from the caller - and for communication between successive calls to `getopt'. - - On entry to `getopt', zero means this is the first call; initialize. - - When `getopt' returns EOF, this is the index of the first of the - non-option elements that the caller should itself scan. - - Otherwise, `optind' communicates from one call to the next - how much of ARGV has been scanned so far. */ - -/* XXX 1003.2 says this must be 1 before any call. */ -int optind = 0; - -/* The next char to be scanned in the option-element - in which the last option character we returned was found. - This allows us to pick up the scan where we left off. - - If this is zero, or a null string, it means resume the scan - by advancing to the next ARGV-element. */ - -static char *nextchar; - -/* Callers store zero here to inhibit the error message - for unrecognized options. */ - -int opterr = 1; - -/* Set to an option character which was unrecognized. - This must be initialized on some systems to avoid linking in the - system's own getopt implementation. */ - -#define BAD_OPTION '\0' -int optopt = BAD_OPTION; - -/* Describe how to deal with options that follow non-option ARGV-elements. - - If the caller did not specify anything, - the default is REQUIRE_ORDER if the environment variable - POSIXLY_CORRECT is defined, PERMUTE otherwise. - - REQUIRE_ORDER means don't recognize them as options; - stop option processing when the first non-option is seen. - This is what Unix does. - This mode of operation is selected by either setting the environment - variable POSIXLY_CORRECT, or using `+' as the first character - of the list of option characters. - - PERMUTE is the default. We permute the contents of ARGV as we scan, - so that eventually all the non-options are at the end. This allows options - to be given in any order, even with programs that were not written to - expect this. - - RETURN_IN_ORDER is an option available to programs that were written - to expect options and other ARGV-elements in any order and that care about - the ordering of the two. We describe each non-option ARGV-element - as if it were the argument of an option with character code 1. - Using `-' as the first character of the list of option characters - selects this mode of operation. - - The special argument `--' forces an end of option-scanning regardless - of the value of `ordering'. In the case of RETURN_IN_ORDER, only - `--' can cause `getopt' to return EOF with `optind' != ARGC. */ - -static enum -{ - REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER -} ordering; - -#ifdef __GNU_LIBRARY__ -/* We want to avoid inclusion of string.h with non-GNU libraries - because there are many ways it can cause trouble. - On some systems, it contains special magic macros that don't work - in GCC. */ -#include <string.h> -#define my_index strchr -#define my_strlen strlen -#else - -/* Avoid depending on library functions or files - whose names are inconsistent. */ - -#if __STDC__ || defined(PROTO) - #ifndef _WIN32 - // Solaris compilation fix - extern "C" { - char *getenv(const char *name); - int strncmp(const char *s1, const char *s2, int n); - } - // extern char *getenv(const char *name); - // extern int strncmp(const char *s1, const char *s2, int n); - #endif - extern int strcmp (const char *s1, const char *s2); - static int my_strlen(const char *s); - static char *my_index (const char *str, int chr); -#else - #ifndef _WIN32 - extern char *getenv (); - #endif -#endif - -static int -my_strlen (const char *str) - -{ - int n = 0; - while (*str++) - n++; - return n; -} - -static char * -my_index ( const char *str, - int chr) - -{ - while (*str) - { - if (*str == chr) - return (char *) str; - str++; - } - return 0; -} - -#endif /* GNU C library. */ - -/* Handle permutation of arguments. */ - -/* Describe the part of ARGV that contains non-options that have - been skipped. `first_nonopt' is the index in ARGV of the first of them; - `last_nonopt' is the index after the last of them. */ - -static int first_nonopt; -static int last_nonopt; - -/* Exchange two adjacent subsequences of ARGV. - One subsequence is elements [first_nonopt,last_nonopt) - which contains all the non-options that have been skipped so far. - The other is elements [last_nonopt,optind), which contains all - the options processed since those non-options were skipped. - - `first_nonopt' and `last_nonopt' are relocated so that they describe - the new indices of the non-options in ARGV after they are moved. - - To perform the swap, we first reverse the order of all elements. So - all options now come before all non options, but they are in the - wrong order. So we put back the options and non options in original - order by reversing them again. For example: - original input: a b c -x -y - reverse all: -y -x c b a - reverse options: -x -y c b a - reverse non options: -x -y a b c -*/ - -#if __STDC__ || defined(PROTO) -static void exchange (char **argv); -#endif - -static void -exchange (char **argv) - -{ - char *temp, **first, **last; - - /* Reverse all the elements [first_nonopt, optind) */ - first = &argv[first_nonopt]; - last = &argv[optind-1]; - while (first < last) { - temp = *first; *first = *last; *last = temp; first++; last--; - } - /* Put back the options in order */ - first = &argv[first_nonopt]; - first_nonopt += (optind - last_nonopt); - last = &argv[first_nonopt - 1]; - while (first < last) { - temp = *first; *first = *last; *last = temp; first++; last--; - } - - /* Put back the non options in order */ - first = &argv[first_nonopt]; - last_nonopt = optind; - last = &argv[last_nonopt-1]; - while (first < last) { - temp = *first; *first = *last; *last = temp; first++; last--; - } -} - -/* Scan elements of ARGV (whose length is ARGC) for option characters - given in OPTSTRING. - - If an element of ARGV starts with '-', and is not exactly "-" or "--", - then it is an option element. The characters of this element - (aside from the initial '-') are option characters. If `getopt' - is called repeatedly, it returns successively each of the option characters - from each of the option elements. - - If `getopt' finds another option character, it returns that character, - updating `optind' and `nextchar' so that the next call to `getopt' can - resume the scan with the following option character or ARGV-element. - - If there are no more option characters, `getopt' returns `EOF'. - Then `optind' is the index in ARGV of the first ARGV-element - that is not an option. (The ARGV-elements have been permuted - so that those that are not options now come last.) - - OPTSTRING is a string containing the legitimate option characters. - If an option character is seen that is not listed in OPTSTRING, - return BAD_OPTION after printing an error message. If you set `opterr' to - zero, the error message is suppressed but we still return BAD_OPTION. - - If a char in OPTSTRING is followed by a colon, that means it wants an arg, - so the following text in the same ARGV-element, or the text of the following - ARGV-element, is returned in `optarg'. Two colons mean an option that - wants an optional arg; if there is text in the current ARGV-element, - it is returned in `optarg', otherwise `optarg' is set to zero. - - If OPTSTRING starts with `-' or `+', it requests different methods of - handling the non-option ARGV-elements. - See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. - - Long-named options begin with `--' instead of `-'. - Their names may be abbreviated as long as the abbreviation is unique - or is an exact match for some defined option. If they have an - argument, it follows the option name in the same ARGV-element, separated - from the option name by a `=', or else the in next ARGV-element. - When `getopt' finds a long-named option, it returns 0 if that option's - `flag' field is nonzero, the value of the option's `val' field - if the `flag' field is zero. - - The elements of ARGV aren't really const, because we permute them. - But we pretend they're const in the prototype to be compatible - with other systems. - - LONGOPTS is a vector of `struct option' terminated by an - element containing a name which is zero. - - LONGIND returns the index in LONGOPT of the long-named option found. - It is only valid when a long-named option has been found by the most - recent call. - - If LONG_ONLY is nonzero, '-' as well as '--' can introduce - long-named options. */ - -int -_getopt_internal ( int argc, - char *const *argv, - const char *optstring, - const struct option *longopts, - int *longind, - int long_only) - -{ - int option_index; - - optarg = 0; - - /* Initialize the internal data when the first call is made. - Start processing options with ARGV-element 1 (since ARGV-element 0 - is the program name); the sequence of previously skipped - non-option ARGV-elements is empty. */ - - if (optind == 0) - { - first_nonopt = last_nonopt = optind = 1; - - nextchar = NULL; - - /* Determine how to handle the ordering of options and nonoptions. */ - - if (optstring[0] == '-') - { - ordering = RETURN_IN_ORDER; - ++optstring; - } - else if (optstring[0] == '+') - { - ordering = REQUIRE_ORDER; - ++optstring; - } - #ifndef _WIN32 - else if (getenv ("POSIXLY_CORRECT") != NULL) - ordering = REQUIRE_ORDER; - #endif - else - ordering = PERMUTE; - } - - if (nextchar == NULL || *nextchar == '\0') - { - if (ordering == PERMUTE) - { - /* If we have just processed some options following some non-options, - exchange them so that the options come first. */ - - if (first_nonopt != last_nonopt && last_nonopt != optind) - exchange ((char **) argv); - else if (last_nonopt != optind) - first_nonopt = optind; - - /* Now skip any additional non-options - and extend the range of non-options previously skipped. */ - - while (optind < argc - && (argv[optind][0] != '-' || argv[optind][1] == '\0') -#ifdef GETOPT_COMPAT - && (longopts == NULL - || argv[optind][0] != '+' || argv[optind][1] == '\0') -#endif /* GETOPT_COMPAT */ - ) - optind++; - last_nonopt = optind; - } - - /* Special ARGV-element `--' means premature end of options. - Skip it like a null option, - then exchange with previous non-options as if it were an option, - then skip everything else like a non-option. */ - - if (optind != argc && !strcmp (argv[optind], "--")) - { - optind++; - - if (first_nonopt != last_nonopt && last_nonopt != optind) - exchange ((char **) argv); - else if (first_nonopt == last_nonopt) - first_nonopt = optind; - last_nonopt = argc; - - optind = argc; - } - - /* If we have done all the ARGV-elements, stop the scan - and back over any non-options that we skipped and permuted. */ - - if (optind == argc) - { - /* Set the next-arg-index to point at the non-options - that we previously skipped, so the caller will digest them. */ - if (first_nonopt != last_nonopt) - optind = first_nonopt; - return EOF; - } - - /* If we have come to a non-option and did not permute it, - either stop the scan or describe it to the caller and pass it by. */ - - if ((argv[optind][0] != '-' || argv[optind][1] == '\0') -#ifdef GETOPT_COMPAT - && (longopts == NULL - || argv[optind][0] != '+' || argv[optind][1] == '\0') -#endif /* GETOPT_COMPAT */ - ) - { - if (ordering == REQUIRE_ORDER) - return EOF; - optarg = argv[optind++]; - return 1; - } - - /* We have found another option-ARGV-element. - Start decoding its characters. */ - - nextchar = (argv[optind] + 1 - + (longopts != NULL && argv[optind][1] == '-')); - } - - if (longopts != NULL - && ((argv[optind][0] == '-' - && (argv[optind][1] == '-' || long_only)) -#ifdef GETOPT_COMPAT - || argv[optind][0] == '+' -#endif /* GETOPT_COMPAT */ - )) - { - const struct option *p; - char *s = nextchar; - int exact = 0; - int ambig = 0; - const struct option *pfound = NULL; - int indfound = 0; - - while (*s && *s != '=') - s++; - - /* Test all options for either exact match or abbreviated matches. */ - for (p = longopts, option_index = 0; p->name; - p++, option_index++) - if (!strncmp (p->name, nextchar, s - nextchar)) - { - if (s - nextchar == my_strlen (p->name)) - { - /* Exact match found. */ - pfound = p; - indfound = option_index; - exact = 1; - break; - } - else if (pfound == NULL) - { - /* First nonexact match found. */ - pfound = p; - indfound = option_index; - } - else - /* Second nonexact match found. */ - ambig = 1; - } - - if (ambig && !exact) - { - if (opterr) - fprintf (stderr, "%s: option `%s' is ambiguous\n", - argv[0], argv[optind]); - nextchar += my_strlen (nextchar); - optind++; - return BAD_OPTION; - } - - if (pfound != NULL) - { - option_index = indfound; - optind++; - if (*s) - { - /* Don't test has_arg with >, because some C compilers don't - allow it to be used on enums. */ - if (pfound->has_arg) - optarg = s + 1; - else - { - if (opterr) - { - if (argv[optind - 1][1] == '-') - /* --option */ - fprintf (stderr, - "%s: option `--%s' doesn't allow an argument\n", - argv[0], pfound->name); - else - /* +option or -option */ - fprintf (stderr, - "%s: option `%c%s' doesn't allow an argument\n", - argv[0], argv[optind - 1][0], pfound->name); - } - nextchar += my_strlen (nextchar); - return BAD_OPTION; - } - } - else if (pfound->has_arg == 1) - { - if (optind < argc) - optarg = argv[optind++]; - else - { - if (opterr) - fprintf (stderr, "%s: option `%s' requires an argument\n", - argv[0], argv[optind - 1]); - nextchar += my_strlen (nextchar); - return optstring[0] == ':' ? ':' : BAD_OPTION; - } - } - nextchar += my_strlen (nextchar); - if (longind != NULL) - *longind = option_index; - if (pfound->flag) - { - *(pfound->flag) = pfound->val; - return 0; - } - return pfound->val; - } - /* Can't find it as a long option. If this is not getopt_long_only, - or the option starts with '--' or is not a valid short - option, then it's an error. - Otherwise interpret it as a short option. */ - if (!long_only || argv[optind][1] == '-' -#ifdef GETOPT_COMPAT - || argv[optind][0] == '+' -#endif /* GETOPT_COMPAT */ - || my_index (optstring, *nextchar) == NULL) - { - if (opterr) - { - if (argv[optind][1] == '-') - /* --option */ - fprintf (stderr, "%s: unrecognized option `--%s'\n", - argv[0], nextchar); - else - /* +option or -option */ - fprintf (stderr, "%s: unrecognized option `%c%s'\n", - argv[0], argv[optind][0], nextchar); - } - nextchar = (char *) ""; - optind++; - return BAD_OPTION; - } - } - - /* Look at and handle the next option-character. */ - - { - char c = *nextchar++; - char *temp = my_index (optstring, c); - - /* Increment `optind' when we start to process its last character. */ - if (*nextchar == '\0') - ++optind; - - if (temp == NULL || c == ':') - { - if (opterr) - { -#if 0 - if (c < 040 || c >= 0177) - fprintf (stderr, "%s: unrecognized option, character code 0%o\n", - argv[0], c); - else - fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c); -#else - /* 1003.2 specifies the format of this message. */ - fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c); -#endif - } - optopt = c; - return BAD_OPTION; - } - if (temp[1] == ':') - { - if (temp[2] == ':') - { - /* This is an option that accepts an argument optionally. */ - if (*nextchar != '\0') - { - optarg = nextchar; - optind++; - } - else - optarg = 0; - nextchar = NULL; - } - else - { - /* This is an option that requires an argument. */ - if (*nextchar != '\0') - { - optarg = nextchar; - /* If we end this ARGV-element by taking the rest as an arg, - we must advance to the next element now. */ - optind++; - } - else if (optind == argc) - { - if (opterr) - { -#if 0 - fprintf (stderr, "%s: option `-%c' requires an argument\n", - argv[0], c); -#else - /* 1003.2 specifies the format of this message. */ - fprintf (stderr, "%s: option requires an argument -- %c\n", - argv[0], c); -#endif - } - optopt = c; - if (optstring[0] == ':') - c = ':'; - else - c = BAD_OPTION; - } - else - /* We already incremented `optind' once; - increment it again when taking next ARGV-elt as argument. */ - optarg = argv[optind++]; - nextchar = NULL; - } - } - return c; - } -} - -int -getopt ( int argc, - char *const *argv, - const char *optstring) - -{ - return _getopt_internal (argc, argv, optstring, - (const struct option *) 0, - (int *) 0, - 0); -} - -int -getopt_long ( int argc, - char *const *argv, - const char *options, - const struct option *long_options, - int *opt_index) - -{ - return _getopt_internal (argc, argv, options, long_options, opt_index, 0); -} - -#endif /* _LIBC or not __GNU_LIBRARY__. */ - -#ifdef TEST - -/* Compile with -DTEST to make an executable for use in testing - the above definition of `getopt'. */ - -int -main (argc, argv) - int argc; - char **argv; -{ - int c; - int digit_optind = 0; - - while (1) - { - int this_option_optind = optind ? optind : 1; - - c = getopt (argc, argv, "abc:d:0123456789"); - if (c == EOF) - break; - - switch (c) - { - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - if (digit_optind != 0 && digit_optind != this_option_optind) - printf ("digits occur in two different argv-elements.\n"); - digit_optind = this_option_optind; - printf ("option %c\n", c); - break; - - case 'a': - printf ("option a\n"); - break; - - case 'b': - printf ("option b\n"); - break; - - case 'c': - printf ("option c with value `%s'\n", optarg); - break; - - case BAD_OPTION: - break; - - default: - printf ("?? getopt returned character code 0%o ??\n", c); - } - } - - if (optind < argc) - { - printf ("non-option ARGV-elements: "); - while (optind < argc) - printf ("%s ", argv[optind++]); - printf ("\n"); - } - - exit (0); -} - -#endif /* TEST */ - -/* Declarations for getopt. - Copyright (C) 1989-1994, 1996-1999, 2001 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - The GNU C Library 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 - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library; if not, write to the Free - Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - 02111-1307 USA. */ - -#ifndef _GETOPT_H - -#ifndef __need_getopt -# define _GETOPT_H 1 -#endif - -/* If __GNU_LIBRARY__ is not already defined, either we are being used - standalone, or this is the first header included in the source file. - If we are being used with glibc, we need to include <features.h>, but - that does not exist if we are standalone. So: if __GNU_LIBRARY__ is - not defined, include <ctype.h>, which will pull in <features.h> for us - if it's from glibc. (Why ctype.h? It's guaranteed to exist and it - doesn't flood the namespace with stuff the way some other headers do.) */ -#if !defined __GNU_LIBRARY__ -# include <ctype.h> -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -/* For communication from `getopt' to the caller. - When `getopt' finds an option that takes an argument, - the argument value is returned here. - Also, when `ordering' is RETURN_IN_ORDER, - each non-option ARGV-element is returned here. */ - -extern char *optarg; - -/* Index in ARGV of the next element to be scanned. - This is used for communication to and from the caller - and for communication between successive calls to `getopt'. - - On entry to `getopt', zero means this is the first call; initialize. - - When `getopt' returns -1, this is the index of the first of the - non-option elements that the caller should itself scan. - - Otherwise, `optind' communicates from one call to the next - how much of ARGV has been scanned so far. */ - -extern int optind; - -/* Callers store zero here to inhibit the error message `getopt' prints - for unrecognized options. */ - -extern int opterr; - -/* Set to an option character which was unrecognized. */ - -extern int optopt; - -#ifndef __need_getopt -/* Describe the long-named options requested by the application. - The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector - of `struct option' terminated by an element containing a name which is - zero. - - The field `has_arg' is: - no_argument (or 0) if the option does not take an argument, - required_argument (or 1) if the option requires an argument, - optional_argument (or 2) if the option takes an optional argument. - - If the field `flag' is not NULL, it points to a variable that is set - to the value given in the field `val' when the option is found, but - left unchanged if the option is not found. - - To have a long-named option do something other than set an `int' to - a compiled-in constant, such as set a value from `optarg', set the - option's `flag' field to zero and its `val' field to a nonzero - value (the equivalent single-letter option character, if there is - one). For long options that have a zero `flag' field, `getopt' - returns the contents of the `val' field. */ - -struct option -{ -# if (defined __STDC__ && __STDC__) || defined __cplusplus - const char *name; -# else - char *name; -# endif - /* has_arg can't be an enum because some compilers complain about - type mismatches in all the code that assumes it is an int. */ - int has_arg; - int *flag; - int val; -}; - -/* Names for the values of the `has_arg' field of `struct option'. */ - -# define no_argument 0 -# define required_argument 1 -# define optional_argument 2 -#endif /* need getopt */ - - -/* Get definitions and prototypes for functions to process the - arguments in ARGV (ARGC of them, minus the program name) for - options given in OPTS. - - Return the option character from OPTS just read. Return -1 when - there are no more options. For unrecognized options, or options - missing arguments, `optopt' is set to the option letter, and '?' is - returned. - - The OPTS string is a list of characters which are recognized option - letters, optionally followed by colons, specifying that that letter - takes an argument, to be placed in `optarg'. - - If a letter in OPTS is followed by two colons, its argument is - optional. This behavior is specific to the GNU `getopt'. - - The argument `--' causes premature termination of argument - scanning, explicitly telling `getopt' that there are no more - options. - - If OPTS begins with `--', then non-option arguments are treated as - arguments to the option '\0'. This behavior is specific to the GNU - `getopt'. */ - -#if (defined __STDC__ && __STDC__) || defined __cplusplus -# ifdef __GNU_LIBRARY__ -/* Many other libraries have conflicting prototypes for getopt, with - differences in the consts, in stdlib.h. To avoid compilation - errors, only prototype getopt for the GNU C library. */ -extern int getopt (int ___argc, char *const *___argv, const char *__shortopts); -# else /* not __GNU_LIBRARY__ */ -// Solaris compilation fix -//extern int getopt (); -# endif /* __GNU_LIBRARY__ */ - -# ifndef __need_getopt -extern int getopt_long (int ___argc, char *const *___argv, - const char *__shortopts, - const struct option *__longopts, int *__longind); -extern int getopt_long_only (int ___argc, char *const *___argv, - const char *__shortopts, - const struct option *__longopts, int *__longind); - -/* Internal only. Users should not call this directly. */ -extern int _getopt_internal (int ___argc, char *const *___argv, - const char *__shortopts, - const struct option *__longopts, int *__longind, - int __long_only); -# endif -#else /* not __STDC__ */ -extern int getopt (); -# ifndef __need_getopt -extern int getopt_long (); -extern int getopt_long_only (); - -extern int _getopt_internal (); -# endif -#endif /* __STDC__ */ - -#ifdef __cplusplus -} -#endif - -/* Make sure we later can get all the definitions and declarations. */ -#undef __need_getopt - -#endif /* getopt.h */ -/*************************************************************************** - help.cpp - description - ------------------- - begin : Die Apr 23 2002 - copyright : (C) 2002 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "help.h" - -namespace Help - { - -/** gibt Hilfetext auf Konsole aus */ - - void printHelp(const std::string & helpFilePath) - { - std::ifstream helpFile(helpFilePath.c_str()); - std::string line; - if (helpFile){ - while (getline(helpFile, line)) - std::cout << line << "\n"; - helpFile.close(); - } - else { - std::cerr <<"highlight: Could not read "<< helpFilePath << "\n"; - } - } - -} -/*************************************************************************** - help.h - description - ------------------- - begin : Die Apr 23 2002 - copyright : (C) 2002 by AndĂ© Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef HELP_H -#define HELP_H - -#include <iostream> -#include <fstream> -#include <string> - -/**\ brief COntains methods for printing help messages - *@author Andre Simon - */ -namespace Help - { - /** print help message to stdout */ - void printHelp(const std::string &); - } - -#endif -/*************************************************************************** - htmlcode.cpp - description - ------------------- - begin : Wed Nov 28 2001 - copyright : (C) 2001 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "htmlgenerator.h" - -using namespace std; - -namespace highlight { - - -HtmlGenerator::HtmlGenerator(void) -{} - -string HtmlGenerator::formatStyleAttributes(const string & elemName, - const ElementStyle & elem) -{ - ostringstream s; - s << "."<<elemName<<"\t{ color:#" - << (elem.getColour().getHexRedValue()) - << (elem.getColour().getHexGreenValue()) - << (elem.getColour().getHexBlueValue() ) - << ( elem.isBold() ?"; font-weight:bold" :"" ) - << ( elem.isItalic() ?"; font-style:italic" :"" ) - << ( elem.isUnderline() ?"; text-decoration:underline" :"" ) - << "; }\n" ; - return s.str(); -} - -string HtmlGenerator::getOpenTag(const string& styleName ){ - return "<span class=\""+styleName+"\">"; -} - -HtmlGenerator::HtmlGenerator ( - const string &cssStyle, - const string &enc, - bool omitEnc, - bool withAnchors) - : CodeGenerator( cssStyle), - brTag("<br>"), - hrTag("<hr>"), - idAttr("name"), - fileSuffix(".html"), - encoding(enc), - omitEncoding(omitEnc), - HTML_FOOTER( - "\n</body>\n</html>\n<!--HTML generated by highlight " - HIGHLIGHT_VERSION - ", " - HIGHLIGHT_URL - "-->\n"), - attachAnchors(withAnchors) -{ - styleTagOpen.push_back(""); - styleTagOpen.push_back(getOpenTag("str")); - styleTagOpen.push_back(getOpenTag("num")); - styleTagOpen.push_back(getOpenTag("slc")); - styleTagOpen.push_back(getOpenTag("com")); - styleTagOpen.push_back(getOpenTag("esc")); - styleTagOpen.push_back(getOpenTag("dir")); - styleTagOpen.push_back(getOpenTag("dstr")); - styleTagOpen.push_back(getOpenTag("line")); - styleTagOpen.push_back(getOpenTag("sym")); - - styleTagClose.push_back(""); - for (int i=1;i<NUMBER_BUILTIN_STYLES; i++) { - styleTagClose.push_back("</span>"); - } - - /*assert (styleTagOpen.size()==styleTagClose.size()); - assert (styleTagOpen.size()==NUMBER_BUILTIN_STYLES); -*/ - newLineTag = "\n"; - spacer = " "; - styleCommentOpen="/*"; - styleCommentClose="*/"; -} - -string HtmlGenerator::getStyleDefinition() -{ - if (styleDefinitionCache.empty()){ - ostringstream os; - os << "body.hl\t{ background-color:#" - << (docStyle.getBgColour().getHexRedValue()) - << (docStyle.getBgColour().getHexGreenValue()) - << (docStyle.getBgColour().getHexBlueValue()) - << "; }\n"; - os << "pre.hl\t{ color:#" - << (docStyle.getDefaultStyle().getColour().getHexRedValue()) - << (docStyle.getDefaultStyle().getColour().getHexGreenValue()) - << (docStyle.getDefaultStyle().getColour().getHexBlueValue() ) - << "; background-color:#" - << (docStyle.getBgColour().getHexRedValue()) - << (docStyle.getBgColour().getHexGreenValue()) - << (docStyle.getBgColour().getHexBlueValue()) - << "; font-size:" - << docStyle.getFontSize() - << "pt; font-family:Courier;}\n"; - os << formatStyleAttributes("num", docStyle.getNumberStyle()) - << formatStyleAttributes("esc", docStyle.getEscapeCharStyle()) - << formatStyleAttributes("str", docStyle.getStringStyle()) - << formatStyleAttributes("dstr", docStyle.getDirectiveStringStyle()) - << formatStyleAttributes("slc", docStyle.getSingleLineCommentStyle()) - << formatStyleAttributes("com", docStyle.getCommentStyle()) - << formatStyleAttributes("dir", docStyle.getDirectiveStyle()) - << formatStyleAttributes("sym", docStyle.getSymbolStyle()) - << formatStyleAttributes("line", docStyle.getLineStyle()); - - KeywordStyles styles = docStyle.getKeywordStyles(); - for (KSIterator it=styles.begin(); it!=styles.end(); it++){ - os << formatStyleAttributes(it->first, *(it->second)); - } - styleDefinitionCache=os.str(); - } - return styleDefinitionCache; -} - -string HtmlGenerator::getHeader(const string &title) -{ - ostringstream os; - os << getHeaderStart((title.empty())?"Source file":title ); - if (langInfo.getSyntaxHighlight()) - { - if (includeStyleDef) //CSS-Definition in HTML-<head> einfuegen - { - os << "<style type=\"text/css\">\n"; - os << "<!--\n"; - os << getStyleDefinition(); - os << CodeGenerator::readUserStyleDef(); - os << "//-->\n"; - os << "</style>" << endl; - } - else //Referenz auf CSS-Datei einfuegen - { - os << "<link rel=\"stylesheet\" type=\"text/css\" href=\"" - << getStyleOutputPath() - << "\"" - << ">\n"; - } - } - os << "</head>\n<body class=\"hl\">\n<pre class=\"hl\">"; - return os.str(); -} - -string HtmlGenerator::getFooter() -{ - return "</pre>" + HTML_FOOTER; -} - - -void HtmlGenerator::printBody() -{ - processRootState(); -} - - - -string HtmlGenerator::maskCharacter(unsigned char c) -{ - switch (c) { - case '<' : - return "<"; - break; - case '>' : - return ">"; - break; - case '&' : - return "&"; - break; - case '\"' : - return """; - break; - - case '@' : - return "@"; - break; - - default : - string m; - return m += c; - } -} - -void HtmlGenerator::insertLineNumber (bool insertNewLine) -{ - if (insertNewLine){ - //*out << getNewLine(); - wsBuffer += getNewLine(); - } - if (showLineNumbers) { - ostringstream numberPrefix; - if (attachAnchors) { - numberPrefix << "<a " - << idAttr - << "=\"l_" - << lineNumber - << "\">"; - } - ostringstream os; - if (lineNumberFillZeroes) os.fill('0'); - os <<setw(LINE_NUMBER_WIDTH)<<right<< lineNumber; - numberPrefix<< styleTagOpen[LINENUMBER] - << os.str() - << spacer - << styleTagClose[LINENUMBER]; - - if (attachAnchors) { - numberPrefix << "</a>"; - } - - wsBuffer += numberPrefix.str(); - } -} - -string HtmlGenerator::getHeaderStart(const string &title){ - ostringstream header; - header<< "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\">" - << "\n<html>\n<head>\n"; - if (!omitEncoding){ - header << "<meta http-equiv=\"content-type\" content=\"text/html; charset="<<encoding<<"\">\n"; - } - header << "<title>" << title <<"</title>\n"; - return header.str(); -} - -bool HtmlGenerator::printIndexFile(const vector<string> &fileList, - const string &outPath ){ - string suffix = fileSuffix; - string outFilePath = outPath + "index" + suffix; - ofstream indexfile(outFilePath.c_str()); - - if (!indexfile.fail()){ - string inFileName; - string inFilePath, newInFilePath; - indexfile << getHeaderStart("Source Index" ); - indexfile << "</head>\n<body>\n<h1> Source Index</h1>\n" - << hrTag - << "\n<ul>\n"; - string::size_type pos; - for (unsigned int i=0; i < fileList.size(); i++){ - pos=(fileList[i]).find_last_of(Platform::pathSeparator); - if (pos!=string::npos){ - newInFilePath = (fileList[i]).substr(0, pos+1); - } else { - newInFilePath=Platform::pathSeparator; - } - if (newInFilePath!=inFilePath){ - indexfile << "</ul>\n<h2>"; - indexfile << newInFilePath; - indexfile << "</h2>\n<ul>\n"; - inFilePath=newInFilePath; - } - inFileName = (fileList[i]).substr(pos+1); - indexfile << "<li><a href=\"" << inFileName << suffix << "\">"; - indexfile << inFileName << suffix <<"</a></li>\n"; - } - - indexfile << "</ul>\n" - << hrTag << brTag - << "<small>Generated by highlight " - << HIGHLIGHT_VERSION - << ", <a href=\"" << HIGHLIGHT_URL << "\" target=\"new\">" - << HIGHLIGHT_URL << "</a></small>"; - indexfile << HTML_FOOTER; - } else { - return false; - } - return true; -} - -string HtmlGenerator::getMatchingOpenTag(unsigned int styleID){ - return getOpenTag(langInfo.getKeywordClasses()[styleID]); - } - -string HtmlGenerator::getMatchingCloseTag(unsigned int styleID){ - return "</span>"; -} - -} -/*************************************************************************** - htmlgenerator.h - description - ------------------- - begin : Wed Nov 28 2001 - copyright : (C) 2001 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - - -#ifndef HTMLGENERATOR_H -#define HTMLGENERATOR_H - -#include <fstream> -#include <iostream> -#include <string> -#include <sstream> - -#include "codegenerator.h" -#include "version.h" -#include "stylecolour.h" -#include "elementstyle.h" -#include "platform_fs.h" - -namespace highlight { - -/** - \brief This class generates HTML. - - It contains information about the resulting document structure (document - header and footer), the colour system, white space handling and text - formatting attributes. - -* @author Andre Simon -*/ - -class HtmlGenerator : public highlight::CodeGenerator - { - public: - - /** Constructor - \param colourTheme Name of Colour theme to use - \param enc encoding name - \param omitEnc switch to omit encoding information - \param withAnchors Test if HTML anchors should be attached to line numbers - */ - HtmlGenerator(const string &colourTheme, - const string &enc, - bool omitEnc=false, - bool withAnchors = false); - - HtmlGenerator(); - - /** Destructor*/ - virtual ~HtmlGenerator() {}; - - /** insert line number in the beginning of the new line - */ - virtual void insertLineNumber(bool insertNewLine=true); - - /** Print document header - \param title Title of the document - */ - string getHeader(const string &title); - - /** Print document body*/ - void printBody(); - - /** Print document footer*/ - string getFooter(); - - /** Print style definitions to external file - \param outFile Path of external style definition - */ - bool printExternalStyle(const string &outFile); - - /** Print index file with all input file names - \param fileList List of output file names - \param outPath Output path - */ - bool printIndexFile(const vector<string> & fileList, const string &outPath); - - protected: - - /** some strings which are similar in HTML and XHTML*/ - string brTag, hrTag, idAttr, fileSuffix; - - /** Output encoding name */ - string encoding; - - /** switch to omit encoding name in file header */ - bool omitEncoding; - - /** HTML footer */ - string HTML_FOOTER; - - /** caches style definition */ - string styleDefinitionCache; - - /** \return CSS definition */ - string getStyleDefinition(); - - /** \return Content of user defined style file */ - string readUserStyleDef(); - - /** \param title Dociment title - \return Start of file header */ - virtual string getHeaderStart(const string &title); - - private: - - /** \param styleName Style name - \return Opening tag of the given style - */ - string getOpenTag(const string& styleName); - - /** \return escaped character*/ - virtual string maskCharacter(unsigned char ); - - /** test if anchors should be appied to line numbers*/ - bool attachAnchors; - - /**\return text formatting attributes in HTML format */ - string formatStyleAttributes(const string & elemName, const ElementStyle & elem); - - /** \param styleID Style ID - \return Opening tag of the given style - */ - string getMatchingOpenTag(unsigned int styleID); - - /** \param styleID Style ID - \return Closing tag of the given style - */ - string getMatchingCloseTag(unsigned int styleID); - }; - -} - -#endif -/*************************************************************************** - languagedefinition.cpp - description - ------------------- - begin : Wed Nov 28 2001 - copyright : (C) 2001 by Andre imon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "languagedefinition.h" - -using namespace std; - -namespace highlight { - -LanguageDefinition::LanguageDefinition(): - ignoreCase(false), - disableHighlighting(false), - allowExtEscape(false), - vhdl_mode(false), - java_mode(false), - allowNestedComments(true), - fullLineComment(false), - reformatCode(false) -{} - -int LanguageDefinition::isKeyword(const string &s) -{ - if (s.length()) - { - if (keywords.count(s)){ - return keywords[s]; - } - else if (prefixes.count(s[0])){ - return prefixes[s[0]]; - } - } - return 0; -} - -bool LanguageDefinition::isPrefix(unsigned char c) -{ - return ( prefixes.count(c)); -} - -void LanguageDefinition::addSimpleSymbol(stringstream& symbolStream, - State state, - const string& paramValues ) { - istringstream valueStream(paramValues); - bool valExists=false; - string value; - while (valueStream >> value) - { - symbolStream << " " << value; - valExists = true; - } - if (valExists) - { - symbolStream << " " << state; - } -} - -void LanguageDefinition::addDelimiterSymbol(stringstream& symbolStream, - State stateBegin, State stateEnd, - const string& paramValues, - unsigned int classID) { - istringstream valueStream(paramValues); - string delimPrefix, delimSuffix; - while (valueStream>>delimPrefix){ - valueStream >> delimSuffix; - symbolStream << " "<<delimPrefix <<" " << stateBegin; - symbolStream <<" "<< delimSuffix<<" "<< stateEnd; - delimiterPrefixes.insert(make_pair(delimPrefix, classID)); - }; -} - -bool LanguageDefinition::getFlag( string& paramValue){ - return (StringTools::lowerCase(paramValue)=="true"); -} - -unsigned char LanguageDefinition::getSymbol(const string& paramValue){ - istringstream valueStream(paramValue); - unsigned char symbol; - valueStream >> symbol; - return symbol; -} - -void LanguageDefinition::addKeywords(const string &kwList, - int classID){ - istringstream valueStream(kwList); - string keyword; - while (valueStream >> keyword){ - keywords.insert(make_pair(keyword, classID)); - } -} - -unsigned int LanguageDefinition::generateNewKWClass(const string& newClassName){ - unsigned int newClassID=0; - bool found=false; - while (newClassID<keywordClasses.size() && !found){ - found= (newClassName==keywordClasses[newClassID++]); - } - if (!found){ - newClassID++; - keywordClasses.push_back(newClassName); - } - return newClassID; -} - -unsigned int LanguageDefinition::getDelimPrefixClassID(const string& prefix){ - if (delimiterPrefixes.count(prefix)){ - return delimiterPrefixes[prefix]; - } - return 0; -} - -bool LanguageDefinition::load(const string& langDefPath, bool clear) -{ - if (clear) reset(); - - ConfigurationReader langDef(langDefPath); - if (langDef.found()) - { - currentPath=langDefPath; - disableHighlighting=false; - string token; - stringstream symbolStrStream; - - //Stringstream zum Einlesen der Token: - istringstream valueStream; - - addDelimiterSymbol(symbolStrStream, ML_COMMENT_BEGIN, ML_COMMENT_END, - langDef.getParameter("ml_comment")); - - addSimpleSymbol(symbolStrStream, SL_COMMENT, - langDef.getParameter("sl_comment")); - - addSimpleSymbol(symbolStrStream, ESC_CHAR, - langDef.getParameter("escchar")); - - addSimpleSymbol(symbolStrStream, DIRECTIVE_LINE, - langDef.getParameter("directive")); - - addSimpleSymbol(symbolStrStream, DIRECTIVE_LINE_END, - langDef.getParameter("directiveend")); - - addSimpleSymbol(symbolStrStream, STRING, - langDef.getParameter("stringdelimiters")); - - ignoreCase=getFlag(langDef.getParameter("ignorecase")); - allowNestedComments=getFlag(langDef.getParameter("allownestedcomments")); - vhdl_mode=getFlag(langDef.getParameter("vhdl_mode")); - java_mode=getFlag(langDef.getParameter("java_mode")); - disableHighlighting=getFlag(langDef.getParameter("disablehighlighting")); - fullLineComment=getFlag(langDef.getParameter("fl_comment")); - reformatCode=getFlag(langDef.getParameter("reformatting")); - rawStringPrefix=getSymbol(langDef.getParameter("rawstringprefix")); - continuationChar=getSymbol(langDef.getParameter("continuationsymbol")); - allowExtEscape=getFlag(langDef.getParameter("allowextescape")); - - string paramName, className, classValue; - vector<string> paramNames=langDef.getParameterNames(); - for (unsigned int i=0;i<paramNames.size();i++){ - paramName=paramNames[i]; - className=StringTools::getParantheseVal(paramName); - classValue=langDef.getParameter(paramName); - if (paramName.find("kw_list") != string::npos ){ - addKeywords(classValue, generateNewKWClass(className)); - } - if (paramName.find("kw_prefix") != string::npos){ - prefixes.insert(make_pair(classValue[0], generateNewKWClass(className))); - } - if (paramName.find("kw_delim") != string::npos ){ - addDelimiterSymbol(symbolStrStream, KEYWORD_BEGIN, KEYWORD_END, - classValue, generateNewKWClass(className)); - } - if (paramName.find("tag_delim") != string::npos ){ - addDelimiterSymbol(symbolStrStream, TAG_BEGIN, TAG_END, - classValue, generateNewKWClass(className)); - } - } - - // zuletzt einlesen, um Probleme mit Delimitern, die Zeichen der - // Symbolliste enthalten, zu vermeiden - addSimpleSymbol(symbolStrStream, SYMBOL, langDef.getParameter("symbols")); - - valueStream.str(langDef.getParameter("allowedchars")); - while (valueStream >> token ) - { - allowedChars += token; - } - symbolString = symbolStrStream.str(); - - string fileToInclude=langDef.getParameter("include"); - if (!fileToInclude.empty()){ - string::size_type Pos = langDefPath.find_last_of(Platform::pathSeparator); - string includeLangDefPath = langDefPath.substr(0, Pos+1) + fileToInclude; - load(includeLangDefPath, false); - } - return true; - } - else - { - currentPath.clear(); - return false; - } -} - -void LanguageDefinition::reset() -{ - keywords.clear(); - keywordClasses.clear(); - delimiterPrefixes.clear();; - prefixes.clear(); - allowedChars.clear(); - ignoreCase= false; - java_mode= vhdl_mode= false; - allowNestedComments= reformatCode = false; - rawStringPrefix = continuationChar = '\0'; - disableHighlighting=false; - fullLineComment=false; -} - -bool LanguageDefinition::isVHDL() -{ - return vhdl_mode; -} - -bool LanguageDefinition::isJava() -{ - return java_mode; -} - -bool LanguageDefinition::allowNestedMLComments(){ - return allowNestedComments; -} - -bool LanguageDefinition::highlightingDisabled(){ - return disableHighlighting; -} - -bool LanguageDefinition::isFullLineComment(){ - return fullLineComment; -} - -bool LanguageDefinition::needsReload(const string &langDefPath){ - return currentPath!=langDefPath; -} - -bool LanguageDefinition::enableReformatting(){ - return reformatCode; -} - -const KeywordMap& LanguageDefinition::getKeywords() const{ - return keywords; -} - -string &LanguageDefinition::getSymbolString() { - return symbolString; -} - -unsigned char LanguageDefinition::getRawStringPrefix(){ - return rawStringPrefix; -} - -unsigned char LanguageDefinition::getContinuationChar(){ - return continuationChar; -} - -string &LanguageDefinition::getAllowedChars() { - return allowedChars; -} - -bool LanguageDefinition::getSyntaxHighlight() { - return !disableHighlighting; -} - -bool LanguageDefinition::isIgnoreCase() { - return ignoreCase; -} - -const vector<string>&LanguageDefinition::getKeywordClasses() const{ - return keywordClasses; -} - -bool LanguageDefinition::allowExtEscSeq() { - return allowExtEscape; -} - -} -/*************************************************************************** - languagedefinition.h - description - ------------------- - begin : Wed Nov 28 2001 - copyright : (C) 2001 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef LANGUAGEDEFINITION_H -#define LANGUAGEDEFINITION_H - -#include <string> -#include <map> -#include <iostream> -#include <fstream> -#include <iterator> -#include <sstream> - -#include "configurationreader.h" -//#include "stringtools.h" -#include "platform_fs.h" -#include "enums.h" - - -namespace highlight { - -/** maps keywords and the corresponding class IDs*/ -typedef map <string, int> KeywordMap; - -/** maps keyword prefixes and the corresponding class IDs*/ -typedef map <unsigned char, int> PrefixMap; - -/**\brief Contains specific data of the programming language being processed. - - The load() method will only read a new language definition if the given - file path is not equal to the path of the current language definition. - -* @author Andre Simon -*/ - -class LanguageDefinition { - - public: - - LanguageDefinition(); - - /**\return Symbol string, containg all known symbols with the referencing state ids*/ - string &getSymbolString(); - - /** \return Prefix of raw strings */ - unsigned char getRawStringPrefix(); - - /** \return Continuation Character */ - unsigned char getContinuationChar(); - - /** \return List of characters allowed within identifiers */ - string &getAllowedChars(); - - /** \return true if syntax highlighting is enabled*/ - bool getSyntaxHighlight(); - - /** \return True if language is case sensitive */ - bool isIgnoreCase(); - - /** \param s String - \return class id of keyword, 0 if s is not a keyword */ - int isKeyword(const string &s); - - - /** \return true if c is member of prefix list*/ - bool isPrefix(unsigned char c); - - /** Load new language definition - \param langDefPath Path of language definition - \param clear Test if former data should be deleted - \return True if successfull */ - bool load(const string& langDefPath, bool clear=true); - - /** \return True if programming language is VHDL */ - bool isVHDL(); - - /** \return True if programming language is Java */ - bool isJava(); - - /** \return True if multi line comments may be nested */ - bool allowNestedMLComments(); - - /** \return True if highlighting is disabled */ - bool highlightingDisabled(); - - /** \return True if single line comments must start at coloumn 1 */ - bool isFullLineComment(); - - /** \return True the next load() call will load a new language definition - \param langDefPath Path to language definition */ - bool needsReload(const string &langDefPath); - - /** \return True if current language may be reformatted (c, c++, c#, java) */ - bool enableReformatting(); - - /** \return True if escape sequences are allowed outsde of strings */ - bool allowExtEscSeq(); - - /** \return Class ID of given keyword delimiter prefix - \param prefix Keyword delimiter prefix */ - unsigned int getDelimPrefixClassID(const string& prefix); - - /** \return keywords*/ - const KeywordMap& getKeywords() const; - - /** \return keyword classes*/ - const vector<string>& getKeywordClasses() const; - - private: - // string containing symbols and their IDs of the programming language - string symbolString; - - // string with special characters that may occour in keywords - string allowedChars; - - // path to laoed language definition - string currentPath; - - KeywordMap keywords; - - vector <string> keywordClasses; - - KeywordMap delimiterPrefixes; - - PrefixMap prefixes; - - // keywords are not case sensitive if set - bool ignoreCase, - disableHighlighting, - allowExtEscape, - - // switch to enable VHDL workarounds - vhdl_mode, - - // switch to enable Java workarounds - java_mode, - - // allow nested multi line comment blocks - allowNestedComments, - - // single line comments have to start in coloumn 1 if set - fullLineComment, - - // code formatting is enabled if set - reformatCode; - - // Character, die eine Variable bzw. ein Keyword kennzeichnen - unsigned char rawStringPrefix, - continuationChar; - - /** setzt Membervariablen auf Defaultwerte */ - void reset(); - - // add a symbol sequencs to the symbolStream - void addSimpleSymbol(stringstream& symbolStream, State state, - const string& paramValues ); - - // add a delimiter symbol sequencs to the symbolStream - void addDelimiterSymbol(stringstream& symbolStream, - State stateBegin, State stateEnd, - const string& paramValues, - unsigned int classID=0); - - bool getFlag( string& paramValue); - - unsigned char getSymbol(const string& paramValue); - - // generate a unique class ID if the class name - unsigned int generateNewKWClass(const string& newClassName); - - // add keywords to the given class - void addKeywords(const string &kwList, int classID); - - }; - -} -#endif -/*************************************************************************** - LatexCode.cpp - description - ------------------- - begin : Mit Jul 24 2002 - copyright : (C) 2002 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "latexgenerator.h" - -namespace highlight { - -LatexGenerator::LatexGenerator(const string &colourTheme, - bool replQuotes) - : CodeGenerator(colourTheme), - replaceQuotes(replQuotes) -{ - styleTagOpen.push_back( "\\hlstd{"); - styleTagOpen.push_back( "\\hlstr{"); - styleTagOpen.push_back( "\\hlnum{"); - styleTagOpen.push_back( "\\hlslc{"); - styleTagOpen.push_back( "\\hlcom{"); - styleTagOpen.push_back( "\\hlesc{"); - styleTagOpen.push_back( "\\hldir{"); - styleTagOpen.push_back( "\\hldstr{"); - styleTagOpen.push_back( "\\hlline{"); - styleTagOpen.push_back( "\\hlsym{"); - - for (int i=0;i<NUMBER_BUILTIN_STYLES; i++){ - styleTagClose.push_back( "}"); - } - - // avoid "Underfull \hbox (badness 10000)" warnings - newLineTag = "\\\\\n"; - longLineTag = "\\hspace*{\\fill}" + newLineTag; - - spacer = "\\ "; - - maskWs=true; - maskWsBegin = "\\hlstd{"; - maskWsEnd = "}"; - - excludeWs=true; - - styleCommentOpen="%"; -} - -LatexGenerator::LatexGenerator() -{} -LatexGenerator::~LatexGenerator() -{} - -string LatexGenerator::formatStyleAttributes(const string & elemName, - const ElementStyle &elem) -{ - ostringstream s; - s << "\\newcommand{\\hl" - << elemName - << "}[1]{\\textcolor[rgb]{" - << elem.getColour().getLatexRedValue() << "," - << elem.getColour().getLatexGreenValue() << "," - << elem.getColour().getLatexBlueValue() - << "}{"; - - if (elem.isBold()) - s << "\\bf{"; - if (elem.isItalic()) - s << "\\it{"; - - s <<"#1"; - - if (elem.isBold()) - s << "}"; - if (elem.isItalic()) - s << "}"; - - s <<"}}\n"; - return s.str(); -} - -void LatexGenerator::printBody() -{ - *out << "\\noindent\n" - << "\\ttfamily\n"; - - processRootState(); - - *out << "\\mbox{}\n" - << "\n\\normalfont\n"; -} - -string LatexGenerator::getHeader(const string & title) -{ - ostringstream os; - os << "\\documentclass{article}\n" - << "\\usepackage{color}\n" - << "\\usepackage{alltt}\n"; - - if (langInfo.getSyntaxHighlight()) { - if (includeStyleDef) { - os << "\n"<<getStyleDefinition(); - os << CodeGenerator::readUserStyleDef(); - } else { - os << "\n\\input {" - << getStyleOutputPath() - << "}\n"; - } - } - - os << "\n\\title{" << title << "}\n" - << "\\begin{document}\n" - << "\\pagecolor{bgcolor}\n"; - return os.str(); -} - -string LatexGenerator::getFooter() -{ - ostringstream os; - os << "\\end {document}\n" - << "(* LaTeX generated by highlight " - << HIGHLIGHT_VERSION - << ", " - << HIGHLIGHT_URL - << " *)\n"; - return os.str(); -} - -string LatexGenerator::getNewLine(){ - return (showLineNumbers)? newLineTag:longLineTag; -} - -string LatexGenerator::maskCharacter(unsigned char c) -{ - switch (c) - { - case '<' : - return "$<$"; - break; - case '>' : - return "$>$"; - break; - case '{': - case '}': - case '&': - case '$': - case '#': - case '%': - { - string m; - m ="\\"; - m += c; - return m; - } - break; - case '\"': - return (fragmentOutput && replaceQuotes)?"\\dq{}":"\""; - break; - case '_': - return "\\textunderscore "; - break; - case '^': - return "\\textasciicircum "; - break; - case '\\': - return "$\\backslash$"; - break; - case '~': - return "$\\sim$"; - break; - case '|': - return "\\textbar "; - break; - // avoid latex compilation failure if [ or * follows a line break (\\) - case '*': - case '[': - case ']': - // avoid "merging" of consecutive '-' chars when included in bold font ( \bf ) - case '-': - { - string m; - m= "{"; - m+= c; - m+= "}"; - return m; - } - break; - case ' ': - return spacer; - break; - case AUML_LC: - return "\\\"a"; - break; - case OUML_LC: - return "\\\"o"; - break; - case UUML_LC: - return "\\\"u"; - break; - case AUML_UC: - return "\\\"A"; - break; - case OUML_UC: - return "\\\"O"; - break; - case UUML_UC: - return "\\\"U"; - break; - case AACUTE_LC: - return "\\'a"; - break; - case EACUTE_LC: - return "\\'e"; - break; - case OACUTE_LC: - return "\\'o"; - break; - case UACUTE_LC: - return "\\'u"; - break; - case AGRAVE_LC: - return "\\`a"; - break; - case EGRAVE_LC: - return "\\`e"; - break; - case OGRAVE_LC: - return "\\`o"; - break; - case UGRAVE_LC: - return "\\`u"; - break; - case AACUTE_UC: - return "\\'A"; - break; - case EACUTE_UC: - return "\\'E"; - break; - case OACUTE_UC: - return "\\'O"; - break; - case UACUTE_UC: - return "\\'U"; - break; - case AGRAVE_UC: - return "\\`A"; - break; - case EGRAVE_UC: - return "\\`E"; - break; - case UGRAVE_UC: - return "\\`O"; - break; - case OGRAVE_UC: - return "\\`U"; - break; - case SZLIG: - return "\\ss "; - break; - /* #ifndef _WIN32 - // skip first byte of multibyte chracters - case 195: - return string(""); - break; -#endif*/ - - default : - { - string m; - return m+=c; - } - } -} - -string LatexGenerator::getMatchingOpenTag(unsigned int styleID){ - return "\\hl"+langInfo.getKeywordClasses()[styleID]+"{"; - } - -string LatexGenerator::getMatchingCloseTag(unsigned int styleID){ - return "}"; -} - - -string LatexGenerator::getStyleDefinition() -{ - if (styleDefinitionCache.empty()){ - ostringstream os; - os << formatStyleAttributes("std", docStyle.getDefaultStyle()); - os << formatStyleAttributes("num", docStyle.getNumberStyle()); - os << formatStyleAttributes("esc", docStyle.getEscapeCharStyle()); - os << formatStyleAttributes("str", docStyle.getStringStyle()); - os << formatStyleAttributes("dstr", docStyle.getDirectiveStringStyle()); - os << formatStyleAttributes("slc", docStyle.getSingleLineCommentStyle()); - os << formatStyleAttributes("com", docStyle.getCommentStyle()); - os << formatStyleAttributes("dir", docStyle.getDirectiveStyle()); - os << formatStyleAttributes("sym", docStyle.getSymbolStyle()); - os << formatStyleAttributes("line", docStyle.getLineStyle()); - - KeywordStyles styles = docStyle.getKeywordStyles(); - for (KSIterator it=styles.begin(); it!=styles.end(); it++){ - os << formatStyleAttributes(it->first, *(it->second)); - } - os << "\\definecolor{bgcolor}{rgb}{" - << docStyle.getBgColour().getLatexRedValue() << "," - << docStyle.getBgColour().getLatexGreenValue() << "," - << docStyle.getBgColour().getLatexBlueValue() - << "}\n"; - os << "\\oddsidemargin -3mm\n\\textwidth 165,2truemm\n" - << "\\topmargin 0truept\n\\headheight 0truept\n" - << "\\headsep 0truept\n\\textheight 230truemm\n"; - - styleDefinitionCache=os.str(); - } - return styleDefinitionCache; -} - - -} -/*************************************************************************** - latexgenerator.h - description - ------------------- - begin : Mit Jul 24 2002 - copyright : (C) 2002 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef LATEXGENERATOR_H -#define LATEXGENERATOR_H - -#include <string> -#include <iostream> -#include <sstream> - -#include "codegenerator.h" -#include "version.h" -#include "charcodes.h" - - -namespace highlight { - -/** - \brief This class generates LaTeX. - - It contains information about the resulting document structure (document - header and footer), the colour system, white space handling and text - formatting attributes. - -* @author Andre Simon -*/ - -class LatexGenerator : public highlight::CodeGenerator - { - public: - - /** Constructor - \param colourTheme Name of Colour theme to use - \param replQuotes Test if quotes shold be replaced by \ dq - */ - LatexGenerator(const string &colourTheme, - bool replQuotes=false); - LatexGenerator(); - ~LatexGenerator(); - - /** prints document header - \param title Title of the document - */ - string getHeader(const string & title); - - /** Prints document footer*/ - string getFooter(); - - /** Prints document body*/ - void printBody(); - - private: - - string styleDefinitionCache; - string longLineTag; - - /** \return escaped character*/ - virtual string maskCharacter(unsigned char ); - - /**\return text formatting attributes in LaTeX format */ - string formatStyleAttributes(const string & elemName, - const ElementStyle & elem); - - /** test if double quotes should be replaced by \dq{} */ - bool replaceQuotes; - - string getNewLine(); - - string getStyleDefinition(); - - string getMatchingOpenTag(unsigned int styleID); - string getMatchingCloseTag(unsigned int styleID); - }; - -} - -#endif -/*************************************************************************** - main.cpp - description - ------------------- - begin : Die Apr 23 22:16:35 CEST 2002 - copyright : (C) 2002-2004 by André Simon - email : andre.simon1@gmx.de - - - Highlight is a universal source code to HTML converter. Syntax highlighting - is formatted by Cascading Style Sheets. It's possible to easily enhance - highlight's parsing database. - - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "main.h" - -using namespace std; - -void HighlightApp::printVersionInfo() -{ - cout << "\n highlight version " - << HIGHLIGHT_VERSION - << "\n Copyright (C) 2002-2005 Andre Simon <andre.simon1@gmx.de>" - << "\n\n Artistic Style Classes (1.15.3)" - << "\n Copyright (C) 1998-2002 Tal Davidson <davidsont@bigfoot.com>" - << "\n\n Dirstream Classes (0.4)" - << "\n Copyright (C) 2002-2004 Benjamin Kaufmann <hume@c-plusplus.de>" - << "\n\n This software is released under the terms of the GNU General " - << "Public License." - << "\n For more information about these matters, see the file named " - << "COPYING.\n\n"; - #ifdef USE_LOCAL_GETOPT - cout << " (Built with USE_LOCAL_GETOPT flag set.)\n"; - #endif - #ifdef HL_DATA_DIR - cout << " (HL_DATA_DIR: \"" <<HL_DATA_DIR<< "\" )\n"; - #endif -} - -void HighlightApp::printBadInstallationInfo() -{ - cerr << "highlight: Data directory not found. Bad installation or wrong " - << OPT_DATADIR << " parameter." - << "\n\nCopy the highlight files into one of the directories listed " - << "in INSTALL.\nYou may also set the data directory with " - << OPT_DATADIR << " and " << OPT_ADDDATADIR << ".\n"; -} - -bool HighlightApp::listInstalledFiles(bool showThemes) -{ - vector <string> filePaths; - string wildcard=(showThemes)? "*.style":"*.lang"; - unsigned int suffixLength=wildcard.length()-1; - - string searchDir = ((showThemes) ? dataDir.getThemeDir(): - dataDir.getLangDefDir()) + wildcard; - - bool directoryOK = Platform::getDirectoryEntries(filePaths, searchDir, true); - if (!directoryOK) { - cerr << "highlight: Could not access directory " - << searchDir - << ", aborted.\n"; - return false; - } - - cout << "\n Installed " - << ((showThemes)? "themes":"language definitions ") - << "(located in " - << ((showThemes)?dataDir.getThemeDir():dataDir.getLangDefDir()) - << ") :\n" - << endl; - - sort(filePaths.begin(), filePaths.end()); - string temp; - - for (unsigned int i=0;i< filePaths.size(); i++){ - if (showThemes) - temp = (filePaths[i]).substr(dataDir.getThemeDir().length()); - else - temp = (filePaths[i]).substr(dataDir.getLangDefDir().length()); - cout << " "<<temp.substr(0, temp.length()- suffixLength) << endl; - } - cout <<"\n Use name of the desired " - << ((showThemes)?"theme":"language") - << " with the --" - << ((showThemes)? OPT_STYLE : OPT_SYNTAX) - << " option.\n" << endl; - return true; -} - -void HighlightApp::printDebugInfo(highlight::LanguageDefinition &lang, - const string & langDefPath) -{ - cerr << "\nLoading language definition: " << langDefPath; - cerr << "\n\nSYMBOLS: " - << lang.getSymbolString(); - cerr << "\n\nKEYWORDS: "; - highlight::KeywordMap::iterator it; - highlight::KeywordMap keys=lang.getKeywords(); - cerr << "\n\nID Keyword \n"; - for (it=keys.begin(); it!=keys.end();it++){ - cerr << it->second - << " <- \"" - << it->first <<"\"\n"; - } - cerr <<"\n"; -} - -string HighlightApp::getFileSuffix(const string &fileName) { - size_t ptPos=fileName.rfind("."); - return (ptPos == string::npos) ? - "" : fileName.substr(ptPos+1, fileName.length()); -} - -bool HighlightApp::loadMapConfig(const string& name, StringMap* map){ - string extPath=dataDir.getDir() + name + ".conf"; - ConfigurationReader config(extPath); - if (config.found() ) - { - stringstream values; - string paramName, paramVal; - for (unsigned int i=0;i<config.getParameterNames().size();i++){ - paramName = config.getParameterNames()[i]; - values.str(config.getParameter(paramName)) ; - while (values >> paramVal) { - map->insert(make_pair( paramVal, paramName)); - } - values.clear(); - } - return true; - } else { - cerr << "highlight: Configuration file "<< extPath << " not found.\n"; - return false; - } -} - - -int HighlightApp::getNumDigits(int i){ - int res=0; - while (i){ - i/=10; - ++res; - } - return res; -} - -void HighlightApp::printProgressBar(int total, int count){ - if (!total) return; - int p=100*count / total; - int numProgressItems=p/10; - cout << "\r["; - for (int i=0;i<10;i++){ - cout <<((i<numProgressItems)?"#":" "); - } - cout<< "] " <<setw(3)<<p<<"%, "<<count << " / " << total << " " <<flush; - if (p==100) { - cout << endl; - } -} - -void HighlightApp::printCurrentAction(const string&outfilePath, - int total, int count, int countWidth){ - cout << "Writing file " - << setw(countWidth)<< count - << " of " - << total - << ": " - << outfilePath - << "\n"; -} - -void HighlightApp::printIOErrorReport(unsigned int numberErrorFiles, - vector<string> & fileList, - const string &action){ - cerr << "highlight: Could not " - << action - << " file" - << ((numberErrorFiles>1)?"s":"")<<":\n"; - copy (fileList.begin(), fileList.end(), ostream_iterator<string>(cerr, "\n")); - if (fileList.size() < numberErrorFiles) { - cerr << "... [" - << (numberErrorFiles - fileList.size() ) - << " of " - << numberErrorFiles - << " failures not shown, use --" - << OPT_VERBOSE - << " switch to print all paths]\n"; - } -} - -string HighlightApp::analyzeShebang(const string& file){ - if (scriptShebangs.empty()) loadMapConfig("scriptre", &scriptShebangs); - ifstream inFile(file.c_str()); - string firstLine; - getline (inFile, firstLine); - return scriptShebangs[StringTools::trimRight(firstLine)]; -} - -string HighlightApp::guessFileType(const string& suffix, const string &inputFile) -{ - if (extensions.empty()) loadMapConfig("extensions", &extensions); - string fileType = (extensions.count(suffix)) ? extensions[suffix] : suffix ; - if (!fileType.empty()) return fileType; - return analyzeShebang(inputFile); -} - - -int HighlightApp::run(int argc, char**argv){ - - //get command line options - CmdLineOptions options(argc, argv); - - // set data directory path, where /langDefs and /themes reside - string highlightRootDir = Platform::getAppPath(); - - // determine highlight data directory - if (! dataDir.searchDataDir((options.dataDirGiven())? - options.getDataDir(): highlightRootDir)){ - printBadInstallationInfo(); - return EXIT_FAILURE; - } - - if (options.additionalDataDirGiven()){ - dataDir.setAdditionalDataDir(options.getAdditionalDataDir()); - } - - if (options.printVersion()) { - printVersionInfo(); - return EXIT_SUCCESS; - } - - if (options.printHelp()) { - Help::printHelp(dataDir.getHelpMsgDir() + options.getHelpLang()); - return EXIT_SUCCESS; - } - - if (options.showThemes() || options.showLangdefs()) { - return listInstalledFiles(options.showThemes())?EXIT_SUCCESS:EXIT_FAILURE; - } - - // list of input files - const vector <string> inFileList=options.getInputFileNames(); - - string stylePath=dataDir.searchForTheme(options.getStyleName()); - - highlight::CodeGenerator *generator = - highlight::CodeGenerator::getInstance(options.getOutputType(), - stylePath, - options.getStyleInFilename(), - options.getStyleOutFilename(), - options.getCharSet(), - options.includeStyleDef(), - options.attachLineAnchors(), - options.replaceQuotes(), - options.fopCompatible(), - options.getNumberSpaces(), - options.getWrappingStyle(), - options.printLineNumbers(), - options.fillLineNrZeroes(), - options.fragmentOutput(), - options.omitEncodingName() ); - - assert (generator!=NULL); - - bool styleFileWanted = !options.fragmentOutput() || options.styleOutPathDefined(); - - if (!generator->styleFound() ) { - cerr << "highlight: Could not find style " - << stylePath - << ".\n"; - highlight::CodeGenerator::deleteInstance(); - return EXIT_FAILURE; - } - - if (!options.getIndentScheme().empty()){ - string indentSchemePath = - dataDir.searchForIndentScheme(options.getIndentScheme()+".indent"); - if (!generator->initIndentationScheme(indentSchemePath)){ - cerr << "highlight: Could not find indentation scheme " - << indentSchemePath - << ".\n"; - highlight::CodeGenerator::deleteInstance(); - return EXIT_FAILURE; - } - } - - string outDirectory = options.getOutDirectory(); - if (!outDirectory.empty() && !options.quietMode() && !dirstr::directory_exists(outDirectory) ){ - cerr << "highlight: Output directory \"" - << outDirectory - << "\" does not exist.\n"; - return EXIT_FAILURE; - } - - bool initError=false, IOError=false; - - if ( !options.includeStyleDef() - && (styleFileWanted) - && options.formatSupportsExtStyle()) { - string cssOutFile=outDirectory + options.getStyleOutFilename(); - bool success=generator->printExternalStyle (cssOutFile); - if (!success){ - cerr << "highlight: Could not write " << cssOutFile <<".\n"; - IOError = true; - } - } - - if (options.printIndexFile()){ - bool success=generator -> printIndexFile(inFileList, outDirectory); - if (!success){ - cerr << "highlight: Could not write index file.\n"; - IOError = true; - } - } - - unsigned int fileCount=inFileList.size(), - fileCountWidth=getNumDigits(fileCount), - i=0, - numBadFormatting=0, - numBadInput=0, - numBadOutput=0; - - vector<string> badFormattedFiles, badInputFiles, badOutputFiles; - string outFilePath; - string suffix, lastSuffix; - - if (options.syntaxGiven()) { // user defined language definition, valid for all files - suffix = guessFileType(options.getLanguage()); - } - - while (i < fileCount && !initError) { - if (!options.syntaxGiven()) { // determine file type for each file - suffix = guessFileType(getFileSuffix(inFileList[i]), inFileList[i]); - } - if (suffix.empty()) { - if (!options.enableBatchMode() && !styleFileWanted) - cerr << "highlight: Undefined language definition. Use --" - << OPT_SYNTAX << " option.\n"; - if (!options.forceOutput()){ - initError = true; - break; - } - } - - if (suffix != lastSuffix) { - string langDefPath=dataDir.searchForLangDef(suffix+".lang"); - highlight::LoadResult loadRes= generator->initLanguage(langDefPath); - if (loadRes==highlight::LOAD_FAILED){ - cerr << "highlight: Unknown source file extension \"" - << suffix - << "\".\n"; - if (!options.forceOutput()){ - initError = true; - break; - } - } - if (options.printDebugInfo() && loadRes==highlight::LOAD_NEW){ - printDebugInfo(generator->getLanguage(), langDefPath); - } - lastSuffix = suffix; - } - - if (options.enableBatchMode()){ - string::size_type pos=(inFileList[i]).find_last_of(Platform::pathSeparator); - outFilePath = outDirectory; - outFilePath += inFileList[i].substr(pos+1); - outFilePath += options.getOutFileSuffix(); - - if (!options.quietMode()) { - if (options.printProgress()){ - printProgressBar(fileCount, i+1); - } else { - printCurrentAction(outFilePath, fileCount, i+1, fileCountWidth); - } - } - } else { - outFilePath = options.getSingleOutFilename(); - } - - highlight::ParseError error = generator->printOutput(inFileList[i], outFilePath); - if (error==highlight::BAD_INPUT){ - if (numBadInput++ < IO_ERROR_REPORT_LENGTH || options.printDebugInfo()) { - badInputFiles.push_back(inFileList[i]); - } - } else if (error==highlight::BAD_OUTPUT){ - if (numBadOutput++ < IO_ERROR_REPORT_LENGTH || options.printDebugInfo()) { - badOutputFiles.push_back(outFilePath); - } - } - if (options.formattingEnabled() && !generator->formattingIsPossible()){ - if (numBadFormatting++ < IO_ERROR_REPORT_LENGTH || options.printDebugInfo()) { - badFormattedFiles.push_back(outFilePath); - } - } - ++i; - } - - if (numBadInput){ - printIOErrorReport(numBadInput, badInputFiles, "read input"); - IOError = true; - } - if (numBadOutput){ - printIOErrorReport(numBadOutput, badOutputFiles, "write output"); - IOError = true; - } - if (numBadFormatting){ - printIOErrorReport(numBadFormatting, badFormattedFiles, "reformat"); - } - - highlight::CodeGenerator::deleteInstance(); - return (initError || IOError) ? EXIT_FAILURE : EXIT_SUCCESS; -} - - -int main(int argc, char **argv) { - HighlightApp app; - return app.run(argc, argv); -} -// -// C++ Interface: main -// -// Description: -// -// -// Author: Andre Simon <andre.simon1@gmx.de>, (C) 2004 -// -// Copyright: See COPYING file that comes with this distribution -// -// - -#ifndef HIGHLIGHT_APP -#define HIGHLIGHT_APP - - -#include <iostream> -#include <fstream> -#include <string> -#include <vector> -#include <map> -#include <iomanip> -#include <cassert> - -#include "./dirstream0.4/dirstream.h" -#include "cmdlineoptions.h" -#include "configurationreader.h" -#include "codegenerator.h" -#include "help.h" -#include "datadir.h" -#include "version.h" -#include "platform_fs.h" - -#define IO_ERROR_REPORT_LENGTH 5 -#define SHEBANG_CNT 12 - -typedef map<string, string> StringMap; - -/** Main application class - @author Andre Simon -*/ - -class HighlightApp { - -public: - - HighlightApp(){}; - ~HighlightApp(){}; - - /** Start application - \param argc Number of command line arguments - \param argv values of command line arguments - \return EXIT_SUCCESS or EXIT_FAILURE - */ - int run(int argc, char **argv); - -private: - - DataDir dataDir; - StringMap extensions; - StringMap scriptShebangs; - - /** print version info*/ - void printVersionInfo(); - - /** print error message*/ - void printBadInstallationInfo(); - - /** print input and output errors */ - void printIOErrorReport(unsigned int numberErrorFiles, vector<string> & fileList, const string &action); - - /** print installed files - \param showThemes Print installed themes if true, language definitions otherwise - */ - bool listInstalledFiles(bool showThemes); - - void printDebugInfo(highlight::LanguageDefinition &lang, - const string &langDefPath); - - string getFileSuffix(const string &fileName); - - string guessFileType(const string &suffix, const string &inputFile=""); - - int getNumDigits(int i); - - void printProgressBar(int total, int count); - void printCurrentAction(const string&outfilePath, - int total, int count, int countWidth); - - bool readInputFilePaths(vector<string> &fileList, string wildcard, - bool recursiveSearch); - - string analyzeShebang(const string& file); - bool loadMapConfig(const string& name, StringMap* map); - -}; - -#endif -// -// C++ Implementation: platform_fs -// -// Description: -// -// -// Author: André Simon <andre.simon1@gmx.de>, (C) 2004 -// -// Copyright: See COPYING file that comes with this distribution -// -// - -#include "platform_fs.h" -#include "./dirstream0.4/dirstream.h" - -#include <iostream> - -using namespace std; - -namespace Platform { - -#ifdef _WIN32 - #include <windows.h> - - const char pathSeparator = '\\'; - //const std::string pathSeparatorStr = "\\"; - - std::string getAppPath() - { - char pathAndName[MAX_PATH], path[MAX_PATH], drive[3]; - GetModuleFileName(NULL, pathAndName, MAX_PATH); - _splitpath(pathAndName, drive, path, 0, 0); - return std::string(drive)+path; - } - -#else - const char pathSeparator = '/'; - // const std::string pathSeparatorStr = "/"; - - std::string getAppPath() - { - return ""; - } - -#endif - -bool getDirectoryEntries(vector<string> &fileList, - string wildcard, - bool recursiveSearch) -{ - if (!wildcard.empty()) { - string directory_path; - string::size_type Pos = wildcard.find_last_of(pathSeparator); - if (Pos == string::npos) { - directory_path = "."; - } else { - directory_path = wildcard.substr(0, Pos + 1); - wildcard = wildcard.substr(Pos + 1); - } - - dirstr::dirstream str( directory_path.c_str(), - #ifdef USE_FN_MATCH - dirstr::pred_f(FnMatcher(wildcard.c_str(), 0)), - #else - dirstr::pattern_f(wildcard.c_str()), - #endif - (recursiveSearch)?dirstr::recursive_yes:dirstr::recursive_no); - - - for(string entry; str >> entry;) { - fileList.push_back(dirstr::full_path(entry)); - //std::cout << "Entry " <<entry<<"\n"; - } - } - return !(fileList.empty()); -} - -} - -// -// C++ Interface: platform_fs -// -// Description: -// -// -// Author: André Simon <andre.simon1@gmx.de>, (C) 2004 -// -// Copyright: See COPYING file that comes with this distribution -// -// -#ifndef PLATFORM_FS__H__INCLUDED -#define PLATFORM_FS__H__INCLUDED - -#include <string> -#include <iostream> -#include <vector> - -#ifdef USE_FN_MATCH - #include <fnmatch.h> -#endif - -namespace Platform -{ - extern const char pathSeparator; - //extern const std::string pathSeparatorStr; - - std::string getAppPath(); - - /** \param fileList Vector where found entries will be stored - \param wildcard Directory path and wildcard - \param recursiveSearch Test if directory should be searched recursively */ - bool getDirectoryEntries(std::vector<std::string> &fileList, - std::string wildcard, - bool recursiveSearch=false); - -#ifdef USE_FN_MATCH - struct FnMatcher - { - FnMatcher(const char* pattern, int flags) - : pattern_(pattern) - , flags_(flags) - {} - bool operator()(const std::string& e) const { - // std::cout << "pattern: "<<pattern_<< " entry: "<<e.c_str()<< " Res fn: " <<::fnmatch(pattern_, e.c_str(), FNM_PATHNAME)<< " \n"; - return ! ::fnmatch(pattern_, e.c_str(), flags_); - } - private: - const char* pattern_; - int flags_; - }; -#endif -} -#endif -/*************************************************************************** - PreFormatter.cpp - description - ------------------- - begin : Mo Jan 03 2005 - copyright : (C) 2005 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "preformatter.h" - -namespace highlight { - -PreFormatter::PreFormatter(bool wrap, bool replTabs): - maxLineLength(80), - index(0), - numberSpaces(0), - wsPrefixLength(string::npos), - hasMore(false), - indentAfterOpenBraces(true), - redefineWsPrefix(false), - wrapLines(wrap), - replaceTabs(replTabs) -{ -} - -PreFormatter::PreFormatter(): - maxLineLength(80), - index(0), - numberSpaces(0), - wsPrefixLength(string::npos), - hasMore(false), - indentAfterOpenBraces(true), - redefineWsPrefix(false), - wrapLines(false), - replaceTabs(false) -{ -} - -PreFormatter::~PreFormatter() -{ -} - -bool PreFormatter::hasMoreLines(){ - return hasMore; -} - -bool PreFormatter::indentCode(){ - return indentAfterOpenBraces; -} - -void PreFormatter::setLine(const std::string newLine){ - - line=newLine; - - if (replaceTabs && numberSpaces) { - size_t tabPos=line.find('\t'); - while (tabPos!=string::npos){ - line.replace(tabPos , 1, numberSpaces - (tabPos % numberSpaces) , ' '); - tabPos = line.find('\t', tabPos+1); - } - } - - if (wrapLines){ - wsPrefix.clear(); - index=0; - wsPrefixLength=string::npos; - hasMore=true; - redefineWsPrefix=false; - } -} - -std::string PreFormatter::getNextLine(){ - - if (!wrapLines){ - hasMore = false; - return line; - } - - if (!index && line.length() > maxLineLength){ // erster Durchlauf... - // wenn möglich an öffnender Klammer oder Geichheitszeichen ausrichten - if (indentAfterOpenBraces){ - wsPrefixLength=line.find_first_of(INDENT_MARKERS); - } - // sonst die Einrückung der Originalzeile beibehalten - if (wsPrefixLength==string::npos || wsPrefixLength-index>maxLineLength){ - wsPrefixLength=line.find_first_not_of(WS_CHARS); - } - else { - // wsPrefix in allen neu umgebrochenen Zeilen durch Spaces ersetzen - redefineWsPrefix=true; - // Position hinter öffnende Klammer springen - wsPrefixLength=line.find_first_not_of(WS_CHARS,wsPrefixLength+1); - } - - if (wsPrefixLength!=string::npos){ - index = wsPrefixLength; - // Falls Anzahl der Whitespaces am beginn der ersten zeile größer - // als Max. Zeilenlänge, Whitespaces verwerfen - if (wsPrefixLength>maxLineLength){ - wsPrefixLength=0; - return string(); - } - else{ - wsPrefix=line.substr(0, wsPrefixLength); - } - } - // Zeile enthaelt nur Whitespace; verwerfen - else { - hasMore= false; - return string(); - } - } else { - if (redefineWsPrefix){ - wsPrefix.clear(); - wsPrefix.append(wsPrefixLength, ' '); - } - redefineWsPrefix=false; - } - - string resultString; - - // Position, ab der rckwaerts nach Umbruchmglichkeit gesucht wird - unsigned int searchEndPos = maxLineLength - wsPrefixLength; - - // letztes Teilstueck der Zeile ausgeben; Parsen beenden - if (line.length()-index < searchEndPos) { - hasMore=false; - resultString=(index>0) ? wsPrefix + line.substr(index) : line.substr(index); - return resultString; - } - - // Umbrechposition suchen - size_t lbPos = line.find_last_of(LB_CHARS, index+searchEndPos); - if (lbPos <= index || lbPos == string::npos) { - // nichts gefunden, hart umbrechen - lbPos = index + searchEndPos; - } - // Einrückung der Originalzeile erhalten - resultString+=wsPrefix; - // Neue Zeile erzeugen - resultString += line.substr(index, lbPos-index+1); - - // Whitespace am neuen Zeilenbeginn ignorieren, ausser beim ersten Durchlauf - //unsigned int newIndex=StringTools::getNextNonWsPos(line,lbPos+1); - size_t newIndex=line.find_first_not_of(WS_CHARS, lbPos+1); - index=(newIndex!=string::npos)?newIndex:line.length(); - - hasMore=index!=line.length(); // unnoetigen Leerstring vermeiden - - return resultString; -} - -void PreFormatter::setWrappingProperties(unsigned int maxLineLength, bool indentAfterOpenBraces){ - this->maxLineLength = maxLineLength; - this->indentAfterOpenBraces = indentAfterOpenBraces; -} - -void PreFormatter::setNumberSpaces(unsigned int num){ - numberSpaces = num; -} - -} -/*************************************************************************** - PreFormatter.cpp - description - ------------------- - begin : Mo Jan 03 2005 - copyright : (C) 2005 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef PreFormatter_H -#define PreFormatter_H - -#define LB_CHARS " \t[](){}-+<>.:,;" -#define WS_CHARS " \n\r\t" -#define INDENT_MARKERS "{(=" - -#include <string> -#include <iostream> - -#include "stringtools.h" - -namespace highlight { - -/** \brief Class which provides intelligent line wrapping. -* @author Andre Simon -*/ - -class PreFormatter{ -public: - /** Constructor - */ - PreFormatter(bool wrap, bool replTabs); - - PreFormatter(); - - ~PreFormatter(); - - /** - \return True if current line can be wrapped again - */ - bool hasMoreLines(); - - /** - Sets new line to be wrapped - \param newline New line - */ - void setLine(const std::string newline); - - /** - The method will indent function calls and statements - \return Next line - */ - std::string getNextLine(); - - /** - \return True if lines following open braces should be indented - */ - bool indentCode(); - - /** - \param maxlength max. length of output lines - \param indentAfterOpenBraces set true if lines should be indented after braces - */ - void setWrappingProperties(unsigned int maxlength=80, bool indentAfterOpenBraces=true); - - /** - \param num number of spaces which replace a tab - */ - - void setNumberSpaces(unsigned int num); - - /** - \return true if preformatting is enabled - */ - bool isEnabled(){ - return wrapLines || replaceTabs; - } - -private: - - unsigned int maxLineLength; - - std::string line, wsPrefix; - unsigned int index; - unsigned int numberSpaces; - size_t wsPrefixLength; - bool hasMore, indentAfterOpenBraces; - bool redefineWsPrefix; - bool wrapLines, replaceTabs; -}; - -} - -#endif -/*************************************************************************** - rtfcode.cpp - description - ------------------- - begin : Die Jul 9 2002 - copyright : (C) 2002 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "rtfgenerator.h" - -using namespace std; - -namespace highlight { - -string RtfGenerator::formatStyleAttributes( const ElementStyle & col) -{ - stringstream s; - s << "\\red"<< col.getColour().getRTFRedValue() - << "\\green"<<col.getColour().getRTFGreenValue() - << "\\blue"<<col.getColour().getRTFBlueValue() - << ";"; - - return s.str(); -} - -string RtfGenerator::getOpenTag(int styleNumber,const ElementStyle & elem) -{ - ostringstream s; - s << "{\\cf"<<(styleNumber+1)<<"{"; - if (elem.isBold()) s << "\\b "; - if (elem.isItalic()) s << "\\i "; - if (elem.isUnderline()) s << "\\ul "; - return s.str(); -} - -string RtfGenerator::getCloseTag(const ElementStyle &elem) -{ - ostringstream s; - if (elem.isBold()) s << "\\b0 "; - if (elem.isItalic()) s << "\\i0 "; - if (elem.isUnderline()) s << "\\ul0 "; - s << "}}"; - return s.str(); -} - -RtfGenerator::RtfGenerator(const string &colourTheme) - : CodeGenerator( colourTheme) -{ - styleTagOpen.push_back(getOpenTag(STANDARD, docStyle.getDefaultStyle())); - styleTagOpen.push_back(getOpenTag(STRING, docStyle.getStringStyle())); - styleTagOpen.push_back(getOpenTag(NUMBER, docStyle.getNumberStyle())); - styleTagOpen.push_back(getOpenTag(SL_COMMENT, docStyle.getSingleLineCommentStyle())); - styleTagOpen.push_back(getOpenTag(ML_COMMENT_BEGIN,docStyle.getCommentStyle())); - styleTagOpen.push_back(getOpenTag(ESC_CHAR, docStyle.getEscapeCharStyle())); - styleTagOpen.push_back(getOpenTag(DIRECTIVE_LINE, docStyle.getDirectiveStyle())); - styleTagOpen.push_back(getOpenTag(DIRECTIVE_STRING, docStyle.getDirectiveStringStyle())); - styleTagOpen.push_back(getOpenTag(LINENUMBER, docStyle.getLineStyle())); - styleTagOpen.push_back(getOpenTag(SYMBOL, docStyle.getSymbolStyle())); - - styleTagClose.push_back(getCloseTag(docStyle.getDefaultStyle())); - styleTagClose.push_back(getCloseTag(docStyle.getStringStyle())); - styleTagClose.push_back(getCloseTag(docStyle.getNumberStyle())); - styleTagClose.push_back(getCloseTag(docStyle.getSingleLineCommentStyle())); - styleTagClose.push_back(getCloseTag(docStyle.getCommentStyle())); - styleTagClose.push_back(getCloseTag(docStyle.getEscapeCharStyle())); - styleTagClose.push_back(getCloseTag(docStyle.getDirectiveStyle())); - styleTagClose.push_back(getCloseTag(docStyle.getDirectiveStringStyle())); - styleTagClose.push_back(getCloseTag(docStyle.getLineStyle())); - styleTagClose.push_back(getCloseTag(docStyle.getSymbolStyle())); - - newLineTag = "\\par\\pard\n"; - spacer = " "; -} - -RtfGenerator::RtfGenerator() -{} -RtfGenerator::~RtfGenerator() -{} - -string RtfGenerator::getHeader(const string & title) -{ - return string(); -} - -void RtfGenerator::printBody() -{ - *out << "{\\rtf1\\ansi\\uc0 \\deff1" - << "{\\fonttbl{\\f1\\fmodern\\fprq1\\fcharset0 Courier;}}" - << "{\\colortbl;"; - - *out << formatStyleAttributes(docStyle.getDefaultStyle()); - - *out << formatStyleAttributes(docStyle.getStringStyle()); - *out << formatStyleAttributes(docStyle.getNumberStyle()); - *out << formatStyleAttributes(docStyle.getSingleLineCommentStyle()); - - *out << formatStyleAttributes(docStyle.getCommentStyle()); - *out << formatStyleAttributes(docStyle.getEscapeCharStyle()); - *out << formatStyleAttributes(docStyle.getDirectiveStyle()); - - *out << formatStyleAttributes(docStyle.getDirectiveStringStyle()); - *out << formatStyleAttributes(docStyle.getLineStyle()); - *out << formatStyleAttributes(docStyle.getSymbolStyle()); - - /* For output formats which can refer to external styles it is more safe - to use the colour theme's keyword class names, since the language - definitions (which may change during a batch conversion) do not have to define - all keyword classes, that are needed to highlight all input files correctly. - It is ok for RTF to use the language definition's class names, because RTF - does not refer to external styles. - We cannot use the theme's class names, because KSIterator returns an - alphabetically ordered list, which is not good because RTF is dependent - on the order. We access the keyword style with an ID, which is calculated - ignoring the alphabetic order. - */ - vector<string> keywordClasses = langInfo.getKeywordClasses(); - for (unsigned int i=0;i<keywordClasses.size();i++){ - *out << formatStyleAttributes(docStyle.getKeywordStyle(keywordClasses[i])); - } - - *out << "}\n{\\info }\\paperw11900\\paperh16820\\margl560\\margr560\\margt840" - << "\\margb840\\widowctrl\\ftnbj\\aenddoc\\formshade \\fet0\\sectd" - << "\\linex0\\endnhere\\plain\\f1\\fs20\n\\pard "; - processRootState(); - *out << "}}"<<endl; -} - - -string RtfGenerator::getFooter() -{ - return string(); -} - -/** Gibt RTF-Code der Sonderzeichen zurueck */ -string RtfGenerator::maskCharacter(unsigned char c) -{ - switch (c) - { - case '}' : - case '{' : - case '\\' : - { - string m; - m="\\"; - return m+=c; - } - break; - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - { - string m; - m="{"; - m+=c; - m+="}"; - return m; - } - break; - case AUML_LC: - return "\\'e4"; - break; - case OUML_LC: - return "\\'f6"; - break; - case UUML_LC: - return "\\'fc"; - break; - case AUML_UC: - return "\\'c4"; - break; - case OUML_UC: - return "\\'d6"; - break; - case UUML_UC: - return "\\'dc"; - break; - - case AACUTE_LC: - return "\\'e1"; - break; - case EACUTE_LC: - return "\\'e9"; - break; - case OACUTE_LC: - return "\\'f3"; - break; - case UACUTE_LC: - return "\\'fa"; - break; - - case AGRAVE_LC: - return "\\'e0"; - break; - case EGRAVE_LC: - return "\\'e8"; - break; - case OGRAVE_LC: - return "\\'f2"; - break; - case UGRAVE_LC: - return "\\'f9"; - break; - - case AACUTE_UC: - return "\\'c1"; - break; - case EACUTE_UC: - return "\\'c9"; - break; - case OACUTE_UC: - return "\\'d3"; - break; - case UACUTE_UC: - return "\\'da"; - break; - case AGRAVE_UC: - return "\\'c0"; - break; - case EGRAVE_UC: - return "\\'c8"; - break; - case OGRAVE_UC: - return "\\'d2"; - break; - case UGRAVE_UC: - return "\\'d9"; - break; - - case SZLIG: - return "\\'df"; - break; - // skip first byte of multibyte chracters - /* #ifndef _WIN32 - case 195: - return string(""); - break; -#endif*/ - - default : - { - string m; - return m += c; - } - } -} - -string RtfGenerator::getMatchingOpenTag(unsigned int styleID){ - return getOpenTag(KEYWORD+styleID, - docStyle.getKeywordStyle(langInfo.getKeywordClasses()[styleID])); -} - -string RtfGenerator::getMatchingCloseTag(unsigned int styleID){ - return getCloseTag(docStyle.getKeywordStyle(langInfo.getKeywordClasses()[styleID])); -} - - -} -/*************************************************************************** - rtfcode.h - description - ------------------- - begin : Die Jul 9 2002 - copyright : (C) 2002 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef RTFGENERATOR_H -#define RTFGENERATOR_H - -#include <iostream> -#include <fstream> -#include <string> -#include <sstream> - -#include "codegenerator.h" -#include "charcodes.h" -#include "version.h" - -namespace highlight { - -/** - \brief This class generates RTF. - - It contains information about the resulting document structure (document - header and footer), the colour system, white space handling and text - formatting attributes. - -* @author Andre Simon -*/ - -class RtfGenerator : public highlight::CodeGenerator - { - public: - - /** Constructor - \param colourTheme Name of Colour theme to use - */ - RtfGenerator( const string &colourTheme); - RtfGenerator(); - ~RtfGenerator(); - - /** prints document header - \param title Title of the document - */ - string getHeader(const string & title); - - /** Prints document footer*/ - string getFooter(); - - /** Prints document body*/ - void printBody(); - - private: - - /** \return escaped character*/ - virtual string maskCharacter(unsigned char ); - - /**\return text formatting attributes in RTF format */ - string formatStyleAttributes( const ElementStyle & col); - - /** gibt RTF-"Tags" zurueck (Farbindex+bold+kursiv)*/ - string getOpenTag(int styleNumber,const ElementStyle &); - - string getCloseTag(const ElementStyle &); - - string getMatchingOpenTag(unsigned int styleID); - string getMatchingCloseTag(unsigned int styleID); - }; - -} -#endif -/*************************************************************************** - stringtools.cpp - description - ------------------- - begin : Mon Dec 10 2001 - copyright : (C) 2001 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "stringtools.h" - -#include <sstream> -#include <iostream> -#include <cctype> - -using namespace std; - -namespace StringTools - { -// Make a lowercase copy of s: -// (C) Bruce Eckel, Thinking in C++ Vol 2 - -string lowerCase(const string& s) -{ - char* buf = new char[s.length()]; - s.copy(buf, s.length()); - for(unsigned int i = 0; i < s.length(); i++) - buf[i] = tolower(buf[i]); - string r(buf, s.length()); - delete buf; - return r; -} - -int str2int(string s) -{ - istringstream os(s); - int intVal; - os >> intVal; - return intVal; -} - - bool isAlpha(unsigned char c) - { - return (isalpha(c) || c == '_'); - } - -string trimRight(const string &value) - { - string::size_type where = value.find_last_not_of(" \t\r"); - - if (where == string::npos) - // string has nothing but space - return string(); - - if (where == (value.length() - 1)) - // string has no trailing space, don't copy its contents - return value; - - return value.substr(0, where + 1); - } - -unsigned char getNextNonWs(const string &line, int index) -{ - unsigned char c; - do - { - c=line[index++]; - } - while (isspace(c)); - return c; -} - -string getParantheseVal(const string &s){ - string::size_type openPos=s.find('('); - string::size_type closePos=s.rfind(')'); - if (openPos ==string::npos || closePos==string::npos){ - return string(); - } - return s.substr(openPos+1, closePos-openPos-1); - -} - -} -/*************************************************************************** - stringtools.h - description - ------------------- - begin : Mon Dec 10 2001 - copyright : (C) 2001 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef STRINGTOOLS_H -#define STRINGTOOLS_H - -#include <string> - -using namespace std; - -/**\brief Contains methods for string manipulation - *@author Andre Simon - */ - -namespace StringTools - { - - /** \param s String - \returns lowercase string */ - string lowerCase(const string &s); - - /** \param s String - \returns Integer value */ - int str2int(string s); - - /** \return true if c is alpa or underscore */ - bool isAlpha(unsigned char c); - - /** \param value String - \return string trimmed on the left side - */ - string trimRight(const string &value); - - /** \return next character in line starting from index, which is no whitespace*/ - unsigned char getNextNonWs(const string &line, int index=0); - - /** \param s String, containing a opening and a closing paranthesis - \return value between "(", ")" */ - string getParantheseVal(const string &s); - -} - -#endif -/*************************************************************************** - stylecolour.cpp - description - ------------------- - begin : Die Nov 5 2002 - copyright : (C) 2002 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "stylecolour.h" - -using std::string; - -namespace highlight { - -StyleColour::StyleColour(const string & r_hex, const string & g_hex, const string & b_hex) - : r(r_hex), g(g_hex), b(b_hex) -{} -StyleColour::StyleColour() - : r("00"), g("00"), b("00") -{} - -//Parst PArameter aus style-Datei -StyleColour::StyleColour(const string & styleColourString) -{ - setRGBValues(styleColourString); -} - -void StyleColour::setRGBValues(const string & styleColourString){ - //Stringstream zum Einlesen der Tokens: - istringstream valueStream(styleColourString.c_str()); - valueStream >> r; - valueStream >> g; - valueStream >> b; -} - -void StyleColour::setRedValue(const string & r_hex) -{ - r = r_hex; -} - -void StyleColour::setGreenValue(const string & g_hex) -{ - g = g_hex; -} - -void StyleColour::setBlueValue(const string & b_hex) -{ - b = b_hex; -} - -string& StyleColour::getHexRedValue() -{ - return r; -} -string& StyleColour::getHexGreenValue() -{ - return g; -} -string& StyleColour::getHexBlueValue() -{ - return b; -} - - -string StyleColour::getRTFRedValue() -{ - return int2str(hex2dec(r)); -} -string StyleColour::getRTFGreenValue() -{ - return int2str(hex2dec(g)); -} -string StyleColour::getRTFBlueValue() -{ - return int2str(hex2dec(b)); -} - - -string StyleColour::getLatexRedValue() -{ - return float2str((float)hex2dec(r)/255); -} -string StyleColour::getLatexGreenValue() -{ - return float2str((float)hex2dec(g)/255); -} -string StyleColour::getLatexBlueValue() -{ - return float2str((float)hex2dec(b)/255); -} - -// Konvertieren von RGB nach CYM -string StyleColour::getTexRedValue() -{ - return float2str(1-(float)hex2dec(r)/255); -} -string StyleColour::getTexGreenValue() -{ - return float2str(1-(float)hex2dec(g)/255); -} -string StyleColour::getTexBlueValue() -{ - return float2str(1-(float)hex2dec(b)/255); -} - - -string StyleColour::int2str(const int num) -{ - std::ostringstream outStream; - outStream << num; - - return outStream.str(); -} - -string StyleColour::float2str(const double num) -{ - std::ostringstream outStream; - outStream << ( floor ( num * 100 + .5 ) / 100); - - return outStream.str(); -} - -int StyleColour::hex2dec(const string &hexVal) -{ - - if (hexVal.length() != 2) - return 0; - - unsigned int decVal=0, koeff=16; - - for (int i=0; i<2;i++ ) - { - if ((hexVal[i] >= '0')&& (hexVal[i]<= '9' )) - { - decVal += (koeff * (hexVal[i]-'0')); - - } - if ((hexVal[i] >= 'a')&& (hexVal[i]<= 'f' )) - { - decVal +=( koeff * (hexVal[i]-87)); - } - if ((hexVal[i] >= 'A')&& (hexVal[i]<= 'F' )) - { - decVal += (koeff * (hexVal[i]-55)); - } - koeff=1; - } - return decVal; -} - -} - -/*************************************************************************** - stylecolour.h - description - ------------------- - begin : Die Nov 5 2002 - copyright : (C) 2002 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef STYLECOLOUR_H -#define STYLECOLOUR_H - -#include <string> -#include <sstream> -#include <fstream> -#include <cmath> -#include <sstream> - -using namespace std; - -namespace highlight { - -/**\brief Stores colours and returns red, green and blue values in different formats -* @author Andre Simon - */ - -class StyleColour - { - public: - /** Constructor - \param r_hex Red value in hex notation - \param g_hex Blue value in hex notation - \param b_hex Green value in hex notation - */ - StyleColour(const string & r_hex, const string & g_hex, const string & b_hex); - - /** Constructor - \param styleColourString String with rgb values - */ - StyleColour(const string & styleColourString); - - StyleColour(); - ~StyleColour(){}; - - /** Sets red, green and blue values - \param styleColourString String containing colour attributes - */ - void setRGBValues(const string & styleColourString); - - /** Sets red value - \param r_hex New red value */ - void setRedValue(const string & r_hex); - - /** Sets green value - \param g_hex New green value */ - void setGreenValue(const string & g_hex); - - /** Sets blue value - \param b_hex New blue value */ - void setBlueValue(const string & b_hex); - - /** \return Red value in hex format */ - string& getHexRedValue(); - /** \return Green value in hex format */ - string& getHexGreenValue(); - /** \return Blue value in hex format */ - string& getHexBlueValue(); - - /** \return Red value in latex format */ - string getLatexRedValue(); - /** \return Green value in latex format */ - string getLatexGreenValue(); - /** \return Blue value in latex format */ - string getLatexBlueValue(); - - /** \return Red value in tex format */ - string getTexRedValue(); - /** \return Green value in tex format */ - string getTexGreenValue(); - /** \return Blue value in tex format */ - string getTexBlueValue(); - - /** \return Red value in RTF format */ - string getRTFRedValue(); - /** \return Green value in RTF format */ - string getRTFGreenValue(); - /** \return Blue value in RTF format */ - string getRTFBlueValue(); - - private: - string r, g, b; - string int2str(int); - string float2str(double); - int hex2dec(const string &hexVal); - }; - -} - -#endif -/*************************************************************************** - TexGenerator.cpp - description - ------------------- - begin : Mit Jul 24 2002 - copyright : (C) 2002 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "texgenerator.h" - -namespace highlight { - -TexGenerator::TexGenerator(const string &colourTheme): - CodeGenerator( colourTheme) -{ - styleTagOpen.push_back( "{\\hlstd "); - styleTagOpen.push_back( "{\\hlstr "); - styleTagOpen.push_back( "{\\hlnum "); - styleTagOpen.push_back( "{\\hlslc "); - styleTagOpen.push_back( "{\\hlcom "); - styleTagOpen.push_back( "{\\hlesc "); - styleTagOpen.push_back( "{\\hldir "); - styleTagOpen.push_back( "{\\hldstr "); - styleTagOpen.push_back( "{\\hlline "); - styleTagOpen.push_back( "{\\hlsym "); - for (int i=0;i<NUMBER_BUILTIN_STYLES; i++) { - styleTagClose.push_back( "}"); - } - - /*This makes TeX to use every par it encounters (the \\leavevmode has - no effect when TeX is in horizontal mode and when TeX is in vertical - mode, it switches it to horizontal mode).*/ - newLineTag="\\leavevmode\\par\n"; - - spacer = "\\ "; - maskWs=true; - excludeWs=true; - maskWsBegin = "{\\hlstd"; - maskWsEnd = "}"; - styleCommentOpen="%"; -} - -TexGenerator::TexGenerator() -{} -TexGenerator::~TexGenerator() -{} - -string TexGenerator::formatStyleAttributes(const string & elemName,const ElementStyle & elem) -{ - ostringstream s; - s << "\\def\\hl" - << elemName - << "{"; - if (elem.isBold()) - s << "\\bf"; - if (elem.isItalic()) - s << "\\it"; - s << "\\textColor{" - << (elem.getColour().getTexRedValue())<<" " - << (elem.getColour().getTexGreenValue())<<" " - << (elem.getColour().getTexBlueValue())<<" 0.0}}\n"; - return s.str(); -} - -string TexGenerator::getHeader(const string & title) -{ - ostringstream os; - - if (langInfo.getSyntaxHighlight()) { - if (includeStyleDef) { - os << "\n"<<getStyleDefinition(); - os << CodeGenerator::readUserStyleDef(); - } else { - os << "\\input " - << getStyleOutputPath() - << "\n\n"; - } - } - - return os.str(); -} - -void TexGenerator::printBody() -{ - *out << "{\n\\tt\n"; - - processRootState(); - *out << "}\n"; -} - -string TexGenerator::getFooter() -{ - ostringstream os; - os << "\\bye\n" - << "% TeX generated by Highlight " - << HIGHLIGHT_VERSION - << ", " - << HIGHLIGHT_URL - << endl; - return os.str(); -} - -string TexGenerator:: maskCharacter(unsigned char c) -{ - switch (c) - { - case '{': - case '}': - { - string m; - m = "$\\"; - m += c; - m += "$"; - return m; - } - break; - case '^': - return "{\\bf\\^{}}"; - break; - case '_': - return "\\_{}"; - break; - case '&': - case '$': - case '#': - case '%': - { - string m; - m = "\\"; - m += c; - return m; - } - break; - case '\\': - return "$\\backslash$"; - break; - case ' ': - return spacer; - break; - case '+': - case '-': - case '<': - case '>': - case '=': - { - string m; - m = "$\\mathord{"; - m += c; - m += "}$"; - return m; - } - break; - case AUML_LC: - return "\\\"a"; - break; - case OUML_LC: - return "\\\"o"; - break; - case UUML_LC: - return "\\\"u"; - break; - case AUML_UC: - return "\\\"A"; - break; - case OUML_UC: - return "\\\"O"; - break; - case UUML_UC: - return "\\\"U"; - break; - case AACUTE_LC: - return "\\'a"; - break; - case EACUTE_LC: - return "\\'e"; - break; - case OACUTE_LC: - return "\\'o"; - break; - case UACUTE_LC: - return "\\'u"; - break; - case AGRAVE_LC: - return "\\`a"; - break; - case EGRAVE_LC: - return "\\`e"; - break; - case OGRAVE_LC: - return "\\`o"; - break; - case UGRAVE_LC: - return "\\`u"; - break; - case AACUTE_UC: - return "\\'A"; - break; - case EACUTE_UC: - return "\\'E"; - break; - case OACUTE_UC: - return "\\'O"; - break; - case UACUTE_UC: - return "\\'U"; - break; - case AGRAVE_UC: - return "\\`A"; - break; - case EGRAVE_UC: - return "\\`E"; - break; - case UGRAVE_UC: - return "\\`O"; - break; - case OGRAVE_UC: - return "\\`U"; - break; - case SZLIG: - return "\\ss "; - break; - /* #ifndef _WIN32 - // skip first byte of multibyte chracters - case 195: - return string(""); - break; -#endif*/ - - default : - string m; - return m += c; - } -} - -string TexGenerator::getMatchingOpenTag(unsigned int styleID){ - return "{\\hl"+langInfo.getKeywordClasses()[styleID]+" "; - } - -string TexGenerator::getMatchingCloseTag(unsigned int styleID){ - return "}"; -} - - -string TexGenerator::getStyleDefinition() -{ - if (styleDefinitionCache.empty()){ - ostringstream os; - os << formatStyleAttributes("std", docStyle.getDefaultStyle()); - os << formatStyleAttributes("num", docStyle.getNumberStyle()); - os << formatStyleAttributes("esc", docStyle.getEscapeCharStyle()); - os << formatStyleAttributes("str", docStyle.getStringStyle()); - os << formatStyleAttributes("dstr", docStyle.getDirectiveStringStyle()); - os << formatStyleAttributes("slc", docStyle.getSingleLineCommentStyle()); - os << formatStyleAttributes("com", docStyle.getCommentStyle()); - os << formatStyleAttributes("dir", docStyle.getDirectiveStyle()); - os << formatStyleAttributes("line", docStyle.getLineStyle()); - os << formatStyleAttributes("sym", docStyle.getSymbolStyle()); - - KeywordStyles styles = docStyle.getKeywordStyles(); - for (KSIterator it=styles.begin(); it!=styles.end(); it++){ - os << formatStyleAttributes(it->first, *(it->second)); - } - - os << "% The special option is not supported by all dvi drivers\n" - << "\\special{background rgb " - << docStyle.getBgColour().getLatexRedValue() << " " - << docStyle.getBgColour().getLatexGreenValue() << " " - << docStyle.getBgColour().getLatexBlueValue() << "}"; - os << "\n\\nopagenumbers\n" - << "\\input colordvi\n"; - styleDefinitionCache=os.str(); - } - return styleDefinitionCache; -} - - -} -/*************************************************************************** - texcode.h - description - ------------------- - begin : Mit Jul 24 2002 - copyright : (C) 2002 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef TEXGENERATOR_H -#define TEXGENERATOR_H - -#include <string> -#include <iostream> -#include <sstream> - -#include "charcodes.h" -#include "version.h" -#include "codegenerator.h" - - -namespace highlight { - -/** - \brief This class generates TeX. - - It contains information about the resulting document structure (document - header and footer), the colour system, white space handling and text - formatting attributes. - -* @author Andre Simon -*/ - -class TexGenerator : public highlight::CodeGenerator - { - public: - - /** Constructor - \param colourTheme Name of Colour theme to use - */ - TexGenerator(const string &colourTheme); - TexGenerator(); - ~TexGenerator(); - - /** prints document header - \param title Title of the document - */ - string getHeader(const string & title); - - /** Prints document footer*/ - string getFooter(); - - /** Prints document body*/ - void printBody(); - - private: - - string styleDefinitionCache; - - string getStyleDefinition(); - - /** \return escaped character*/ - virtual string maskCharacter(unsigned char ); - - /**\return text formatting attributes in RTF format */ - string formatStyleAttributes(const string & elemName, const ElementStyle & elem); - - string getMatchingOpenTag(unsigned int styleID); - string getMatchingCloseTag(unsigned int styleID); - - }; - -} - -#endif -/*************************************************************************** - version.h - description - ------------------- - begin : Mon March 3 2003 - copyright : (C) 2003 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef VERSION_H -#define VERSION_H - -#define HIGHLIGHT_VERSION "2.2-10" - -#define HIGHLIGHT_URL "http://www.andre-simon.de/" -#define HIGHLIGHT_EMAIL "andre.simon1@gmx.de" - -#endif -/*************************************************************************** - htmlcode.cpp - description - ------------------- - begin : Wed Nov 28 2001 - copyright : (C) 2001 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "xhtmlgenerator.h" - -using namespace std; - -namespace highlight { - -XHtmlGenerator::XHtmlGenerator(void) -{} - -XHtmlGenerator::XHtmlGenerator ( - const string &cssStyle, - const string &enc, - bool omitEnc, - bool withAnchors) - : HtmlGenerator(cssStyle, enc, omitEnc, withAnchors) -{ - fileSuffix=".xhtml"; - brTag="<br />"; - hrTag="<hr />"; - idAttr="id"; - - HTML_FOOTER= - "\n</body>\n</html>\n<!--XHTML generated by highlight " - HIGHLIGHT_VERSION - ", " - HIGHLIGHT_URL - "-->\n"; -} - -string XHtmlGenerator::getHeaderStart(const string &title){ - ostringstream header; - header << "<?xml version=\"1.0\""; - if (!omitEncoding) { - header << " encoding=\"" << encoding << "\""; - } - header << "?>\n<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\"" - << " \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">\n" - << "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n" - << "<head>\n<title>" << title << "</title>\n"; - - return header.str(); -} - - -string XHtmlGenerator::getHeader(const string &title) -{ - ostringstream osPart1; - osPart1 << getHeaderStart((title.empty())?"Source file":title ); - - if (langInfo.getSyntaxHighlight()) - { - if (includeStyleDef) //CSS-Definition in HTML-<head> einfuegen - { - osPart1 << "<style type=\"text/css\">\n"; - osPart1 << "<![CDATA[\n"; - osPart1 << getStyleDefinition(); - osPart1 << CodeGenerator::readUserStyleDef(); - osPart1 << "]]>\n"; - osPart1 << "</style>\n"; - } - else //Referenz auf CSS-Datei einfuegen - { - osPart1 << "<link rel=\"stylesheet\" type=\"text/css\" href=\"" - << getStyleOutputPath() - << "\"" - << "/" - << ">\n"; - } - } - osPart1 << "</head>\n<body class=\"hl\">\n<pre class=\"hl\">"; - - return osPart1.str(); -} - -} -/*************************************************************************** - xhtmlgenerator.h - description - ------------------- - begin : Mo Jun 21 2004 - copyright : (C) 2004 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - - -#ifndef XHTMLGENERATOR_H -#define XHTMLGENERATOR_H - -#include "htmlgenerator.h" - -namespace highlight { - -/** - \brief This class generates XHTML. - - It contains information about the resulting document structure (document - header and footer), the colour system, white space handling and text - formatting attributes. - -* @author Andre Simon -*/ - - -class XHtmlGenerator : public highlight::HtmlGenerator - { - public: - - /** Constructor - \param colourTheme Name of Colour theme to use - \param enc encoding name - \param omitEnc switch to omit encoding information - \param withAnchors Test if HTML anchors should be attached to line numbers - */ - XHtmlGenerator(const string &colourTheme, - const string &enc, - bool omitEnc=false, - bool withAnchors = false); - - XHtmlGenerator(); - - /** Destructor*/ - virtual ~XHtmlGenerator() {}; - - private: - - /** prints document header - \param title Title of the document - */ - string getHeader(const string &title); - - string getHeaderStart(const string &title); - - }; - -} - -#endif -/*************************************************************************** - xmlcode.cpp - description - ------------------- - begin : Do 20.01.2005 - copyright : (C) 2005 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "xmlgenerator.h" - -using namespace std; -namespace highlight { - - XmlGenerator::XmlGenerator(const string &colourTheme,const string &enc, bool omitEnc) - : CodeGenerator(colourTheme), - encoding(enc), omitEncoding(omitEnc) -{ - styleTagOpen.push_back(getOpenTag("def")); - styleTagOpen.push_back(getOpenTag("str")); - styleTagOpen.push_back(getOpenTag("num")); - styleTagOpen.push_back(getOpenTag("slc")); - styleTagOpen.push_back(getOpenTag("com")); - styleTagOpen.push_back(getOpenTag("esc")); - styleTagOpen.push_back(getOpenTag("dir")); - styleTagOpen.push_back(getOpenTag("dstr")); - styleTagOpen.push_back(getOpenTag("line")); - styleTagOpen.push_back(getOpenTag("sym")); - - styleTagClose.push_back(getCloseTag("def")); - styleTagClose.push_back(getCloseTag("str")); - styleTagClose.push_back(getCloseTag("num")); - styleTagClose.push_back(getCloseTag("slc")); - styleTagClose.push_back(getCloseTag("com")); - styleTagClose.push_back(getCloseTag("esc")); - styleTagClose.push_back(getCloseTag("dir")); - styleTagClose.push_back(getCloseTag("dstr")); - styleTagClose.push_back(getCloseTag("line")); - styleTagClose.push_back(getCloseTag("sym")); - - spacer = " "; - newLineTag = "<br />\n"; -} - -string XmlGenerator::getStyleDefinition() -{ - if (styleDefinitionCache.empty()) { - ostringstream os; - os << "\n<style>\n" - << "\t<bgcolor value=\"" - << (docStyle.getBgColour().getHexRedValue()) - << (docStyle.getBgColour().getHexGreenValue()) - << (docStyle.getBgColour().getHexBlueValue()) - << "\" />\n" - << "\t<font size=\"" - << docStyle.getFontSize() - << "\" family=\"Courier\" />\n"; - - os << formatStyleAttributes("def", docStyle.getDefaultStyle()) - << formatStyleAttributes("num", docStyle.getNumberStyle()) - << formatStyleAttributes("esc", docStyle.getEscapeCharStyle()) - << formatStyleAttributes("str", docStyle.getStringStyle()) - << formatStyleAttributes("dstr", docStyle.getDirectiveStringStyle()) - << formatStyleAttributes("slc", docStyle.getSingleLineCommentStyle()) - << formatStyleAttributes("com", docStyle.getCommentStyle()) - << formatStyleAttributes("dir", docStyle.getDirectiveStyle()) - << formatStyleAttributes("sym", docStyle.getSymbolStyle()) - << formatStyleAttributes("line", docStyle.getLineStyle()); - - KeywordStyles styles = docStyle.getKeywordStyles(); - for (KSIterator it=styles.begin(); it!=styles.end(); it++){ - os << formatStyleAttributes(it->first, *(it->second)); - } - os << "</style>\n"; - styleDefinitionCache=os.str(); - } - return styleDefinitionCache; -} - - -string XmlGenerator::formatStyleAttributes(const string & elemName, - const ElementStyle & elem) -{ - ostringstream s; - s << "\t<class name=\"" - << elemName - <<"\" color=\"" - << (elem.getColour().getHexRedValue()) - << (elem.getColour().getHexGreenValue()) - << (elem.getColour().getHexBlueValue() ) - << "\" bold=\"" - << ( elem.isBold() ? "true" :"false" ) - << "\" italic=\"" - << ( elem.isItalic() ? "true" :"false" ) - << "\" underline=\"" - << ( elem.isUnderline() ? "true" :"false" ) - << "\" />\n" ; - return s.str(); -} - - -XmlGenerator::XmlGenerator() -{} -XmlGenerator::~XmlGenerator() -{} - -string XmlGenerator::getOpenTag(const string& styleName ){ - return "<"+styleName+">"; -} - -string XmlGenerator::getCloseTag(const string& styleName ){ - return "</"+styleName+">"; -} - -string XmlGenerator::getHeader(const string & title) -{ - ostringstream header; - header << "<?xml version=\"1.0\""; - if (!omitEncoding) { - header << " encoding=\"" << encoding << "\""; - } - header << "?>\n<document>" << getStyleDefinition(); - return header.str(); -} - -void XmlGenerator::printBody() -{ - *out << "<source>\n"; - processRootState(); - *out << "</source>\n"; -} - - -string XmlGenerator::getFooter() -{ - ostringstream os; - os <<"</document>\n"; - os<< "<!-- XML generated by Highlight " - << HIGHLIGHT_VERSION - << ", " - << HIGHLIGHT_URL - <<" -->\n"; - return os.str(); -} - -string XmlGenerator::maskCharacter(unsigned char c) -{ - switch (c) - { - case '<' : - return "<"; - break; - case '>' : - return ">"; - break; - case '&' : - return "&"; - break; - case '\"' : - return """; - break; - -// skip first byte of multibyte chracters - /* #ifndef _WIN32 - case 195: - return string(""); - break; -#endif*/ - - default: - string m; - m += c; - return m; - } -} - -/*string XmlGenerator::getNewLine(){ - string nlStr; - if (currentState!=_UNKNOWN){ - nlStr+=styleTagClose[getStyleID(currentState, currentKeywordClass)]; - } - nlStr += newLineTag; - if (currentState!=_UNKNOWN){ - nlStr+=styleTagOpen[getStyleID(currentState, currentKeywordClass)]; - } - return nlStr; -} -*/ -string XmlGenerator::getMatchingOpenTag(unsigned int styleID){ - return getOpenTag(langInfo.getKeywordClasses()[styleID]); -} - -string XmlGenerator::getMatchingCloseTag(unsigned int styleID){ - return getCloseTag(langInfo.getKeywordClasses()[styleID]); -} - -} -/*************************************************************************** - xmlcode.h - description - ------------------- - begin : Do 20.01.2005 - copyright : (C) 2005 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef XMLGENERATOR_H -#define XMLGENERATOR_H - -#include <string> -#include <sstream> -#include <iostream> - -#include "codegenerator.h" -#include "version.h" - -namespace highlight { - -/** - \brief This class generates XML. - - It contains information about the resulting document structure (document - header and footer), the colour system, white space handling and text - formatting attributes. - -* @author Andre Simon -*/ - -class XmlGenerator : public highlight::CodeGenerator - { - public: - - /** Constructor - \param colourTheme Name of Colour theme to use - \param enc encoding name - \param omitEnc switch to omit encoding information - */ - XmlGenerator( const string &colourTheme,const string &enc, bool omitEnc=false); - - XmlGenerator(); - - ~XmlGenerator(); - - /** prints document header - \param title Title of the document - */ - string getHeader(const string & title); - - /** Prints document footer*/ - string getFooter(); - - /** Prints document body*/ - void printBody(); - - private: - - string styleDefinitionCache, encoding; - - bool omitEncoding; - - string getStyleDefinition(); - - string formatStyleAttributes(const string &, const ElementStyle &); - - /** \return escaped character*/ - virtual string maskCharacter(unsigned char ); - - -// string getNewLine(); - - string getOpenTag(const string& ); - string getCloseTag(const string& ); - - string getMatchingOpenTag(unsigned int styleID); - string getMatchingCloseTag(unsigned int styleID); - }; - -} - -#endif -/*************************************************************************** - xslfocode.cpp - description - ------------------- - begin : Do 11.12.2003 - copyright : (C) 2003 by André Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#include "xslfogenerator.h" - -using namespace std; -namespace highlight { - -XslFoGenerator::XslFoGenerator(const string &colourTheme, - const string &enc, - bool omitEnc, - bool fopCompatible) - : CodeGenerator(colourTheme), - encoding(enc), - fopOutput(fopCompatible), - omitEncoding(omitEnc) -{ - styleTagOpen.push_back( getOpenTag(docStyle.getDefaultStyle())); - styleTagOpen.push_back( getOpenTag(docStyle.getStringStyle())); - styleTagOpen.push_back( getOpenTag(docStyle.getNumberStyle())); - styleTagOpen.push_back( getOpenTag(docStyle.getSingleLineCommentStyle())); - styleTagOpen.push_back( getOpenTag(docStyle.getCommentStyle())); - styleTagOpen.push_back( getOpenTag(docStyle.getEscapeCharStyle())); - styleTagOpen.push_back( getOpenTag(docStyle.getDirectiveStyle())); - styleTagOpen.push_back( getOpenTag(docStyle.getDirectiveStringStyle())); - styleTagOpen.push_back( getOpenTag(docStyle.getLineStyle())); - styleTagOpen.push_back( getOpenTag(docStyle.getSymbolStyle())); - snl << " <fo:block font-size=\"" - << docStyle.getFontSize() - << "pt\" font-family=\"Courier\" white-space-collapse=\"false\" " - << "wrap-option=\"wrap\" line-height=\"12pt\" background-color=\"#" - << (docStyle.getBgColour().getHexRedValue()) - << (docStyle.getBgColour().getHexGreenValue()) - << (docStyle.getBgColour().getHexBlueValue()) - << "\">"; - - for (int i=0;i<NUMBER_BUILTIN_STYLES; i++) - { - styleTagClose.push_back( "</fo:inline>"); - } - if (fopOutput) - newLineTag ="</fo:block>\n<fo:block>"; - else - newLineTag ="</fo:block>\n"+ snl.str(); - - spacer = " "; -} - -XslFoGenerator::XslFoGenerator() -{} -XslFoGenerator::~XslFoGenerator() -{} - -string XslFoGenerator::getOpenTag(const ElementStyle &elem) -{ - ostringstream s; - s << "<fo:inline color=\"#" - << (elem.getColour().getHexRedValue()) - << (elem.getColour().getHexGreenValue()) - << (elem.getColour().getHexBlueValue()) - << "\""; - s << ( elem.isBold() ?" font-weight=\"bold\"" :"" ) - << ( elem.isItalic() ?" font-style=\"italic\"" :"" ) - << ( elem.isUnderline() ?" text-decoration=\"underline\"" :"" ); - s << ">"; - return s.str(); -} - -string XslFoGenerator::getHeader(const string & title) -{ - ostringstream os; - os << "<?xml version=\"1.0\""; - if (!omitEncoding) { - os << " encoding=\"" << encoding << "\""; - } - os << "?>\n<fo:root xmlns:fo=\"http://www.w3.org/1999/XSL/Format\">\n" - << "<fo:layout-master-set>\n" - << "<fo:simple-page-master master-name=\"DINA4\"\n" - << " page-height=\"29.7cm\"\n" - << " page-width=\"21cm\"\n" - << " margin-top=\"1cm\"\n" - << " margin-bottom=\"2cm\"\n" - << " margin-left=\"2.5cm\"\n" - << " margin-right=\"2.5cm\">\n" - << "<fo:region-body />\n" - << "</fo:simple-page-master>\n" - << "<fo:page-sequence-master master-name=\"basic\">\n" - << "<fo:repeatable-page-master-alternatives>\n" - << "<fo:conditional-page-master-reference master-reference=\"DINA4\" />\n" - << "</fo:repeatable-page-master-alternatives>\n" - << "</fo:page-sequence-master>\n" - << "</fo:layout-master-set>\n\n" - << "<fo:page-sequence master-reference=\"basic\">\n" - << " <fo:flow flow-name=\"xsl-region-body\">\n"; - if (fopOutput) - os << snl.str()<< "<fo:block>"; - else - os << snl.str(); - - return os.str(); -} - -/** gibt RTF-Text aus */ -void XslFoGenerator::printBody() -{ - processRootState(); -} - - -string XslFoGenerator::getFooter() -{ - ostringstream os; - if (fopOutput) - os <<"\n</fo:block>"; - os <<"\n</fo:block>\n </fo:flow>\n</fo:page-sequence>\n</fo:root>"<<endl - << "<!-- XSL-FO generated by Highlight " - << HIGHLIGHT_VERSION - << ", " - << HIGHLIGHT_URL - <<" -->\n"; - return os.str(); -} - -/** Gibt RTF-Code der Sonderzeichen zurueck */ -string XslFoGenerator::maskCharacter(unsigned char c) -{ - switch (c) - { - case '<' : - return "<"; - break; - case '>' : - return ">"; - break; - case '&' : - return "&"; - break; - case '\"' : - return """; - break; - -// skip first byte of multibyte chracters - /*#ifndef _WIN32 - case 195: - return string(""); - break; -#endif*/ - - default: - string m; - m += c; - return m; - } -} - -/*string XslFoGenerator::getNewLine(){ - string nlStr; - - if (currentState!=_UNKNOWN){ - nlStr+=styleTagClose[getStyleID(currentState, currentKeywordClass)]; -} - nlStr += newLineTag; - if (currentState!=_UNKNOWN){ - nlStr+=styleTagOpen[getStyleID(currentState, currentKeywordClass)]; -} - return nlStr; -}*/ - -string XslFoGenerator::getMatchingOpenTag(unsigned int styleID){ - return getOpenTag(docStyle.getKeywordStyle(langInfo.getKeywordClasses()[styleID])); -} - -string XslFoGenerator::getMatchingCloseTag(unsigned int styleID){ - return "</fo:inline>"; -} - -} -/*************************************************************************** - xslfocode.h - description - ------------------- - begin : Do 11.12.2003 - copyright : (C) 2003 by Andre Simon - email : andre.simon1@gmx.de - ***************************************************************************/ - -/*************************************************************************** - * * - * 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. * - * * - ***************************************************************************/ - -#ifndef XSLFOGENERATOR_H -#define XSLFOGENERATOR_H - - -#include <string> -#include <sstream> -#include <iostream> -#include <fstream> - -#include "codegenerator.h" -#include "version.h" - -namespace highlight { - -/** - \brief This class generates XSL-FO. - - It contains information about the resulting document structure (document - header and footer), the colour system, white space handling and text - formatting attributes. - -* @author Andre Simon -*/ - -class XslFoGenerator : public highlight::CodeGenerator - { - public: - - /** Constructor - \param colourTheme Name of Colour theme to use - \param enc encoding name - \param omitEnc switch to omit encoding information - \param fopCompatible Test if output should be compatible with Apache FOP 0.20.5 - */ - XslFoGenerator( const string &colourTheme, - const string &enc, - bool omitEnc=false, - bool fopCompatible=false); - - XslFoGenerator(); - - ~XslFoGenerator(); - - /** prints document header - \param title Title of the document - */ - string getHeader(const string & title); - - /** Prints document footer*/ - string getFooter(); - - /** Prints document body*/ - void printBody(); - - private: - ostringstream snl; - - string styleDefinition, encoding; - bool fopOutput, omitEncoding; - - /** \return escaped character*/ - virtual string maskCharacter(unsigned char ); - - string getOpenTag(const ElementStyle &); - - // string getNewLine(); - - string getMatchingOpenTag(unsigned int styleID); - string getMatchingCloseTag(unsigned int styleID); - }; - -} - -#endif |